From 197a82e5421eb9e695201c666a3c04e5a0cdd4e7 Mon Sep 17 00:00:00 2001 From: Jakub Bednar Date: Thu, 3 Mar 2022 09:34:29 +0100 Subject: [PATCH 01/46] feat: prepare async client --- influxdb_client/__init__.py | 4 - influxdb_client/_async/__init__.py | 1 + influxdb_client/_async/api_client.py | 652 ++++++++++++++++++++++ influxdb_client/_async/rest.py | 245 ++++++++ influxdb_client/_sync/__init__.py | 1 + influxdb_client/{ => _sync}/api_client.py | 2 +- influxdb_client/_sync/rest.py | 349 ++++++++++++ influxdb_client/client/influxdb_client.py | 6 +- influxdb_client/rest.py | 333 ----------- 9 files changed, 1252 insertions(+), 341 deletions(-) create mode 100644 influxdb_client/_async/__init__.py create mode 100644 influxdb_client/_async/api_client.py create mode 100644 influxdb_client/_async/rest.py create mode 100644 influxdb_client/_sync/__init__.py rename influxdb_client/{ => _sync}/api_client.py (99%) create mode 100644 influxdb_client/_sync/rest.py diff --git a/influxdb_client/__init__.py b/influxdb_client/__init__.py index d80e534d..9e926915 100644 --- a/influxdb_client/__init__.py +++ b/influxdb_client/__init__.py @@ -56,8 +56,6 @@ from influxdb_client.service.views_service import ViewsService from influxdb_client.service.write_service import WriteService -# import ApiClient -from influxdb_client.api_client import ApiClient from influxdb_client.configuration import Configuration # import models into sdk package from influxdb_client.domain.ast_response import ASTResponse @@ -317,8 +315,6 @@ from influxdb_client.domain.template_export_by_id_org_ids import TemplateExportByIDOrgIDs from influxdb_client.domain.template_export_by_id_resource_filters import TemplateExportByIDResourceFilters from influxdb_client.domain.template_export_by_id_resources import TemplateExportByIDResources -from influxdb_client.domain.template_export_by_name import TemplateExportByName -from influxdb_client.domain.template_export_by_name_resources import TemplateExportByNameResources from influxdb_client.domain.template_kind import TemplateKind from influxdb_client.domain.template_summary import TemplateSummary from influxdb_client.domain.template_summary_diff import TemplateSummaryDiff diff --git a/influxdb_client/_async/__init__.py b/influxdb_client/_async/__init__.py new file mode 100644 index 00000000..743539c5 --- /dev/null +++ b/influxdb_client/_async/__init__.py @@ -0,0 +1 @@ +"""Asynchronous REST APIs.""" diff --git a/influxdb_client/_async/api_client.py b/influxdb_client/_async/api_client.py new file mode 100644 index 00000000..7a5ecef8 --- /dev/null +++ b/influxdb_client/_async/api_client.py @@ -0,0 +1,652 @@ +# coding: utf-8 +""" +InfluxDB OSS API Service. + +The InfluxDB v2 API provides a programmatic interface for all interactions with InfluxDB. Access the InfluxDB API using the `/api/v2/` endpoint. # noqa: E501 + +OpenAPI spec version: 2.0.0 +Generated by: https://openapi-generator.tech +""" + +from __future__ import absolute_import + +import datetime +import json +import mimetypes +from multiprocessing.pool import ThreadPool +import os +import re +import tempfile + +# python 2 and python 3 compatibility library +import six +from six.moves.urllib.parse import quote + +from influxdb_client.configuration import Configuration +import influxdb_client.domain +from influxdb_client._async import rest + + +class ApiClientAsync(object): + """Generic API client for OpenAPI client library Build. + + OpenAPI generic API client. This client handles the client- + server communication, and is invariant across implementations. Specifics of + the methods and models for each application are generated from the OpenAPI + templates. + + NOTE: This class is auto generated by OpenAPI Generator. + Ref: https://openapi-generator.tech + Do not edit the class manually. + + :param configuration: .Configuration object for this client + :param header_name: a header to pass when making calls to the API. + :param header_value: a header value to pass when making calls to + the API. + :param cookie: a cookie to include in the header when making calls + to the API + :param pool_threads: The number of threads to use for async requests + to the API. More threads means more concurrent API requests. + """ + + PRIMITIVE_TYPES = (float, bool, bytes, six.text_type) + six.integer_types + NATIVE_TYPES_MAPPING = { + 'int': int, + 'long': int if six.PY3 else long, # noqa: F821 + 'float': float, + 'str': str, + 'bool': bool, + 'date': datetime.date, + 'datetime': datetime.datetime, + 'object': object, + } + _pool = None + + def __init__(self, configuration=None, header_name=None, header_value=None, + cookie=None, pool_threads=None, retries=False): + """Initialize generic API client.""" + if configuration is None: + configuration = Configuration() + self.configuration = configuration + self.pool_threads = pool_threads + + self.rest_client = rest.RESTClientObjectAsync(configuration, retries=retries) + self.default_headers = {} + if header_name is not None: + self.default_headers[header_name] = header_value + self.cookie = cookie + # Set default User-Agent. + from influxdb_client import CLIENT_VERSION + self.user_agent = f'influxdb-client-python/{CLIENT_VERSION}' + + async def close(self): + await self.rest_client.close() + """Dispose pools.""" + if self._pool: + self._pool.close() + self._pool.join() + self._pool = None + if self.rest_client and self.rest_client.pool_manager and hasattr(self.rest_client.pool_manager, 'clear'): + self.rest_client.pool_manager.clear() + + @property + def pool(self): + """Create thread pool on first request avoids instantiating unused threadpool for blocking clients.""" + if self._pool is None: + self._pool = ThreadPool(self.pool_threads) + return self._pool + + @property + def user_agent(self): + """User agent for this API client.""" + return self.default_headers['User-Agent'] + + @user_agent.setter + def user_agent(self, value): + """Set User agent for this API client.""" + self.default_headers['User-Agent'] = value + + def set_default_header(self, header_name, header_value): + """Set HTTP header for this API client.""" + self.default_headers[header_name] = header_value + + async def __call_api( + self, resource_path, method, path_params=None, + query_params=None, header_params=None, body=None, post_params=None, + files=None, response_type=None, auth_settings=None, + _return_http_data_only=None, collection_formats=None, + _preload_content=True, _request_timeout=None, urlopen_kw=None): + + config = self.configuration + + # header parameters + header_params = header_params or {} + config.update_request_header_params(resource_path, header_params) + header_params.update(self.default_headers) + if self.cookie: + header_params['Cookie'] = self.cookie + if header_params: + header_params = self.sanitize_for_serialization(header_params) + header_params = dict(self.parameters_to_tuples(header_params, + collection_formats)) + + # path parameters + if path_params: + path_params = self.sanitize_for_serialization(path_params) + path_params = self.parameters_to_tuples(path_params, + collection_formats) + for k, v in path_params: + # specified safe chars, encode everything + resource_path = resource_path.replace( + '{%s}' % k, + quote(str(v), safe=config.safe_chars_for_path_param) + ) + + # query parameters + if query_params: + query_params = self.sanitize_for_serialization(query_params) + query_params = self.parameters_to_tuples(query_params, + collection_formats) + + # post parameters + if post_params or files: + post_params = self.prepare_post_parameters(post_params, files) + post_params = self.sanitize_for_serialization(post_params) + post_params = self.parameters_to_tuples(post_params, + collection_formats) + + # auth setting + self.update_params_for_auth(header_params, query_params, auth_settings) + + # body + if body: + body = self.sanitize_for_serialization(body) + body = config.update_request_body(resource_path, body) + + # request url + url = self.configuration.host + resource_path + + urlopen_kw = urlopen_kw or {} + + # perform request and return response + response_data = await self.request( + method, url, query_params=query_params, headers=header_params, + post_params=post_params, body=body, + _preload_content=_preload_content, + _request_timeout=_request_timeout, **urlopen_kw) + + self.last_response = response_data + + return_data = response_data + if _preload_content: + # deserialize response data + if response_type: + return_data = self.deserialize(response_data, response_type) + else: + return_data = None + + if _return_http_data_only: + return (return_data) + else: + return (return_data, response_data.status, + response_data.getheaders()) + + def sanitize_for_serialization(self, obj): + """Build a JSON POST object. + + If obj is None, return None. + If obj is str, int, long, float, bool, return directly. + If obj is datetime.datetime, datetime.date + convert to string in iso8601 format. + If obj is list, sanitize each element in the list. + If obj is dict, return the dict. + If obj is OpenAPI model, return the properties dict. + + :param obj: The data to serialize. + :return: The serialized form of data. + """ + if obj is None: + return None + elif isinstance(obj, self.PRIMITIVE_TYPES): + return obj + elif isinstance(obj, list): + return [self.sanitize_for_serialization(sub_obj) + for sub_obj in obj] + elif isinstance(obj, tuple): + return tuple(self.sanitize_for_serialization(sub_obj) + for sub_obj in obj) + elif isinstance(obj, (datetime.datetime, datetime.date)): + return obj.isoformat() + + if isinstance(obj, dict): + obj_dict = obj + else: + # Convert model obj to dict except + # attributes `openapi_types`, `attribute_map` + # and attributes which value is not None. + # Convert attribute name to json key in + # model definition for request. + obj_dict = {obj.attribute_map[attr]: getattr(obj, attr) + for attr, _ in six.iteritems(obj.openapi_types) + if getattr(obj, attr) is not None} + + return {key: self.sanitize_for_serialization(val) + for key, val in six.iteritems(obj_dict)} + + def deserialize(self, response, response_type): + """Deserializes response into an object. + + :param response: RESTResponse object to be deserialized. + :param response_type: class literal for + deserialized object, or string of class name. + + :return: deserialized object. + """ + # handle file downloading + # save response body into a tmp file and return the instance + if response_type == "file": + return self.__deserialize_file(response) + + # fetch data from response object + try: + data = json.loads(response.data) + except ValueError: + data = response.data + + return self.__deserialize(data, response_type) + + def __deserialize(self, data, klass): + """Deserializes dict, list, str into an object. + + :param data: dict, list or str. + :param klass: class literal, or string of class name. + + :return: object. + """ + if data is None: + return None + + if type(klass) == str: + if klass.startswith('list['): + sub_kls = re.match(r'list\[(.*)\]', klass).group(1) + return [self.__deserialize(sub_data, sub_kls) + for sub_data in data] + + if klass.startswith('dict('): + sub_kls = re.match(r'dict\(([^,]*), (.*)\)', klass).group(2) + return {k: self.__deserialize(v, sub_kls) + for k, v in six.iteritems(data)} + + # convert str to class + if klass in self.NATIVE_TYPES_MAPPING: + klass = self.NATIVE_TYPES_MAPPING[klass] + else: + klass = getattr(influxdb_client.domain, klass) + + if klass in self.PRIMITIVE_TYPES: + return self.__deserialize_primitive(data, klass) + elif klass == object: + return self.__deserialize_object(data) + elif klass == datetime.date: + return self.__deserialize_date(data) + elif klass == datetime.datetime: + return self.__deserialize_datatime(data) + else: + return self.__deserialize_model(data, klass) + + def call_api(self, resource_path, method, + path_params=None, query_params=None, header_params=None, + body=None, post_params=None, files=None, + response_type=None, auth_settings=None, async_req=None, + _return_http_data_only=None, collection_formats=None, + _preload_content=True, _request_timeout=None, urlopen_kw=None): + """Make the HTTP request (synchronous) and Return deserialized data. + + To make an async_req request, set the async_req parameter. + + :param resource_path: Path to method endpoint. + :param method: Method to call. + :param path_params: Path parameters in the url. + :param query_params: Query parameters in the url. + :param header_params: Header parameters to be + placed in the request header. + :param body: Request body. + :param post_params dict: Request post form parameters, + for `application/x-www-form-urlencoded`, `multipart/form-data`. + :param auth_settings list: Auth Settings names for the request. + :param response: Response data type. + :param files dict: key -> filename, value -> filepath, + for `multipart/form-data`. + :param async_req bool: execute request asynchronously + :param _return_http_data_only: response data without head status code + and headers + :param collection_formats: dict of collection formats for path, query, + header, and post parameters. + :param _preload_content: if False, the urllib3.HTTPResponse object will + be returned without reading/decoding response + data. Default is True. + :param _request_timeout: timeout setting for this request. If one + number provided, it will be total request + timeout. It can also be a pair (tuple) of + (connection, read) timeouts. + :param urlopen_kw: Additional parameters are passed to + :meth:`urllib3.request.RequestMethods.request` + :return: + If async_req parameter is True, + the request will be called asynchronously. + The method will return the request thread. + If parameter async_req is False or missing, + then the method will return the response directly. + """ + if not async_req: + return self.__call_api(resource_path, method, + path_params, query_params, header_params, + body, post_params, files, + response_type, auth_settings, + _return_http_data_only, collection_formats, + _preload_content, _request_timeout, urlopen_kw) + else: + thread = self.pool.apply_async(self.__call_api, (resource_path, + method, path_params, query_params, + header_params, body, + post_params, files, + response_type, auth_settings, + _return_http_data_only, + collection_formats, + _preload_content, _request_timeout, urlopen_kw)) + return thread + + def request(self, method, url, query_params=None, headers=None, + post_params=None, body=None, _preload_content=True, + _request_timeout=None, **urlopen_kw): + """Make the HTTP request using RESTClient.""" + if method == "GET": + return self.rest_client.GET(url, + query_params=query_params, + _preload_content=_preload_content, + _request_timeout=_request_timeout, + headers=headers, + **urlopen_kw) + elif method == "HEAD": + return self.rest_client.HEAD(url, + query_params=query_params, + _preload_content=_preload_content, + _request_timeout=_request_timeout, + headers=headers, + **urlopen_kw) + elif method == "OPTIONS": + return self.rest_client.OPTIONS(url, + query_params=query_params, + headers=headers, + post_params=post_params, + _preload_content=_preload_content, + _request_timeout=_request_timeout, + body=body, + **urlopen_kw) + elif method == "POST": + return self.rest_client.POST(url, + query_params=query_params, + headers=headers, + post_params=post_params, + _preload_content=_preload_content, + _request_timeout=_request_timeout, + body=body, + **urlopen_kw) + elif method == "PUT": + return self.rest_client.PUT(url, + query_params=query_params, + headers=headers, + post_params=post_params, + _preload_content=_preload_content, + _request_timeout=_request_timeout, + body=body, + **urlopen_kw) + elif method == "PATCH": + return self.rest_client.PATCH(url, + query_params=query_params, + headers=headers, + post_params=post_params, + _preload_content=_preload_content, + _request_timeout=_request_timeout, + body=body, + **urlopen_kw) + elif method == "DELETE": + return self.rest_client.DELETE(url, + query_params=query_params, + headers=headers, + _preload_content=_preload_content, + _request_timeout=_request_timeout, + body=body, + **urlopen_kw) + else: + raise ValueError( + "http method must be `GET`, `HEAD`, `OPTIONS`," + " `POST`, `PATCH`, `PUT` or `DELETE`." + ) + + def parameters_to_tuples(self, params, collection_formats): + """Get parameters as list of tuples, formatting collections. + + :param params: Parameters as dict or list of two-tuples + :param dict collection_formats: Parameter collection formats + :return: Parameters as list of tuples, collections formatted + """ + new_params = [] + if collection_formats is None: + collection_formats = {} + for k, v in six.iteritems(params) if isinstance(params, dict) else params: # noqa: E501 + if k in collection_formats: + collection_format = collection_formats[k] + if collection_format == 'multi': + new_params.extend((k, value) for value in v) + else: + if collection_format == 'ssv': + delimiter = ' ' + elif collection_format == 'tsv': + delimiter = '\t' + elif collection_format == 'pipes': + delimiter = '|' + else: # csv is the default + delimiter = ',' + new_params.append( + (k, delimiter.join(str(value) for value in v))) + else: + new_params.append((k, v)) + return new_params + + def prepare_post_parameters(self, post_params=None, files=None): + """Build form parameters. + + :param post_params: Normal form parameters. + :param files: File parameters. + :return: Form parameters with files. + """ + params = [] + + if post_params: + params = post_params + + if files: + for k, v in six.iteritems(files): + if not v: + continue + file_names = v if type(v) is list else [v] + for n in file_names: + with open(n, 'rb') as f: + filename = os.path.basename(f.name) + filedata = f.read() + mimetype = (mimetypes.guess_type(filename)[0] or + 'application/octet-stream') + params.append( + tuple([k, tuple([filename, filedata, mimetype])])) + + return params + + def select_header_accept(self, accepts): + """Return `Accept` based on an array of accepts provided. + + :param accepts: List of headers. + :return: Accept (e.g. application/json). + """ + if not accepts: + return + + accepts = [x.lower() for x in accepts] + + if 'application/json' in accepts: + return 'application/json' + else: + return ', '.join(accepts) + + def select_header_content_type(self, content_types): + """Return `Content-Type` based on an array of content_types provided. + + :param content_types: List of content-types. + :return: Content-Type (e.g. application/json). + """ + if not content_types: + return 'application/json' + + content_types = [x.lower() for x in content_types] + + if 'application/json' in content_types or '*/*' in content_types: + return 'application/json' + else: + return content_types[0] + + def update_params_for_auth(self, headers, querys, auth_settings): + """Update header and query params based on authentication setting. + + :param headers: Header parameters dict to be updated. + :param querys: Query parameters tuple list to be updated. + :param auth_settings: Authentication setting identifiers list. + """ + if not auth_settings: + return + + for auth in auth_settings: + auth_setting = self.configuration.auth_settings().get(auth) + if auth_setting: + if not auth_setting['value']: + continue + elif auth_setting['in'] == 'header': + headers[auth_setting['key']] = auth_setting['value'] + elif auth_setting['in'] == 'query': + querys.append((auth_setting['key'], auth_setting['value'])) + else: + raise ValueError( + 'Authentication token must be in `query` or `header`' + ) + + def __deserialize_file(self, response): + """Deserializes body to file. + + Saves response body into a file in a temporary folder, + using the filename from the `Content-Disposition` header if provided. + + :param response: RESTResponse. + :return: file path. + """ + fd, path = tempfile.mkstemp(dir=self.configuration.temp_folder_path) + os.close(fd) + os.remove(path) + + content_disposition = response.getheader("Content-Disposition") + if content_disposition: + filename = re.search(r'filename=[\'"]?([^\'"\s]+)[\'"]?', + content_disposition).group(1) + path = os.path.join(os.path.dirname(path), filename) + + with open(path, "wb") as f: + f.write(response.data) + + return path + + def __deserialize_primitive(self, data, klass): + """Deserializes string to primitive type. + + :param data: str. + :param klass: class literal. + + :return: int, long, float, str, bool. + """ + try: + return klass(data) + except UnicodeEncodeError: + return six.text_type(data) + except TypeError: + return data + + def __deserialize_object(self, value): + """Return an original value. + + :return: object. + """ + return value + + def __deserialize_date(self, string): + """Deserializes string to date. + + :param string: str. + :return: date. + """ + try: + from dateutil.parser import parse + return parse(string).date() + except ImportError: + return string + except ValueError: + raise rest.ApiException( + status=0, + reason="Failed to parse `{0}` as date object".format(string) + ) + + def __deserialize_datatime(self, string): + """Deserializes string to datetime. + + The string should be in iso8601 datetime format. + + :param string: str. + :return: datetime. + """ + try: + from dateutil.parser import parse + return parse(string) + except ImportError: + return string + except ValueError: + raise rest.ApiException( + status=0, + reason=( + "Failed to parse `{0}` as datetime object" + .format(string) + ) + ) + + def __deserialize_model(self, data, klass): + """Deserializes list or dict to model. + + :param data: dict, list. + :param klass: class literal. + :return: model object. + """ + if not klass.openapi_types and not hasattr(klass, + 'get_real_child_model'): + return data + + kwargs = {} + if klass.openapi_types is not None: + for attr, attr_type in six.iteritems(klass.openapi_types): + if (data is not None and + klass.attribute_map[attr] in data and + isinstance(data, (list, dict))): + value = data[klass.attribute_map[attr]] + kwargs[attr] = self.__deserialize(value, attr_type) + + instance = klass(**kwargs) + + if hasattr(instance, 'get_real_child_model'): + klass_name = instance.get_real_child_model(data) + if klass_name: + instance = self.__deserialize(data, klass_name) + return instance diff --git a/influxdb_client/_async/rest.py b/influxdb_client/_async/rest.py new file mode 100644 index 00000000..c28e998a --- /dev/null +++ b/influxdb_client/_async/rest.py @@ -0,0 +1,245 @@ +""" +InfluxDB OSS API Service. + +The InfluxDB v2 API provides a programmatic interface for all interactions with InfluxDB. Access the InfluxDB API using the `/api/v2/` endpoint. # noqa: E501 + +OpenAPI spec version: 2.0.0 +Generated by: https://openapi-generator.tech +""" + + +import io +import json +import logging +import re +import ssl + +import aiohttp +# python 2 and python 3 compatibility library +from six.moves.urllib.parse import urlencode + +from influxdb_client.rest import ApiException + +logger = logging.getLogger(__name__) + + +class RESTResponseAsync(io.IOBase): + + def __init__(self, resp, data): + self.aiohttp_response = resp + self.status = resp.status + self.reason = resp.reason + self.data = data + + def getheaders(self): + """Returns a CIMultiDictProxy of the response headers.""" + return self.aiohttp_response.headers + + def getheader(self, name, default=None): + """Returns a given response header.""" + return self.aiohttp_response.headers.get(name, default) + + +class RESTClientObjectAsync(object): + + def __init__(self, configuration, pools_size=4, maxsize=None): + + # maxsize is number of requests to host that are allowed in parallel + if maxsize is None: + maxsize = configuration.connection_pool_maxsize + + ssl_context = ssl.create_default_context(cafile=configuration.ssl_ca_cert) + if configuration.cert_file: + ssl_context.load_cert_chain( + configuration.cert_file, keyfile=configuration.key_file + ) + + if not configuration.verify_ssl: + ssl_context.check_hostname = False + ssl_context.verify_mode = ssl.CERT_NONE + + connector = aiohttp.TCPConnector( + limit=maxsize, + ssl=ssl_context + ) + + self.proxy = configuration.proxy + self.proxy_headers = configuration.proxy_headers + + # https pool manager + self.pool_manager = aiohttp.ClientSession( + connector=connector, + trust_env=True + ) + + async def close(self): + await self.pool_manager.close() + + async def request(self, method, url, query_params=None, headers=None, + body=None, post_params=None, _preload_content=True, + _request_timeout=None): + """Execute request + + :param method: http request method + :param url: http request url + :param query_params: query parameters in the url + :param headers: http request headers + :param body: request json body, for `application/json` + :param post_params: request post parameters, + `application/x-www-form-urlencoded` + and `multipart/form-data` + :param _preload_content: this is a non-applicable field for + the AiohttpClient. + :param _request_timeout: timeout setting for this request. If one + number provided, it will be total request + timeout. It can also be a pair (tuple) of + (connection, read) timeouts. + """ + method = method.upper() + assert method in ['GET', 'HEAD', 'DELETE', 'POST', 'PUT', + 'PATCH', 'OPTIONS'] + + if post_params and body: + raise ValueError( + "body parameter cannot be used with post_params parameter." + ) + + post_params = post_params or {} + headers = headers or {} + timeout = _request_timeout or 5 * 60 + + if 'Content-Type' not in headers: + headers['Content-Type'] = 'application/json' + + args = { + "method": method, + "url": url, + "timeout": timeout, + "headers": headers + } + + if self.proxy: + args["proxy"] = self.proxy + if self.proxy_headers: + args["proxy_headers"] = self.proxy_headers + + if query_params: + args["url"] += '?' + urlencode(query_params) + + # For `POST`, `PUT`, `PATCH`, `OPTIONS`, `DELETE` + if method in ['POST', 'PUT', 'PATCH', 'OPTIONS', 'DELETE']: + if re.search('json', headers['Content-Type'], re.IGNORECASE): + if body is not None: + body = json.dumps(body) + args["data"] = body + elif headers['Content-Type'] == 'application/x-www-form-urlencoded': # noqa: E501 + args["data"] = aiohttp.FormData(post_params) + elif headers['Content-Type'] == 'multipart/form-data': + # must del headers['Content-Type'], or the correct + # Content-Type which generated by aiohttp + del headers['Content-Type'] + data = aiohttp.FormData() + for param in post_params: + k, v = param + if isinstance(v, tuple) and len(v) == 3: + data.add_field(k, + value=v[1], + filename=v[0], + content_type=v[2]) + else: + data.add_field(k, v) + args["data"] = data + + # Pass a `bytes` parameter directly in the body to support + # other content types than Json when `body` argument is provided + # in serialized form + elif isinstance(body, bytes): + args["data"] = body + else: + # Cannot generate the request from given parameters + msg = """Cannot prepare a request message for provided + arguments. Please check that your arguments match + declared content type.""" + raise ApiException(status=0, reason=msg) + + r = await self.pool_manager.request(**args) + if _preload_content: + + data = await r.read() + r = RESTResponseAsync(r, data) + + # log response body + logger.debug("response body: %s", r.data) + + if not 200 <= r.status <= 299: + raise ApiException(http_resp=r) + + return r + + async def GET(self, url, headers=None, query_params=None, + _preload_content=True, _request_timeout=None): + return (await self.request("GET", url, + headers=headers, + _preload_content=_preload_content, + _request_timeout=_request_timeout, + query_params=query_params)) + + async def HEAD(self, url, headers=None, query_params=None, + _preload_content=True, _request_timeout=None): + return (await self.request("HEAD", url, + headers=headers, + _preload_content=_preload_content, + _request_timeout=_request_timeout, + query_params=query_params)) + + async def OPTIONS(self, url, headers=None, query_params=None, + post_params=None, body=None, _preload_content=True, + _request_timeout=None): + return (await self.request("OPTIONS", url, + headers=headers, + query_params=query_params, + post_params=post_params, + _preload_content=_preload_content, + _request_timeout=_request_timeout, + body=body)) + + async def DELETE(self, url, headers=None, query_params=None, body=None, + _preload_content=True, _request_timeout=None): + return (await self.request("DELETE", url, + headers=headers, + query_params=query_params, + _preload_content=_preload_content, + _request_timeout=_request_timeout, + body=body)) + + async def POST(self, url, headers=None, query_params=None, + post_params=None, body=None, _preload_content=True, + _request_timeout=None): + return (await self.request("POST", url, + headers=headers, + query_params=query_params, + post_params=post_params, + _preload_content=_preload_content, + _request_timeout=_request_timeout, + body=body)) + + async def PUT(self, url, headers=None, query_params=None, post_params=None, + body=None, _preload_content=True, _request_timeout=None): + return (await self.request("PUT", url, + headers=headers, + query_params=query_params, + post_params=post_params, + _preload_content=_preload_content, + _request_timeout=_request_timeout, + body=body)) + + async def PATCH(self, url, headers=None, query_params=None, + post_params=None, body=None, _preload_content=True, + _request_timeout=None): + return (await self.request("PATCH", url, + headers=headers, + query_params=query_params, + post_params=post_params, + _preload_content=_preload_content, + _request_timeout=_request_timeout, + body=body)) diff --git a/influxdb_client/_sync/__init__.py b/influxdb_client/_sync/__init__.py new file mode 100644 index 00000000..476e193a --- /dev/null +++ b/influxdb_client/_sync/__init__.py @@ -0,0 +1 @@ +"""Synchronous REST APIs.""" diff --git a/influxdb_client/api_client.py b/influxdb_client/_sync/api_client.py similarity index 99% rename from influxdb_client/api_client.py rename to influxdb_client/_sync/api_client.py index 6059e7bb..26c1ddf3 100644 --- a/influxdb_client/api_client.py +++ b/influxdb_client/_sync/api_client.py @@ -24,7 +24,7 @@ from influxdb_client.configuration import Configuration import influxdb_client.domain -from influxdb_client import rest +from influxdb_client._sync import rest class ApiClient(object): diff --git a/influxdb_client/_sync/rest.py b/influxdb_client/_sync/rest.py new file mode 100644 index 00000000..93b41218 --- /dev/null +++ b/influxdb_client/_sync/rest.py @@ -0,0 +1,349 @@ +# coding: utf-8 + +""" +InfluxDB OSS API Service. + +The InfluxDB v2 API provides a programmatic interface for all interactions with InfluxDB. Access the InfluxDB API using the `/api/v2/` endpoint. # noqa: E501 + +OpenAPI spec version: 2.0.0 +Generated by: https://openapi-generator.tech +""" + + +from __future__ import absolute_import + +import io +import json +import logging +import re +import ssl + +# python 2 and python 3 compatibility library +import six +from six.moves.urllib.parse import urlencode + +from influxdb_client.rest import ApiException + +try: + import urllib3 +except ImportError: + raise ImportError('OpenAPI Python client requires urllib3.') + + +logger = logging.getLogger(__name__) + + +class RESTResponse(io.IOBase): + """NOTE: This class is auto generated by OpenAPI Generator. + + Ref: https://openapi-generator.tech + Do not edit the class manually. + """ + + def __init__(self, resp): + """Initialize with HTTP response.""" + self.urllib3_response = resp + self.status = resp.status + self.reason = resp.reason + self.data = resp.data + + def getheaders(self): + """Return a dictionary of the response headers.""" + return self.urllib3_response.getheaders() + + def getheader(self, name, default=None): + """Return a given response header.""" + return self.urllib3_response.getheader(name, default) + + +class RESTClientObject(object): + """NOTE: This class is auto generated by OpenAPI Generator. + + Ref: https://openapi-generator.tech + Do not edit the class manually. + """ + + def __init__(self, configuration, pools_size=4, maxsize=None, retries=False): + """Initialize REST client.""" + # urllib3.PoolManager will pass all kw parameters to connectionpool + # https://github.com/shazow/urllib3/blob/f9409436f83aeb79fbaf090181cd81b784f1b8ce/urllib3/poolmanager.py#L75 # noqa: E501 + # https://github.com/shazow/urllib3/blob/f9409436f83aeb79fbaf090181cd81b784f1b8ce/urllib3/connectionpool.py#L680 # noqa: E501 + # maxsize is the number of requests to host that are allowed in parallel # noqa: E501 + # Custom SSL certificates and client certificates: http://urllib3.readthedocs.io/en/latest/advanced-usage.html # noqa: E501 + + self.configuration = configuration + self.pools_size = pools_size + self.maxsize = maxsize + self.retries = retries + + # cert_reqs + if configuration.verify_ssl: + cert_reqs = ssl.CERT_REQUIRED + else: + cert_reqs = ssl.CERT_NONE + + # ca_certs + if configuration.ssl_ca_cert: + ca_certs = configuration.ssl_ca_cert + else: + ca_certs = None + + addition_pool_args = {} + if configuration.assert_hostname is not None: + addition_pool_args['assert_hostname'] = configuration.assert_hostname # noqa: E501 + addition_pool_args['retries'] = self.retries + + if maxsize is None: + if configuration.connection_pool_maxsize is not None: + maxsize = configuration.connection_pool_maxsize + else: + maxsize = 4 + + # https pool manager + if configuration.proxy: + self.pool_manager = urllib3.ProxyManager( + num_pools=pools_size, + maxsize=maxsize, + cert_reqs=cert_reqs, + ca_certs=ca_certs, + cert_file=configuration.cert_file, + key_file=configuration.key_file, + proxy_url=configuration.proxy, + proxy_headers=configuration.proxy_headers, + **addition_pool_args + ) + else: + self.pool_manager = urllib3.PoolManager( + num_pools=pools_size, + maxsize=maxsize, + cert_reqs=cert_reqs, + ca_certs=ca_certs, + cert_file=configuration.cert_file, + key_file=configuration.key_file, + **addition_pool_args + ) + + def request(self, method, url, query_params=None, headers=None, + body=None, post_params=None, _preload_content=True, + _request_timeout=None, **urlopen_kw): + """Perform requests. + + :param method: http request method + :param url: http request url + :param query_params: query parameters in the url + :param headers: http request headers + :param body: request json body, for `application/json` + :param post_params: request post parameters, + `application/x-www-form-urlencoded` + and `multipart/form-data` + :param _preload_content: if False, the urllib3.HTTPResponse object will + be returned without reading/decoding response + data. Default is True. + :param _request_timeout: timeout setting for this request. If one + number provided, it will be total request + timeout. It can also be a pair (tuple) of + (connection, read) timeouts. + :param urlopen_kw: Additional parameters are passed to + :meth:`urllib3.request.RequestMethods.request` + """ + method = method.upper() + assert method in ['GET', 'HEAD', 'DELETE', 'POST', 'PUT', + 'PATCH', 'OPTIONS'] + + if post_params and body: + raise ValueError( + "body parameter cannot be used with post_params parameter." + ) + + post_params = post_params or {} + headers = headers or {} + + timeout = None + _configured_timeout = _request_timeout or self.configuration.timeout + if _configured_timeout: + if isinstance(_configured_timeout, (int, float, ) if six.PY3 else (int, long, float, )): # noqa: E501,F821 + timeout = urllib3.Timeout(total=_configured_timeout / 1_000) + elif (isinstance(_configured_timeout, tuple) and + len(_configured_timeout) == 2): + timeout = urllib3.Timeout( + connect=_configured_timeout[0] / 1_000, read=_configured_timeout[1] / 1_000) + + if 'Content-Type' not in headers: + headers['Content-Type'] = 'application/json' + + try: + # For `POST`, `PUT`, `PATCH`, `OPTIONS`, `DELETE` + if method in ['POST', 'PUT', 'PATCH', 'OPTIONS', 'DELETE']: + if query_params: + url += '?' + urlencode(query_params) + if re.search('json', headers['Content-Type'], re.IGNORECASE): + request_body = None + if body is not None: + request_body = json.dumps(body) + r = self.pool_manager.request( + method, url, + body=request_body, + preload_content=_preload_content, + timeout=timeout, + headers=headers, + **urlopen_kw) + elif headers['Content-Type'] == 'application/x-www-form-urlencoded': # noqa: E501 + r = self.pool_manager.request( + method, url, + fields=post_params, + encode_multipart=False, + preload_content=_preload_content, + timeout=timeout, + headers=headers, + **urlopen_kw) + elif headers['Content-Type'] == 'multipart/form-data': + # must del headers['Content-Type'], or the correct + # Content-Type which generated by urllib3 will be + # overwritten. + del headers['Content-Type'] + r = self.pool_manager.request( + method, url, + fields=post_params, + encode_multipart=True, + preload_content=_preload_content, + timeout=timeout, + headers=headers, + **urlopen_kw) + # Pass a `string` parameter directly in the body to support + # other content types than Json when `body` argument is + # provided in serialized form + elif isinstance(body, str) or isinstance(body, bytes): + request_body = body + r = self.pool_manager.request( + method, url, + body=request_body, + preload_content=_preload_content, + timeout=timeout, + headers=headers, + **urlopen_kw) + else: + # Cannot generate the request from given parameters + msg = """Cannot prepare a request message for provided + arguments. Please check that your arguments match + declared content type.""" + raise ApiException(status=0, reason=msg) + # For `GET`, `HEAD` + else: + r = self.pool_manager.request(method, url, + fields=query_params, + preload_content=_preload_content, + timeout=timeout, + headers=headers, + **urlopen_kw) + except urllib3.exceptions.SSLError as e: + msg = "{0}\n{1}".format(type(e).__name__, str(e)) + raise ApiException(status=0, reason=msg) + + if _preload_content: + r = RESTResponse(r) + + # In the python 3, the response.data is bytes. + # we need to decode it to string. + if six.PY3: + r.data = r.data.decode('utf8') + + # log response body + logger.debug("response body: %s", r.data) + + if not 200 <= r.status <= 299: + raise ApiException(http_resp=r) + + return r + + def GET(self, url, headers=None, query_params=None, _preload_content=True, + _request_timeout=None, **urlopen_kw): + """Perform GET HTTP request.""" + return self.request("GET", url, + headers=headers, + _preload_content=_preload_content, + _request_timeout=_request_timeout, + query_params=query_params, + **urlopen_kw) + + def HEAD(self, url, headers=None, query_params=None, _preload_content=True, + _request_timeout=None, **urlopen_kw): + """Perform HEAD HTTP request.""" + return self.request("HEAD", url, + headers=headers, + _preload_content=_preload_content, + _request_timeout=_request_timeout, + query_params=query_params, + **urlopen_kw) + + def OPTIONS(self, url, headers=None, query_params=None, post_params=None, + body=None, _preload_content=True, _request_timeout=None, **urlopen_kw): + """Perform OPTIONS HTTP request.""" + return self.request("OPTIONS", url, + headers=headers, + query_params=query_params, + post_params=post_params, + _preload_content=_preload_content, + _request_timeout=_request_timeout, + body=body, + **urlopen_kw) + + def DELETE(self, url, headers=None, query_params=None, body=None, + _preload_content=True, _request_timeout=None, **urlopen_kw): + """Perform DELETE HTTP request.""" + return self.request("DELETE", url, + headers=headers, + query_params=query_params, + _preload_content=_preload_content, + _request_timeout=_request_timeout, + body=body, + **urlopen_kw) + + def POST(self, url, headers=None, query_params=None, post_params=None, + body=None, _preload_content=True, _request_timeout=None, **urlopen_kw): + """Perform POST HTTP request.""" + return self.request("POST", url, + headers=headers, + query_params=query_params, + post_params=post_params, + _preload_content=_preload_content, + _request_timeout=_request_timeout, + body=body, + **urlopen_kw) + + def PUT(self, url, headers=None, query_params=None, post_params=None, + body=None, _preload_content=True, _request_timeout=None, **urlopen_kw): + """Perform PUT HTTP request.""" + return self.request("PUT", url, + headers=headers, + query_params=query_params, + post_params=post_params, + _preload_content=_preload_content, + _request_timeout=_request_timeout, + body=body, + **urlopen_kw) + + def PATCH(self, url, headers=None, query_params=None, post_params=None, + body=None, _preload_content=True, _request_timeout=None, **urlopen_kw): + """Perform PATCH HTTP request.""" + return self.request("PATCH", url, + headers=headers, + query_params=query_params, + post_params=post_params, + _preload_content=_preload_content, + _request_timeout=_request_timeout, + body=body, + **urlopen_kw) + + def __getstate__(self): + """Return a dict of attributes that you want to pickle.""" + state = self.__dict__.copy() + # Remove Pool managaer + del state['pool_manager'] + return state + + def __setstate__(self, state): + """Set your object with the provided dict.""" + self.__dict__.update(state) + # Init Pool manager + self.__init__(self.configuration, self.pools_size, self.maxsize, self.retries) + diff --git a/influxdb_client/client/influxdb_client.py b/influxdb_client/client/influxdb_client.py index e66b3ba6..7ccb94d0 100644 --- a/influxdb_client/client/influxdb_client.py +++ b/influxdb_client/client/influxdb_client.py @@ -2,13 +2,13 @@ from __future__ import absolute_import +import base64 import configparser import logging import os -import base64 import warnings -from influxdb_client import Configuration, ApiClient, HealthCheck, HealthService, Ready, ReadyService, PingService, \ +from influxdb_client import Configuration, HealthCheck, HealthService, Ready, ReadyService, PingService, \ InvocableScriptsApi from influxdb_client.client.authorizations_api import AuthorizationsApi from influxdb_client.client.bucket_api import BucketsApi @@ -20,7 +20,6 @@ from influxdb_client.client.users_api import UsersApi from influxdb_client.client.write_api import WriteApi, WriteOptions, PointSettings - logger = logging.getLogger(__name__) @@ -87,6 +86,7 @@ def __init__(self, url, token, debug=None, timeout=10_000, enable_gzip=False, or self.profilers = kwargs.get('profilers', None) + from .._sync.api_client import ApiClient self.api_client = ApiClient(configuration=conf, header_name=auth_header_name, header_value=auth_header_value, retries=retries) diff --git a/influxdb_client/rest.py b/influxdb_client/rest.py index 120d803e..f348d9b1 100644 --- a/influxdb_client/rest.py +++ b/influxdb_client/rest.py @@ -12,341 +12,8 @@ from __future__ import absolute_import -import io -import json -import logging -import re -import ssl - -# python 2 and python 3 compatibility library -import six -from six.moves.urllib.parse import urlencode - from influxdb_client.client.exceptions import InfluxDBError -try: - import urllib3 -except ImportError: - raise ImportError('OpenAPI Python client requires urllib3.') - - -logger = logging.getLogger(__name__) - - -class RESTResponse(io.IOBase): - """NOTE: This class is auto generated by OpenAPI Generator. - - Ref: https://openapi-generator.tech - Do not edit the class manually. - """ - - def __init__(self, resp): - """Initialize with HTTP response.""" - self.urllib3_response = resp - self.status = resp.status - self.reason = resp.reason - self.data = resp.data - - def getheaders(self): - """Return a dictionary of the response headers.""" - return self.urllib3_response.getheaders() - - def getheader(self, name, default=None): - """Return a given response header.""" - return self.urllib3_response.getheader(name, default) - - -class RESTClientObject(object): - """NOTE: This class is auto generated by OpenAPI Generator. - - Ref: https://openapi-generator.tech - Do not edit the class manually. - """ - - def __init__(self, configuration, pools_size=4, maxsize=None, retries=False): - """Initialize REST client.""" - # urllib3.PoolManager will pass all kw parameters to connectionpool - # https://github.com/shazow/urllib3/blob/f9409436f83aeb79fbaf090181cd81b784f1b8ce/urllib3/poolmanager.py#L75 # noqa: E501 - # https://github.com/shazow/urllib3/blob/f9409436f83aeb79fbaf090181cd81b784f1b8ce/urllib3/connectionpool.py#L680 # noqa: E501 - # maxsize is the number of requests to host that are allowed in parallel # noqa: E501 - # Custom SSL certificates and client certificates: http://urllib3.readthedocs.io/en/latest/advanced-usage.html # noqa: E501 - - self.configuration = configuration - self.pools_size = pools_size - self.maxsize = maxsize - self.retries = retries - - # cert_reqs - if configuration.verify_ssl: - cert_reqs = ssl.CERT_REQUIRED - else: - cert_reqs = ssl.CERT_NONE - - # ca_certs - if configuration.ssl_ca_cert: - ca_certs = configuration.ssl_ca_cert - else: - ca_certs = None - - addition_pool_args = {} - if configuration.assert_hostname is not None: - addition_pool_args['assert_hostname'] = configuration.assert_hostname # noqa: E501 - addition_pool_args['retries'] = self.retries - - if maxsize is None: - if configuration.connection_pool_maxsize is not None: - maxsize = configuration.connection_pool_maxsize - else: - maxsize = 4 - - # https pool manager - if configuration.proxy: - self.pool_manager = urllib3.ProxyManager( - num_pools=pools_size, - maxsize=maxsize, - cert_reqs=cert_reqs, - ca_certs=ca_certs, - cert_file=configuration.cert_file, - key_file=configuration.key_file, - proxy_url=configuration.proxy, - proxy_headers=configuration.proxy_headers, - **addition_pool_args - ) - else: - self.pool_manager = urllib3.PoolManager( - num_pools=pools_size, - maxsize=maxsize, - cert_reqs=cert_reqs, - ca_certs=ca_certs, - cert_file=configuration.cert_file, - key_file=configuration.key_file, - **addition_pool_args - ) - - def request(self, method, url, query_params=None, headers=None, - body=None, post_params=None, _preload_content=True, - _request_timeout=None, **urlopen_kw): - """Perform requests. - - :param method: http request method - :param url: http request url - :param query_params: query parameters in the url - :param headers: http request headers - :param body: request json body, for `application/json` - :param post_params: request post parameters, - `application/x-www-form-urlencoded` - and `multipart/form-data` - :param _preload_content: if False, the urllib3.HTTPResponse object will - be returned without reading/decoding response - data. Default is True. - :param _request_timeout: timeout setting for this request. If one - number provided, it will be total request - timeout. It can also be a pair (tuple) of - (connection, read) timeouts. - :param urlopen_kw: Additional parameters are passed to - :meth:`urllib3.request.RequestMethods.request` - """ - method = method.upper() - assert method in ['GET', 'HEAD', 'DELETE', 'POST', 'PUT', - 'PATCH', 'OPTIONS'] - - if post_params and body: - raise ValueError( - "body parameter cannot be used with post_params parameter." - ) - - post_params = post_params or {} - headers = headers or {} - - timeout = None - _configured_timeout = _request_timeout or self.configuration.timeout - if _configured_timeout: - if isinstance(_configured_timeout, (int, float, ) if six.PY3 else (int, long, float, )): # noqa: E501,F821 - timeout = urllib3.Timeout(total=_configured_timeout / 1_000) - elif (isinstance(_configured_timeout, tuple) and - len(_configured_timeout) == 2): - timeout = urllib3.Timeout( - connect=_configured_timeout[0] / 1_000, read=_configured_timeout[1] / 1_000) - - if 'Content-Type' not in headers: - headers['Content-Type'] = 'application/json' - - try: - # For `POST`, `PUT`, `PATCH`, `OPTIONS`, `DELETE` - if method in ['POST', 'PUT', 'PATCH', 'OPTIONS', 'DELETE']: - if query_params: - url += '?' + urlencode(query_params) - if re.search('json', headers['Content-Type'], re.IGNORECASE): - request_body = None - if body is not None: - request_body = json.dumps(body) - r = self.pool_manager.request( - method, url, - body=request_body, - preload_content=_preload_content, - timeout=timeout, - headers=headers, - **urlopen_kw) - elif headers['Content-Type'] == 'application/x-www-form-urlencoded': # noqa: E501 - r = self.pool_manager.request( - method, url, - fields=post_params, - encode_multipart=False, - preload_content=_preload_content, - timeout=timeout, - headers=headers, - **urlopen_kw) - elif headers['Content-Type'] == 'multipart/form-data': - # must del headers['Content-Type'], or the correct - # Content-Type which generated by urllib3 will be - # overwritten. - del headers['Content-Type'] - r = self.pool_manager.request( - method, url, - fields=post_params, - encode_multipart=True, - preload_content=_preload_content, - timeout=timeout, - headers=headers, - **urlopen_kw) - # Pass a `string` parameter directly in the body to support - # other content types than Json when `body` argument is - # provided in serialized form - elif isinstance(body, str) or isinstance(body, bytes): - request_body = body - r = self.pool_manager.request( - method, url, - body=request_body, - preload_content=_preload_content, - timeout=timeout, - headers=headers, - **urlopen_kw) - else: - # Cannot generate the request from given parameters - msg = """Cannot prepare a request message for provided - arguments. Please check that your arguments match - declared content type.""" - raise ApiException(status=0, reason=msg) - # For `GET`, `HEAD` - else: - r = self.pool_manager.request(method, url, - fields=query_params, - preload_content=_preload_content, - timeout=timeout, - headers=headers, - **urlopen_kw) - except urllib3.exceptions.SSLError as e: - msg = "{0}\n{1}".format(type(e).__name__, str(e)) - raise ApiException(status=0, reason=msg) - - if _preload_content: - r = RESTResponse(r) - - # In the python 3, the response.data is bytes. - # we need to decode it to string. - if six.PY3: - r.data = r.data.decode('utf8') - - # log response body - logger.debug("response body: %s", r.data) - - if not 200 <= r.status <= 299: - raise ApiException(http_resp=r) - - return r - - def GET(self, url, headers=None, query_params=None, _preload_content=True, - _request_timeout=None, **urlopen_kw): - """Perform GET HTTP request.""" - return self.request("GET", url, - headers=headers, - _preload_content=_preload_content, - _request_timeout=_request_timeout, - query_params=query_params, - **urlopen_kw) - - def HEAD(self, url, headers=None, query_params=None, _preload_content=True, - _request_timeout=None, **urlopen_kw): - """Perform HEAD HTTP request.""" - return self.request("HEAD", url, - headers=headers, - _preload_content=_preload_content, - _request_timeout=_request_timeout, - query_params=query_params, - **urlopen_kw) - - def OPTIONS(self, url, headers=None, query_params=None, post_params=None, - body=None, _preload_content=True, _request_timeout=None, **urlopen_kw): - """Perform OPTIONS HTTP request.""" - return self.request("OPTIONS", url, - headers=headers, - query_params=query_params, - post_params=post_params, - _preload_content=_preload_content, - _request_timeout=_request_timeout, - body=body, - **urlopen_kw) - - def DELETE(self, url, headers=None, query_params=None, body=None, - _preload_content=True, _request_timeout=None, **urlopen_kw): - """Perform DELETE HTTP request.""" - return self.request("DELETE", url, - headers=headers, - query_params=query_params, - _preload_content=_preload_content, - _request_timeout=_request_timeout, - body=body, - **urlopen_kw) - - def POST(self, url, headers=None, query_params=None, post_params=None, - body=None, _preload_content=True, _request_timeout=None, **urlopen_kw): - """Perform POST HTTP request.""" - return self.request("POST", url, - headers=headers, - query_params=query_params, - post_params=post_params, - _preload_content=_preload_content, - _request_timeout=_request_timeout, - body=body, - **urlopen_kw) - - def PUT(self, url, headers=None, query_params=None, post_params=None, - body=None, _preload_content=True, _request_timeout=None, **urlopen_kw): - """Perform PUT HTTP request.""" - return self.request("PUT", url, - headers=headers, - query_params=query_params, - post_params=post_params, - _preload_content=_preload_content, - _request_timeout=_request_timeout, - body=body, - **urlopen_kw) - - def PATCH(self, url, headers=None, query_params=None, post_params=None, - body=None, _preload_content=True, _request_timeout=None, **urlopen_kw): - """Perform PATCH HTTP request.""" - return self.request("PATCH", url, - headers=headers, - query_params=query_params, - post_params=post_params, - _preload_content=_preload_content, - _request_timeout=_request_timeout, - body=body, - **urlopen_kw) - - def __getstate__(self): - """Return a dict of attributes that you want to pickle.""" - state = self.__dict__.copy() - # Remove Pool managaer - del state['pool_manager'] - return state - - def __setstate__(self, state): - """Set your object with the provided dict.""" - self.__dict__.update(state) - # Init Pool manager - self.__init__(self.configuration, self.pools_size, self.maxsize, self.retries) - class ApiException(InfluxDBError): """NOTE: This class is auto generated by OpenAPI Generator. From 9dc43cbc0b283cff6878a0cc0d69520e08b37776 Mon Sep 17 00:00:00 2001 From: Jakub Bednar Date: Thu, 3 Mar 2022 12:21:39 +0100 Subject: [PATCH 02/46] fix: code & doc style --- influxdb_client/_async/api_client.py | 1 + influxdb_client/_async/rest.py | 27 +++++++++++++++++++++++---- influxdb_client/_sync/rest.py | 1 - 3 files changed, 24 insertions(+), 5 deletions(-) diff --git a/influxdb_client/_async/api_client.py b/influxdb_client/_async/api_client.py index 7a5ecef8..ac34e7e5 100644 --- a/influxdb_client/_async/api_client.py +++ b/influxdb_client/_async/api_client.py @@ -80,6 +80,7 @@ def __init__(self, configuration=None, header_name=None, header_value=None, self.user_agent = f'influxdb-client-python/{CLIENT_VERSION}' async def close(self): + """Dispose api client.""" await self.rest_client.close() """Dispose pools.""" if self._pool: diff --git a/influxdb_client/_async/rest.py b/influxdb_client/_async/rest.py index c28e998a..50c79d19 100644 --- a/influxdb_client/_async/rest.py +++ b/influxdb_client/_async/rest.py @@ -24,26 +24,37 @@ class RESTResponseAsync(io.IOBase): + """NOTE: This class is auto generated by OpenAPI Generator. + + Ref: https://openapi-generator.tech + Do not edit the class manually. + """ def __init__(self, resp, data): + """Initialize with HTTP response.""" self.aiohttp_response = resp self.status = resp.status self.reason = resp.reason self.data = data def getheaders(self): - """Returns a CIMultiDictProxy of the response headers.""" + """Return a CIMultiDictProxy of the response headers.""" return self.aiohttp_response.headers def getheader(self, name, default=None): - """Returns a given response header.""" + """Return a given response header.""" return self.aiohttp_response.headers.get(name, default) class RESTClientObjectAsync(object): + """NOTE: This class is auto generated by OpenAPI Generator. - def __init__(self, configuration, pools_size=4, maxsize=None): + Ref: https://openapi-generator.tech + Do not edit the class manually. + """ + def __init__(self, configuration, pools_size=4, maxsize=None): + """Initialize REST client.""" # maxsize is number of requests to host that are allowed in parallel if maxsize is None: maxsize = configuration.connection_pool_maxsize @@ -73,12 +84,13 @@ def __init__(self, configuration, pools_size=4, maxsize=None): ) async def close(self): + """Dispose connection pool manager.""" await self.pool_manager.close() async def request(self, method, url, query_params=None, headers=None, body=None, post_params=None, _preload_content=True, _request_timeout=None): - """Execute request + """Execute request. :param method: http request method :param url: http request url @@ -178,6 +190,7 @@ async def request(self, method, url, query_params=None, headers=None, async def GET(self, url, headers=None, query_params=None, _preload_content=True, _request_timeout=None): + """Perform GET HTTP request.""" return (await self.request("GET", url, headers=headers, _preload_content=_preload_content, @@ -186,6 +199,7 @@ async def GET(self, url, headers=None, query_params=None, async def HEAD(self, url, headers=None, query_params=None, _preload_content=True, _request_timeout=None): + """Perform HEAD HTTP request.""" return (await self.request("HEAD", url, headers=headers, _preload_content=_preload_content, @@ -195,6 +209,7 @@ async def HEAD(self, url, headers=None, query_params=None, async def OPTIONS(self, url, headers=None, query_params=None, post_params=None, body=None, _preload_content=True, _request_timeout=None): + """Perform OPTIONS HTTP request.""" return (await self.request("OPTIONS", url, headers=headers, query_params=query_params, @@ -205,6 +220,7 @@ async def OPTIONS(self, url, headers=None, query_params=None, async def DELETE(self, url, headers=None, query_params=None, body=None, _preload_content=True, _request_timeout=None): + """Perform DELETE HTTP request.""" return (await self.request("DELETE", url, headers=headers, query_params=query_params, @@ -215,6 +231,7 @@ async def DELETE(self, url, headers=None, query_params=None, body=None, async def POST(self, url, headers=None, query_params=None, post_params=None, body=None, _preload_content=True, _request_timeout=None): + """Perform POST HTTP request.""" return (await self.request("POST", url, headers=headers, query_params=query_params, @@ -225,6 +242,7 @@ async def POST(self, url, headers=None, query_params=None, async def PUT(self, url, headers=None, query_params=None, post_params=None, body=None, _preload_content=True, _request_timeout=None): + """Perform PUT HTTP request.""" return (await self.request("PUT", url, headers=headers, query_params=query_params, @@ -236,6 +254,7 @@ async def PUT(self, url, headers=None, query_params=None, post_params=None, async def PATCH(self, url, headers=None, query_params=None, post_params=None, body=None, _preload_content=True, _request_timeout=None): + """Perform PATCH HTTP request.""" return (await self.request("PATCH", url, headers=headers, query_params=query_params, diff --git a/influxdb_client/_sync/rest.py b/influxdb_client/_sync/rest.py index 93b41218..68da8328 100644 --- a/influxdb_client/_sync/rest.py +++ b/influxdb_client/_sync/rest.py @@ -346,4 +346,3 @@ def __setstate__(self, state): self.__dict__.update(state) # Init Pool manager self.__init__(self.configuration, self.pools_size, self.maxsize, self.retries) - From 8cc39a7c0f8b29bab4e42e8fee53054de48a1f0a Mon Sep 17 00:00:00 2001 From: Jakub Bednar Date: Thu, 3 Mar 2022 13:45:48 +0100 Subject: [PATCH 03/46] feat: prepared _BaseClient to share sources between sync and async client --- README.rst | 14 ++++ docs/usage.rst | 6 ++ influxdb_client/_async/api_client.py | 4 +- influxdb_client/client/_base.py | 76 ++++++++++++++++++ influxdb_client/client/influxdb_client.py | 78 ++----------------- .../client/influxdb_client_async.py | 39 ++++++++++ setup.py | 6 +- tests/test_InfluxDBClientAsync.py | 28 +++++++ 8 files changed, 176 insertions(+), 75 deletions(-) create mode 100644 influxdb_client/client/_base.py create mode 100644 influxdb_client/client/influxdb_client_async.py create mode 100644 tests/test_InfluxDBClientAsync.py diff --git a/README.rst b/README.rst index 738f99e5..7cd9c72a 100644 --- a/README.rst +++ b/README.rst @@ -120,6 +120,12 @@ Then import the package: import influxdb_client +If your application uses async/await in Python you can install with the ``async`` extra:: + + $ pip install influxdb-client[async] + +For more info se `How to use asyncio`_. + Setuptools ^^^^^^^^^^ @@ -1324,6 +1330,14 @@ that is replacement for python ``datetime.datetime`` object and also you should .. marker-nanosecond-end +How to use asyncio +^^^^^^^^^^^^^^^^^^ +.. marker-asyncio-start + +TBD + +.. marker-asyncio-end + Local tests ----------- diff --git a/docs/usage.rst b/docs/usage.rst index 1fae61fa..162ad5e8 100644 --- a/docs/usage.rst +++ b/docs/usage.rst @@ -52,6 +52,12 @@ Handling Errors :start-after: marker-handling-errors-start :end-before: marker-handling-errors-end +How to use Asyncio +^^^^^^^^^^^^^^^^^^ +.. include:: ../README.rst + :start-after: marker-asyncio-start + :end-before: marker-asyncio-end + Debugging ^^^^^^^^^ diff --git a/influxdb_client/_async/api_client.py b/influxdb_client/_async/api_client.py index ac34e7e5..d0139b95 100644 --- a/influxdb_client/_async/api_client.py +++ b/influxdb_client/_async/api_client.py @@ -70,7 +70,7 @@ def __init__(self, configuration=None, header_name=None, header_value=None, self.configuration = configuration self.pool_threads = pool_threads - self.rest_client = rest.RESTClientObjectAsync(configuration, retries=retries) + self.rest_client = rest.RESTClientObjectAsync(configuration) self.default_headers = {} if header_name is not None: self.default_headers[header_name] = header_value @@ -87,8 +87,6 @@ async def close(self): self._pool.close() self._pool.join() self._pool = None - if self.rest_client and self.rest_client.pool_manager and hasattr(self.rest_client.pool_manager, 'clear'): - self.rest_client.pool_manager.clear() @property def pool(self): diff --git a/influxdb_client/client/_base.py b/influxdb_client/client/_base.py new file mode 100644 index 00000000..3dce55a7 --- /dev/null +++ b/influxdb_client/client/_base.py @@ -0,0 +1,76 @@ +"""Commons function for Sync and Async client.""" +import base64 + +from influxdb_client import Configuration + + +class _BaseClient(object): + def __init__(self, url, token, debug=None, timeout=10_000, enable_gzip=False, org: str = None, + default_tags: dict = None, **kwargs) -> None: + self.url = url + self.token = token + self.org = org + + self.default_tags = default_tags + + self.conf = _Configuration() + if self.url.endswith("/"): + self.conf.host = self.url[:-1] + else: + self.conf.host = self.url + self.conf.enable_gzip = enable_gzip + self.conf.debug = debug + self.conf.verify_ssl = kwargs.get('verify_ssl', True) + self.conf.ssl_ca_cert = kwargs.get('ssl_ca_cert', None) + self.conf.proxy = kwargs.get('proxy', None) + self.conf.proxy_headers = kwargs.get('proxy_headers', None) + self.conf.connection_pool_maxsize = kwargs.get('connection_pool_maxsize', self.conf.connection_pool_maxsize) + self.conf.timeout = timeout + + auth_token = self.token + self.auth_header_name = "Authorization" + self.auth_header_value = "Token " + auth_token + + auth_basic = kwargs.get('auth_basic', False) + if auth_basic: + self.auth_header_value = "Basic " + base64.b64encode(token.encode()).decode() + + self.retries = kwargs.get('retries', False) + + self.profilers = kwargs.get('profilers', None) + pass + + +class _Configuration(Configuration): + def __init__(self): + Configuration.__init__(self) + self.enable_gzip = False + + def update_request_header_params(self, path: str, params: dict): + super().update_request_header_params(path, params) + if self.enable_gzip: + # GZIP Request + if path == '/api/v2/write': + params["Content-Encoding"] = "gzip" + params["Accept-Encoding"] = "identity" + pass + # GZIP Response + if path == '/api/v2/query': + # params["Content-Encoding"] = "gzip" + params["Accept-Encoding"] = "gzip" + pass + pass + pass + + def update_request_body(self, path: str, body): + _body = super().update_request_body(path, body) + if self.enable_gzip: + # GZIP Request + if path == '/api/v2/write': + import gzip + if isinstance(_body, bytes): + return gzip.compress(data=_body) + else: + return gzip.compress(bytes(_body, "utf-8")) + + return _body diff --git a/influxdb_client/client/influxdb_client.py b/influxdb_client/client/influxdb_client.py index 7ccb94d0..289548a6 100644 --- a/influxdb_client/client/influxdb_client.py +++ b/influxdb_client/client/influxdb_client.py @@ -2,14 +2,14 @@ from __future__ import absolute_import -import base64 import configparser import logging import os import warnings -from influxdb_client import Configuration, HealthCheck, HealthService, Ready, ReadyService, PingService, \ +from influxdb_client import HealthCheck, HealthService, Ready, ReadyService, PingService, \ InvocableScriptsApi +from influxdb_client.client._base import _BaseClient from influxdb_client.client.authorizations_api import AuthorizationsApi from influxdb_client.client.bucket_api import BucketsApi from influxdb_client.client.delete_api import DeleteApi @@ -23,7 +23,7 @@ logger = logging.getLogger(__name__) -class InfluxDBClient(object): +class InfluxDBClient(_BaseClient): """InfluxDBClient is client for InfluxDB v2.""" def __init__(self, url, token, debug=None, timeout=10_000, enable_gzip=False, org: str = None, @@ -54,41 +54,12 @@ def __init__(self, url, token, debug=None, timeout=10_000, enable_gzip=False, or (defaults to false, don't set to true when talking to InfluxDB 2) :key list[str] profilers: list of enabled Flux profilers """ - self.url = url - self.token = token - self.org = org - - self.default_tags = default_tags - - conf = _Configuration() - if self.url.endswith("/"): - conf.host = self.url[:-1] - else: - conf.host = self.url - conf.enable_gzip = enable_gzip - conf.debug = debug - conf.verify_ssl = kwargs.get('verify_ssl', True) - conf.ssl_ca_cert = kwargs.get('ssl_ca_cert', None) - conf.proxy = kwargs.get('proxy', None) - conf.proxy_headers = kwargs.get('proxy_headers', None) - conf.connection_pool_maxsize = kwargs.get('connection_pool_maxsize', conf.connection_pool_maxsize) - conf.timeout = timeout - - auth_token = self.token - auth_header_name = "Authorization" - auth_header_value = "Token " + auth_token - - auth_basic = kwargs.get('auth_basic', False) - if auth_basic: - auth_header_value = "Basic " + base64.b64encode(token.encode()).decode() - - retries = kwargs.get('retries', False) - - self.profilers = kwargs.get('profilers', None) + super().__init__(url=url, token=token, debug=debug, timeout=timeout, enable_gzip=enable_gzip, org=org, + default_tags=default_tags, **kwargs) from .._sync.api_client import ApiClient - self.api_client = ApiClient(configuration=conf, header_name=auth_header_name, - header_value=auth_header_value, retries=retries) + self.api_client = ApiClient(configuration=self.conf, header_name=self.auth_header_name, + header_value=self.auth_header_value, retries=self.retries) def __enter__(self): """ @@ -474,41 +445,6 @@ def delete_api(self) -> DeleteApi: return DeleteApi(self) -class _Configuration(Configuration): - def __init__(self): - Configuration.__init__(self) - self.enable_gzip = False - - def update_request_header_params(self, path: str, params: dict): - super().update_request_header_params(path, params) - if self.enable_gzip: - # GZIP Request - if path == '/api/v2/write': - params["Content-Encoding"] = "gzip" - params["Accept-Encoding"] = "identity" - pass - # GZIP Response - if path == '/api/v2/query': - # params["Content-Encoding"] = "gzip" - params["Accept-Encoding"] = "gzip" - pass - pass - pass - - def update_request_body(self, path: str, body): - _body = super().update_request_body(path, body) - if self.enable_gzip: - # GZIP Request - if path == '/api/v2/write': - import gzip - if isinstance(_body, bytes): - return gzip.compress(data=_body) - else: - return gzip.compress(bytes(_body, "utf-8")) - - return _body - - def _to_bool(bool_value): return str(bool_value).lower() in ("yes", "true") diff --git a/influxdb_client/client/influxdb_client_async.py b/influxdb_client/client/influxdb_client_async.py new file mode 100644 index 00000000..5352053c --- /dev/null +++ b/influxdb_client/client/influxdb_client_async.py @@ -0,0 +1,39 @@ +"""InfluxDBClientAsync is client for API defined in https://github.com/influxdata/influxdb/blob/master/http/swagger.yml.""" + +from influxdb_client.client._base import _BaseClient + + +class InfluxDBClientAsync(_BaseClient): + """InfluxDBClient is client for InfluxDB v2.""" + + def __init__(self, url, token, org: str = None, **kwargs) -> None: + """ + Initialize defaults. + + :param url: InfluxDB server API url (ex. http://localhost:8086). + :param token: auth token + :param org: organization name (used as a default in Query, Write and Delete API) + """ + super().__init__(url=url, token=token, org=org, **kwargs) + + from .._async.api_client import ApiClientAsync + self.api_client = ApiClientAsync(configuration=self.conf, header_name=self.auth_header_name, + header_value=self.auth_header_value, retries=self.retries) + + async def __aenter__(self) -> 'InfluxDBClientAsync': + """ + Enter the runtime context related to this object. + + return: self instance + """ + return self + + async def __aexit__(self, exc_type, exc, tb) -> None: + """Shutdown the client.""" + await self.close() + + async def close(self): + """Shutdown the client.""" + if self.api_client: + await self.api_client.close() + self.api_client = None diff --git a/setup.py b/setup.py index 48344c25..785f1f42 100644 --- a/setup.py +++ b/setup.py @@ -34,6 +34,10 @@ 'ciso8601>=2.1.1' ] +async_requires = [ + 'aiohttp>=3.8.1' +] + with open('README.rst', 'r') as f: readme = f.read() @@ -52,7 +56,7 @@ keywords=["InfluxDB", "InfluxDB Python Client"], tests_require=test_requires, install_requires=requires, - extras_require={'extra': extra_requires, 'ciso': ciso_requires, 'test': test_requires}, + extras_require={'extra': extra_requires, 'ciso': ciso_requires, 'async': async_requires, 'test': test_requires}, long_description_content_type="text/x-rst", packages=find_packages(exclude=('tests*',)), test_suite='tests', diff --git a/tests/test_InfluxDBClientAsync.py b/tests/test_InfluxDBClientAsync.py new file mode 100644 index 00000000..4faab5cc --- /dev/null +++ b/tests/test_InfluxDBClientAsync.py @@ -0,0 +1,28 @@ +import asyncio +import unittest + +from influxdb_client.client.influxdb_client_async import InfluxDBClientAsync + + +def async_test(coro): + def wrapper(*args, **kwargs): + loop = asyncio.new_event_loop() + try: + return loop.run_until_complete(coro(*args, **kwargs)) + finally: + loop.close() + return wrapper + + +class InfluxDBClientAsyncTest(unittest.TestCase): + + def setUp(self) -> None: + self.client = InfluxDBClientAsync(url="http://localhost:8086", token="my-token", org="my-org") + + @async_test + async def tearDown(self) -> None: + if self.client: + await self.client.close() + + def test_use_async_context_manager(self): + self.assertIsNotNone(self.client) From 9cd8a786ce68a072cb594f4feebb4f1a8dc6d8e3 Mon Sep 17 00:00:00 2001 From: Jakub Bednar Date: Thu, 3 Mar 2022 13:50:43 +0100 Subject: [PATCH 04/46] fix: CI --- scripts/ci-test.sh | 1 + 1 file changed, 1 insertion(+) diff --git a/scripts/ci-test.sh b/scripts/ci-test.sh index 10d89a0b..8e2cdd4e 100755 --- a/scripts/ci-test.sh +++ b/scripts/ci-test.sh @@ -11,6 +11,7 @@ python --version pip install -e . --user pip install -e .\[extra\] --user pip install -e .\[test\] --user +pip install -e .\[async\] --user if [ "$ENABLED_CISO_8601" = true ] ; then echo "ciso8601 is enabled" pip install -e .\[ciso\] --user From 7b6931a09f437387095c2133505b8e57ece96158 Mon Sep 17 00:00:00 2001 From: Jakub Bednar Date: Thu, 3 Mar 2022 14:01:46 +0100 Subject: [PATCH 05/46] fix: code style --- influxdb_client/client/influxdb_client_async.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/influxdb_client/client/influxdb_client_async.py b/influxdb_client/client/influxdb_client_async.py index 5352053c..5e866f33 100644 --- a/influxdb_client/client/influxdb_client_async.py +++ b/influxdb_client/client/influxdb_client_async.py @@ -1,4 +1,4 @@ -"""InfluxDBClientAsync is client for API defined in https://github.com/influxdata/influxdb/blob/master/http/swagger.yml.""" +"""InfluxDBClientAsync is client for API defined in https://github.com/influxdata/openapi/blob/master/contracts/oss.yml.""" # noqa: E501 from influxdb_client.client._base import _BaseClient From 3c55787c9e147a4d00f3648a3d6306dff0ccc26f Mon Sep 17 00:00:00 2001 From: Jakub Bednar Date: Thu, 3 Mar 2022 14:51:33 +0100 Subject: [PATCH 06/46] feat: implement async version, ping --- .circleci/config.yml | 2 + examples/README.md | 1 + examples/buckets_management.py | 2 +- influxdb_client/client/_base.py | 10 +++ influxdb_client/client/influxdb_client.py | 9 +-- .../client/influxdb_client_async.py | 30 ++++++++ influxdb_client/service/ping_service.py | 68 +++++++++++++++++++ 7 files changed, 115 insertions(+), 7 deletions(-) diff --git a/.circleci/config.yml b/.circleci/config.yml index 95f2a581..e2506cba 100644 --- a/.circleci/config.yml +++ b/.circleci/config.yml @@ -128,11 +128,13 @@ jobs: name: Checks that examples are runnable command: | pip install -e . --user + pip install -e .\[async\] --user export PYTHONPATH="$PWD" python examples/monitoring_and_alerting.py python examples/buckets_management.py python examples/write_structured_data.py python examples/write_api_callbacks.py + python examples/asynchronous.py check-sphinx: docker: - image: *default-python diff --git a/examples/README.md b/examples/README.md index 2f262e9a..7c1a2ca8 100644 --- a/examples/README.md +++ b/examples/README.md @@ -29,4 +29,5 @@ - [influxdb_18_example.py](influxdb_18_example.py) - How to connect to InfluxDB 1.8 - [nanosecond_precision.py](nanosecond_precision.py) - How to use nanoseconds precision - [invocable_scripts.py](invocable_scripts.py) - How to use Invocable scripts Cloud API to create custom endpoints that query data +- [asynchronous.py](asynchronous.py) - How to use Asyncio with InfluxDB client diff --git a/examples/buckets_management.py b/examples/buckets_management.py index 2e261fd3..cc81b58f 100644 --- a/examples/buckets_management.py +++ b/examples/buckets_management.py @@ -1,5 +1,5 @@ """ -How to How to create, list and delete Buckets. +How to create, list and delete Buckets. """ from influxdb_client import InfluxDBClient, BucketRetentionRules diff --git a/influxdb_client/client/_base.py b/influxdb_client/client/_base.py index 3dce55a7..81f27abf 100644 --- a/influxdb_client/client/_base.py +++ b/influxdb_client/client/_base.py @@ -1,9 +1,12 @@ """Commons function for Sync and Async client.""" +from __future__ import absolute_import + import base64 from influxdb_client import Configuration +# noinspection PyMethodMayBeStatic class _BaseClient(object): def __init__(self, url, token, debug=None, timeout=10_000, enable_gzip=False, org: str = None, default_tags: dict = None, **kwargs) -> None: @@ -40,6 +43,13 @@ def __init__(self, url, token, debug=None, timeout=10_000, enable_gzip=False, or self.profilers = kwargs.get('profilers', None) pass + def _version(self, response) -> str: + if response is not None and len(response) >= 3: + if 'X-Influxdb-Version' in response[2]: + return response[2]['X-Influxdb-Version'] + + return "unknown" + class _Configuration(Configuration): def __init__(self): diff --git a/influxdb_client/client/influxdb_client.py b/influxdb_client/client/influxdb_client.py index 289548a6..081c648c 100644 --- a/influxdb_client/client/influxdb_client.py +++ b/influxdb_client/client/influxdb_client.py @@ -20,7 +20,7 @@ from influxdb_client.client.users_api import UsersApi from influxdb_client.client.write_api import WriteApi, WriteOptions, PointSettings -logger = logging.getLogger(__name__) +logger = logging.getLogger('influxdb_client.client.influxdb_client') class InfluxDBClient(_BaseClient): @@ -399,7 +399,7 @@ def health(self) -> HealthCheck: def ping(self) -> bool: """ - Return the the status of InfluxDB instance. + Return the status of InfluxDB instance. :return: The status of InfluxDB. """ @@ -421,11 +421,8 @@ def version(self) -> str: ping_service = PingService(self.api_client) response = ping_service.get_ping_with_http_info(_return_http_data_only=False) - if response is not None and len(response) >= 3: - if 'X-Influxdb-Version' in response[2]: - return response[2]['X-Influxdb-Version'] - return "unknown" + return self._version(response) def ready(self) -> Ready: """ diff --git a/influxdb_client/client/influxdb_client_async.py b/influxdb_client/client/influxdb_client_async.py index 5e866f33..f264255c 100644 --- a/influxdb_client/client/influxdb_client_async.py +++ b/influxdb_client/client/influxdb_client_async.py @@ -1,7 +1,11 @@ """InfluxDBClientAsync is client for API defined in https://github.com/influxdata/openapi/blob/master/contracts/oss.yml.""" # noqa: E501 +import logging +from influxdb_client import PingService from influxdb_client.client._base import _BaseClient +logger = logging.getLogger('influxdb_client.client.influxdb_client') + class InfluxDBClientAsync(_BaseClient): """InfluxDBClient is client for InfluxDB v2.""" @@ -37,3 +41,29 @@ async def close(self): if self.api_client: await self.api_client.close() self.api_client = None + + async def ping(self) -> bool: + """ + Return the status of InfluxDB instance. + + :return: The status of InfluxDB. + """ + ping_service = PingService(self.api_client) + + try: + await ping_service.get_ping_with_http_info() + return True + except Exception as ex: + logger.debug("Unexpected error during /ping: %s", ex) + raise ex + + async def version(self) -> str: + """ + Return the version of the connected InfluxDB Server. + + :return: The version of InfluxDB. + """ + ping_service = PingService(self.api_client) + + response = await ping_service.get_ping_with_http_info(_return_http_data_only=False) + return self._version(response) diff --git a/influxdb_client/service/ping_service.py b/influxdb_client/service/ping_service.py index 8e8c3768..41e74e2a 100644 --- a/influxdb_client/service/ping_service.py +++ b/influxdb_client/service/ping_service.py @@ -120,6 +120,74 @@ def get_ping_with_http_info(self, **kwargs): # noqa: E501,D401,D403 collection_formats=collection_formats, urlopen_kw=urlopen_kw) + async def get_ping_async(self, **kwargs): # noqa: E501,D401,D403 + """Checks the status of InfluxDB instance and version of InfluxDB.. + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.get_ping_with_http_info(async_req=True) + >>> result = thread.get() + + :param async_req bool + :return: None + If the method is called asynchronously, + returns the request thread. + """ # noqa: E501 + local_var_params = locals() + + all_params = [] # noqa: E501 + all_params.append('async_req') + all_params.append('_return_http_data_only') + all_params.append('_preload_content') + all_params.append('_request_timeout') + all_params.append('urlopen_kw') + + for key, val in six.iteritems(local_var_params['kwargs']): + if key not in all_params: + raise TypeError( + "Got an unexpected keyword argument '%s'" + " to method get_ping" % key + ) + local_var_params[key] = val + del local_var_params['kwargs'] + + collection_formats = {} + + path_params = {} + + query_params = [] + + header_params = {} + + form_params = [] + local_var_files = {} + + body_params = None + # Authentication setting + auth_settings = [] # noqa: E501 + + # urlopen optional setting + urlopen_kw = None + if 'urlopen_kw' in kwargs: + urlopen_kw = kwargs['urlopen_kw'] + + return await self.api_client.call_api( + '/ping', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=form_params, + files=local_var_files, + response_type=None, # noqa: E501 + auth_settings=auth_settings, + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats=collection_formats, + urlopen_kw=urlopen_kw) + def head_ping(self, **kwargs): # noqa: E501,D401,D403 """Checks the status of InfluxDB instance and version of InfluxDB.. From 44c9d3e917bd040aa04ace0368ff465d5418871b Mon Sep 17 00:00:00 2001 From: Jakub Bednar Date: Thu, 3 Mar 2022 14:55:45 +0100 Subject: [PATCH 07/46] feat: add asynchronous.py example --- examples/asynchronous.py | 19 +++++++++++++++++++ 1 file changed, 19 insertions(+) create mode 100644 examples/asynchronous.py diff --git a/examples/asynchronous.py b/examples/asynchronous.py new file mode 100644 index 00000000..3e284c4a --- /dev/null +++ b/examples/asynchronous.py @@ -0,0 +1,19 @@ +""" +How to use Asyncio with InfluxDB client. +""" +import asyncio + +from influxdb_client.client.influxdb_client_async import InfluxDBClientAsync + + +async def main(): + async with InfluxDBClientAsync(url="http://localhost:8086", token="my-token", org="my-org") as client: + """ + Check the version of the InfluxDB + """ + version = await client.version() + print(f"InfluxDB: {version}") + + +if __name__ == "__main__": + asyncio.run(main()) From 5848ace270e9a5d61c7e83e04d92f4086f523bdd Mon Sep 17 00:00:00 2001 From: Jakub Bednar Date: Thu, 3 Mar 2022 15:10:28 +0100 Subject: [PATCH 08/46] chore: add tests for ping and version --- tests/test_InfluxDBClientAsync.py | 19 +++++++++++++------ 1 file changed, 13 insertions(+), 6 deletions(-) diff --git a/tests/test_InfluxDBClientAsync.py b/tests/test_InfluxDBClientAsync.py index 4faab5cc..75318fd1 100644 --- a/tests/test_InfluxDBClientAsync.py +++ b/tests/test_InfluxDBClientAsync.py @@ -6,17 +6,14 @@ def async_test(coro): def wrapper(*args, **kwargs): - loop = asyncio.new_event_loop() - try: - return loop.run_until_complete(coro(*args, **kwargs)) - finally: - loop.close() + return asyncio.get_event_loop().run_until_complete(coro(*args, **kwargs)) return wrapper class InfluxDBClientAsyncTest(unittest.TestCase): - def setUp(self) -> None: + @async_test + async def setUp(self) -> None: self.client = InfluxDBClientAsync(url="http://localhost:8086", token="my-token", org="my-org") @async_test @@ -26,3 +23,13 @@ async def tearDown(self) -> None: def test_use_async_context_manager(self): self.assertIsNotNone(self.client) + + @async_test + async def test_ping(self): + ping = await self.client.ping() + self.assertTrue(ping) + + @async_test + async def test_version(self): + version = await self.client.version() + self.assertTrue(len(version) > 0) From 1719120478d485191b25767b2d8e5d98f646c713 Mon Sep 17 00:00:00 2001 From: Jakub Bednar Date: Thu, 3 Mar 2022 15:19:26 +0100 Subject: [PATCH 09/46] chore: add tests for ping and version --- docs/api.rst | 5 +++++ influxdb_client/client/influxdb_client_async.py | 2 +- 2 files changed, 6 insertions(+), 1 deletion(-) diff --git a/docs/api.rst b/docs/api.rst index 41990f07..3a1731b0 100644 --- a/docs/api.rst +++ b/docs/api.rst @@ -81,6 +81,11 @@ DeleteApi .. autoclass:: influxdb_client.domain.DeletePredicateRequest :members: +InfluxDBClientAsync +""""""""""""""""""" +.. autoclass:: influxdb_client.client.influxdb_client_async.InfluxDBClientAsync + :members: + Helpers """"""" .. autoclass:: influxdb_client.client.util.date_utils.DateHelper diff --git a/influxdb_client/client/influxdb_client_async.py b/influxdb_client/client/influxdb_client_async.py index f264255c..ab198b6b 100644 --- a/influxdb_client/client/influxdb_client_async.py +++ b/influxdb_client/client/influxdb_client_async.py @@ -8,7 +8,7 @@ class InfluxDBClientAsync(_BaseClient): - """InfluxDBClient is client for InfluxDB v2.""" + """InfluxDBClientAsync is client for InfluxDB v2.""" def __init__(self, url, token, org: str = None, **kwargs) -> None: """ From a47dddc721c1a4e0a95ddf7fea6e640a5837a6d0 Mon Sep 17 00:00:00 2001 From: Jakub Bednar Date: Thu, 3 Mar 2022 15:37:58 +0100 Subject: [PATCH 10/46] chore: prepare query and write api for async API --- influxdb_client/service/query_service.py | 103 +++++++++++++++- influxdb_client/service/write_service.py | 151 ++++++++++++++++++++--- 2 files changed, 234 insertions(+), 20 deletions(-) diff --git a/influxdb_client/service/query_service.py b/influxdb_client/service/query_service.py index 884b5792..b5632473 100644 --- a/influxdb_client/service/query_service.py +++ b/influxdb_client/service/query_service.py @@ -245,8 +245,8 @@ def post_query(self, **kwargs): # noqa: E501,D401,D403 :param str zap_trace_span: OpenTracing span context :param str accept_encoding: Indicates the content encoding (usually a compression algorithm) that the client can understand. :param str content_type: - :param str org: Specifies the name of the organization executing the query. Takes either the ID or Name. If both `orgID` and `org` are specified, `org` takes precedence. - :param str org_id: Specifies the ID of the organization executing the query. If both `orgID` and `org` are specified, `org` takes precedence. + :param str org: Name of the organization executing the query. Accepts either the ID or Name. If you provide both `orgID` and `org`, `org` takes precedence. + :param str org_id: ID of the organization executing the query. If you provide both `orgID` and `org`, `org` takes precedence. :param Query query: Flux query or specification to execute :return: str If the method is called asynchronously, @@ -272,8 +272,8 @@ def post_query_with_http_info(self, **kwargs): # noqa: E501,D401,D403 :param str zap_trace_span: OpenTracing span context :param str accept_encoding: Indicates the content encoding (usually a compression algorithm) that the client can understand. :param str content_type: - :param str org: Specifies the name of the organization executing the query. Takes either the ID or Name. If both `orgID` and `org` are specified, `org` takes precedence. - :param str org_id: Specifies the ID of the organization executing the query. If both `orgID` and `org` are specified, `org` takes precedence. + :param str org: Name of the organization executing the query. Accepts either the ID or Name. If you provide both `orgID` and `org`, `org` takes precedence. + :param str org_id: ID of the organization executing the query. If you provide both `orgID` and `org`, `org` takes precedence. :param Query query: Flux query or specification to execute :return: str If the method is called asynchronously, @@ -354,6 +354,101 @@ def post_query_with_http_info(self, **kwargs): # noqa: E501,D401,D403 collection_formats=collection_formats, urlopen_kw=urlopen_kw) + async def post_query_async(self, **kwargs): # noqa: E501,D401,D403 + """Query data. + + Retrieves data from InfluxDB buckets. To query data, you need the following: - **organization** – _See [View organizations](https://docs.influxdata.com/influxdb/v2.1/organizations/view-orgs/#view-your-organization-id) for instructions on viewing your organization ID._ - **API token** – _See [View tokens](https://docs.influxdata.com/influxdb/v2.1/security/tokens/view-tokens/) for instructions on viewing your API token._ - **InfluxDB URL** – _See [InfluxDB URLs](https://docs.influxdata.com/influxdb/v2.1/reference/urls/)_. - **Flux query** – _See [Flux](https://docs.influxdata.com/flux/v0.x/)._ For more information and examples, see [Query with the InfluxDB API](https://docs.influxdata.com/influxdb/v2.1/query-data/execute-queries/influx-api/). + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.post_query_with_http_info(async_req=True) + >>> result = thread.get() + + :param async_req bool + :param str zap_trace_span: OpenTracing span context + :param str accept_encoding: Indicates the content encoding (usually a compression algorithm) that the client can understand. + :param str content_type: + :param str org: Name of the organization executing the query. Accepts either the ID or Name. If you provide both `orgID` and `org`, `org` takes precedence. + :param str org_id: ID of the organization executing the query. If you provide both `orgID` and `org`, `org` takes precedence. + :param Query query: Flux query or specification to execute + :return: str + If the method is called asynchronously, + returns the request thread. + """ # noqa: E501 + local_var_params = locals() + + all_params = ['zap_trace_span', 'accept_encoding', 'content_type', 'org', 'org_id', 'query'] # noqa: E501 + all_params.append('async_req') + all_params.append('_return_http_data_only') + all_params.append('_preload_content') + all_params.append('_request_timeout') + all_params.append('urlopen_kw') + + for key, val in six.iteritems(local_var_params['kwargs']): + if key not in all_params: + raise TypeError( + "Got an unexpected keyword argument '%s'" + " to method post_query" % key + ) + local_var_params[key] = val + del local_var_params['kwargs'] + + collection_formats = {} + + path_params = {} + + query_params = [] + if 'org' in local_var_params: + query_params.append(('org', local_var_params['org'])) # noqa: E501 + if 'org_id' in local_var_params: + query_params.append(('orgID', local_var_params['org_id'])) # noqa: E501 + + header_params = {} + if 'zap_trace_span' in local_var_params: + header_params['Zap-Trace-Span'] = local_var_params['zap_trace_span'] # noqa: E501 + if 'accept_encoding' in local_var_params: + header_params['Accept-Encoding'] = local_var_params['accept_encoding'] # noqa: E501 + if 'content_type' in local_var_params: + header_params['Content-Type'] = local_var_params['content_type'] # noqa: E501 + + form_params = [] + local_var_files = {} + + body_params = None + if 'query' in local_var_params: + body_params = local_var_params['query'] + # HTTP header `Accept` + header_params['Accept'] = self.api_client.select_header_accept( + ['text/csv', 'application/json']) # noqa: E501 + + # HTTP header `Content-Type` + header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501 + ['application/json', 'application/vnd.flux']) # noqa: E501 + + # Authentication setting + auth_settings = [] # noqa: E501 + + # urlopen optional setting + urlopen_kw = None + if 'urlopen_kw' in kwargs: + urlopen_kw = kwargs['urlopen_kw'] + + return await self.api_client.call_api( + '/api/v2/query', 'POST', + path_params, + query_params, + header_params, + body=body_params, + post_params=form_params, + files=local_var_files, + response_type='str', # noqa: E501 + auth_settings=auth_settings, + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats=collection_formats, + urlopen_kw=urlopen_kw) + def post_query_analyze(self, **kwargs): # noqa: E501,D401,D403 """Analyze a Flux query. diff --git a/influxdb_client/service/write_service.py b/influxdb_client/service/write_service.py index 6639a112..f666326a 100644 --- a/influxdb_client/service/write_service.py +++ b/influxdb_client/service/write_service.py @@ -35,23 +35,23 @@ def __init__(self, api_client=None): # noqa: E501,D401,D403 def post_write(self, org, bucket, body, **kwargs): # noqa: E501,D401,D403 """Write data. - Writes data to a bucket. To write data into InfluxDB, you need the following: - **organization name or ID** – _See [View organizations](https://docs.influxdata.com/influxdb/v2.1/organizations/view-orgs/#view-your-organization-id) for instructions on viewing your organization ID._ - **bucket** – _See [View buckets](https://docs.influxdata.com/influxdb/v2.1/organizations/buckets/view-buckets/) for instructions on viewing your bucket ID._ - **API token** – _See [View tokens](https://docs.influxdata.com/influxdb/v2.1/security/tokens/view-tokens/) for instructions on viewing your API token._ - **InfluxDB URL** – _See [InfluxDB URLs](https://docs.influxdata.com/influxdb/v2.1/reference/urls/)_. - data in [line protocol](https://docs.influxdata.com/influxdb/v2.1/reference/syntax/line-protocol) format. InfluxDB Cloud enforces rate and size limits different from InfluxDB OSS. For details, see Responses. For more information and examples, see the following: - [Write data with the InfluxDB API](https://docs.influxdata.com/influxdb/v2.1/write-data/developer-tools/api). - [Optimize writes to InfluxDB](https://docs.influxdata.com/influxdb/v2.1/write-data/best-practices/optimize-writes/). + Writes data to a bucket. To write data into InfluxDB, you need the following: - **organization name or ID** – _See [View organizations](https://docs.influxdata.com/influxdb/v2.1/organizations/view-orgs/#view-your-organization-id) for instructions on viewing your organization ID._ - **bucket** – _See [View buckets](https://docs.influxdata.com/influxdb/v2.1/organizations/buckets/view-buckets/) for instructions on viewing your bucket ID._ - **API token** – _See [View tokens](https://docs.influxdata.com/influxdb/v2.1/security/tokens/view-tokens/) for instructions on viewing your API token._ - **InfluxDB URL** – _See [InfluxDB URLs](https://docs.influxdata.com/influxdb/v2.1/reference/urls/)_. - data in [line protocol](https://docs.influxdata.com/influxdb/v2.1/reference/syntax/line-protocol) format. InfluxDB Cloud enforces rate and size limits different from InfluxDB OSS. For details, see Responses. For more information and examples, see the following: - [Write data with the InfluxDB API](https://docs.influxdata.com/influxdb/v2.1/write-data/developer-tools/api). - [Optimize writes to InfluxDB](https://docs.influxdata.com/influxdb/v2.1/write-data/best-practices/optimize-writes/). - [Troubleshoot issues writing data](https://docs.influxdata.com/influxdb/v2.1/write-data/troubleshoot/) This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.post_write(org, bucket, body, async_req=True) >>> result = thread.get() :param async_req bool - :param str org: The parameter value specifies the destination organization for writes. The database writes all points in the batch to this organization. If you provide both `orgID` and `org` parameters, `org` takes precedence. (required) - :param str bucket: The destination bucket for writes. (required) + :param str org: Destination organization for writes. The database writes all points in the batch to this organization. If you provide both `orgID` and `org` parameters, `org` takes precedence. (required) + :param str bucket: Destination bucket for writes. (required) :param str body: Data in line protocol format. (required) :param str zap_trace_span: OpenTracing span context :param str content_encoding: The value tells InfluxDB what compression is applied to the line protocol in the request payload. To make an API request with a GZIP payload, send `Content-Encoding: gzip` as a request header. - :param str content_type: The header value indicates the format of the data in the request body. - :param int content_length: The header value indicates the size of the entity-body, in bytes, sent to the database. If the length is greater than the database's `max body` configuration option, the server responds with status code `413`. - :param str accept: The header value specifies the response format. - :param str org_id: The parameter value specifies the ID of the destination organization for writes. If both `orgID` and `org` are specified, `org` takes precedence. - :param WritePrecision precision: The precision for the unix timestamps within the body line-protocol. + :param str content_type: Format of the data in the request body. To make an API request with a line protocol payload, send `Content-Type: text/plain; charset=utf-8` as a request header. + :param int content_length: Size of the entity-body, in bytes, sent to the database. If the length is greater than the database's `max body` configuration option, the server responds with status code `413`. + :param str accept: Content type that the client can understand. Writes only return a response body if they fail, e.g. due to a formatting problem or quota limit. #### InfluxDB Cloud - returns only `application/json` for format and limit errors. - returns only `text/html` for some quota limit errors. #### InfluxDB OSS - returns only `application/json` for format and limit errors. For more information about write errors, see how to [troubleshoot issues writing data](https://docs.influxdata.com/influxdb/v2.1/write-data/troubleshoot/). + :param str org_id: ID of the destination organization for writes. If both `orgID` and `org` are specified, `org` takes precedence. + :param WritePrecision precision: Precision for unix timestamps in the line protocol of the request payload. :return: None If the method is called asynchronously, returns the request thread. @@ -66,23 +66,23 @@ def post_write(self, org, bucket, body, **kwargs): # noqa: E501,D401,D403 def post_write_with_http_info(self, org, bucket, body, **kwargs): # noqa: E501,D401,D403 """Write data. - Writes data to a bucket. To write data into InfluxDB, you need the following: - **organization name or ID** – _See [View organizations](https://docs.influxdata.com/influxdb/v2.1/organizations/view-orgs/#view-your-organization-id) for instructions on viewing your organization ID._ - **bucket** – _See [View buckets](https://docs.influxdata.com/influxdb/v2.1/organizations/buckets/view-buckets/) for instructions on viewing your bucket ID._ - **API token** – _See [View tokens](https://docs.influxdata.com/influxdb/v2.1/security/tokens/view-tokens/) for instructions on viewing your API token._ - **InfluxDB URL** – _See [InfluxDB URLs](https://docs.influxdata.com/influxdb/v2.1/reference/urls/)_. - data in [line protocol](https://docs.influxdata.com/influxdb/v2.1/reference/syntax/line-protocol) format. InfluxDB Cloud enforces rate and size limits different from InfluxDB OSS. For details, see Responses. For more information and examples, see the following: - [Write data with the InfluxDB API](https://docs.influxdata.com/influxdb/v2.1/write-data/developer-tools/api). - [Optimize writes to InfluxDB](https://docs.influxdata.com/influxdb/v2.1/write-data/best-practices/optimize-writes/). + Writes data to a bucket. To write data into InfluxDB, you need the following: - **organization name or ID** – _See [View organizations](https://docs.influxdata.com/influxdb/v2.1/organizations/view-orgs/#view-your-organization-id) for instructions on viewing your organization ID._ - **bucket** – _See [View buckets](https://docs.influxdata.com/influxdb/v2.1/organizations/buckets/view-buckets/) for instructions on viewing your bucket ID._ - **API token** – _See [View tokens](https://docs.influxdata.com/influxdb/v2.1/security/tokens/view-tokens/) for instructions on viewing your API token._ - **InfluxDB URL** – _See [InfluxDB URLs](https://docs.influxdata.com/influxdb/v2.1/reference/urls/)_. - data in [line protocol](https://docs.influxdata.com/influxdb/v2.1/reference/syntax/line-protocol) format. InfluxDB Cloud enforces rate and size limits different from InfluxDB OSS. For details, see Responses. For more information and examples, see the following: - [Write data with the InfluxDB API](https://docs.influxdata.com/influxdb/v2.1/write-data/developer-tools/api). - [Optimize writes to InfluxDB](https://docs.influxdata.com/influxdb/v2.1/write-data/best-practices/optimize-writes/). - [Troubleshoot issues writing data](https://docs.influxdata.com/influxdb/v2.1/write-data/troubleshoot/) This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.post_write_with_http_info(org, bucket, body, async_req=True) >>> result = thread.get() :param async_req bool - :param str org: The parameter value specifies the destination organization for writes. The database writes all points in the batch to this organization. If you provide both `orgID` and `org` parameters, `org` takes precedence. (required) - :param str bucket: The destination bucket for writes. (required) + :param str org: Destination organization for writes. The database writes all points in the batch to this organization. If you provide both `orgID` and `org` parameters, `org` takes precedence. (required) + :param str bucket: Destination bucket for writes. (required) :param str body: Data in line protocol format. (required) :param str zap_trace_span: OpenTracing span context :param str content_encoding: The value tells InfluxDB what compression is applied to the line protocol in the request payload. To make an API request with a GZIP payload, send `Content-Encoding: gzip` as a request header. - :param str content_type: The header value indicates the format of the data in the request body. - :param int content_length: The header value indicates the size of the entity-body, in bytes, sent to the database. If the length is greater than the database's `max body` configuration option, the server responds with status code `413`. - :param str accept: The header value specifies the response format. - :param str org_id: The parameter value specifies the ID of the destination organization for writes. If both `orgID` and `org` are specified, `org` takes precedence. - :param WritePrecision precision: The precision for the unix timestamps within the body line-protocol. + :param str content_type: Format of the data in the request body. To make an API request with a line protocol payload, send `Content-Type: text/plain; charset=utf-8` as a request header. + :param int content_length: Size of the entity-body, in bytes, sent to the database. If the length is greater than the database's `max body` configuration option, the server responds with status code `413`. + :param str accept: Content type that the client can understand. Writes only return a response body if they fail, e.g. due to a formatting problem or quota limit. #### InfluxDB Cloud - returns only `application/json` for format and limit errors. - returns only `text/html` for some quota limit errors. #### InfluxDB OSS - returns only `application/json` for format and limit errors. For more information about write errors, see how to [troubleshoot issues writing data](https://docs.influxdata.com/influxdb/v2.1/write-data/troubleshoot/). + :param str org_id: ID of the destination organization for writes. If both `orgID` and `org` are specified, `org` takes precedence. + :param WritePrecision precision: Precision for unix timestamps in the line protocol of the request payload. :return: None If the method is called asynchronously, returns the request thread. @@ -181,3 +181,122 @@ def post_write_with_http_info(self, org, bucket, body, **kwargs): # noqa: E501, _request_timeout=local_var_params.get('_request_timeout'), collection_formats=collection_formats, urlopen_kw=urlopen_kw) + + async def post_write_async(self, org, bucket, body, **kwargs): # noqa: E501,D401,D403 + """Write data. + + Writes data to a bucket. To write data into InfluxDB, you need the following: - **organization name or ID** – _See [View organizations](https://docs.influxdata.com/influxdb/v2.1/organizations/view-orgs/#view-your-organization-id) for instructions on viewing your organization ID._ - **bucket** – _See [View buckets](https://docs.influxdata.com/influxdb/v2.1/organizations/buckets/view-buckets/) for instructions on viewing your bucket ID._ - **API token** – _See [View tokens](https://docs.influxdata.com/influxdb/v2.1/security/tokens/view-tokens/) for instructions on viewing your API token._ - **InfluxDB URL** – _See [InfluxDB URLs](https://docs.influxdata.com/influxdb/v2.1/reference/urls/)_. - data in [line protocol](https://docs.influxdata.com/influxdb/v2.1/reference/syntax/line-protocol) format. InfluxDB Cloud enforces rate and size limits different from InfluxDB OSS. For details, see Responses. For more information and examples, see the following: - [Write data with the InfluxDB API](https://docs.influxdata.com/influxdb/v2.1/write-data/developer-tools/api). - [Optimize writes to InfluxDB](https://docs.influxdata.com/influxdb/v2.1/write-data/best-practices/optimize-writes/). - [Troubleshoot issues writing data](https://docs.influxdata.com/influxdb/v2.1/write-data/troubleshoot/) + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.post_write_with_http_info(org, bucket, body, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param str org: Destination organization for writes. The database writes all points in the batch to this organization. If you provide both `orgID` and `org` parameters, `org` takes precedence. (required) + :param str bucket: Destination bucket for writes. (required) + :param str body: Data in line protocol format. (required) + :param str zap_trace_span: OpenTracing span context + :param str content_encoding: The value tells InfluxDB what compression is applied to the line protocol in the request payload. To make an API request with a GZIP payload, send `Content-Encoding: gzip` as a request header. + :param str content_type: Format of the data in the request body. To make an API request with a line protocol payload, send `Content-Type: text/plain; charset=utf-8` as a request header. + :param int content_length: Size of the entity-body, in bytes, sent to the database. If the length is greater than the database's `max body` configuration option, the server responds with status code `413`. + :param str accept: Content type that the client can understand. Writes only return a response body if they fail, e.g. due to a formatting problem or quota limit. #### InfluxDB Cloud - returns only `application/json` for format and limit errors. - returns only `text/html` for some quota limit errors. #### InfluxDB OSS - returns only `application/json` for format and limit errors. For more information about write errors, see how to [troubleshoot issues writing data](https://docs.influxdata.com/influxdb/v2.1/write-data/troubleshoot/). + :param str org_id: ID of the destination organization for writes. If both `orgID` and `org` are specified, `org` takes precedence. + :param WritePrecision precision: Precision for unix timestamps in the line protocol of the request payload. + :return: None + If the method is called asynchronously, + returns the request thread. + """ # noqa: E501 + local_var_params = locals() + + all_params = ['org', 'bucket', 'body', 'zap_trace_span', 'content_encoding', 'content_type', 'content_length', 'accept', 'org_id', 'precision'] # noqa: E501 + all_params.append('async_req') + all_params.append('_return_http_data_only') + all_params.append('_preload_content') + all_params.append('_request_timeout') + all_params.append('urlopen_kw') + + for key, val in six.iteritems(local_var_params['kwargs']): + if key not in all_params: + raise TypeError( + "Got an unexpected keyword argument '%s'" + " to method post_write" % key + ) + local_var_params[key] = val + del local_var_params['kwargs'] + # verify the required parameter 'org' is set + if ('org' not in local_var_params or + local_var_params['org'] is None): + raise ValueError("Missing the required parameter `org` when calling `post_write`") # noqa: E501 + # verify the required parameter 'bucket' is set + if ('bucket' not in local_var_params or + local_var_params['bucket'] is None): + raise ValueError("Missing the required parameter `bucket` when calling `post_write`") # noqa: E501 + # verify the required parameter 'body' is set + if ('body' not in local_var_params or + local_var_params['body'] is None): + raise ValueError("Missing the required parameter `body` when calling `post_write`") # noqa: E501 + + collection_formats = {} + + path_params = {} + + query_params = [] + if 'org' in local_var_params: + query_params.append(('org', local_var_params['org'])) # noqa: E501 + if 'org_id' in local_var_params: + query_params.append(('orgID', local_var_params['org_id'])) # noqa: E501 + if 'bucket' in local_var_params: + query_params.append(('bucket', local_var_params['bucket'])) # noqa: E501 + if 'precision' in local_var_params: + query_params.append(('precision', local_var_params['precision'])) # noqa: E501 + + header_params = {} + if 'zap_trace_span' in local_var_params: + header_params['Zap-Trace-Span'] = local_var_params['zap_trace_span'] # noqa: E501 + if 'content_encoding' in local_var_params: + header_params['Content-Encoding'] = local_var_params['content_encoding'] # noqa: E501 + if 'content_type' in local_var_params: + header_params['Content-Type'] = local_var_params['content_type'] # noqa: E501 + if 'content_length' in local_var_params: + header_params['Content-Length'] = local_var_params['content_length'] # noqa: E501 + if 'accept' in local_var_params: + header_params['Accept'] = local_var_params['accept'] # noqa: E501 + + form_params = [] + local_var_files = {} + + body_params = None + if 'body' in local_var_params: + body_params = local_var_params['body'] + # HTTP header `Accept` + header_params['Accept'] = self.api_client.select_header_accept( + ['application/json', 'text/html', ]) # noqa: E501 + + # HTTP header `Content-Type` + header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501 + ['text/plain']) # noqa: E501 + + # Authentication setting + auth_settings = [] # noqa: E501 + + # urlopen optional setting + urlopen_kw = None + if 'urlopen_kw' in kwargs: + urlopen_kw = kwargs['urlopen_kw'] + + return await self.api_client.call_api( + '/api/v2/write', 'POST', + path_params, + query_params, + header_params, + body=body_params, + post_params=form_params, + files=local_var_files, + response_type=None, # noqa: E501 + auth_settings=auth_settings, + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats=collection_formats, + urlopen_kw=urlopen_kw) From c525847e9bea09f3227c41ce24da603078de57d5 Mon Sep 17 00:00:00 2001 From: Jakub Bednar Date: Mon, 7 Mar 2022 08:33:15 +0100 Subject: [PATCH 11/46] chore: prepare QueryApi async --- influxdb_client/client/_base.py | 51 ++++++++++++++++++ .../client/influxdb_client_async.py | 11 ++++ .../client/invocable_scripts_api.py | 4 +- influxdb_client/client/query_api.py | 6 +-- influxdb_client/client/query_api_async.py | 23 ++++++++ influxdb_client/client/queryable_api.py | 53 ------------------- tests/test_InfluxDBClientAsync.py | 5 ++ 7 files changed, 95 insertions(+), 58 deletions(-) create mode 100644 influxdb_client/client/query_api_async.py delete mode 100644 influxdb_client/client/queryable_api.py diff --git a/influxdb_client/client/_base.py b/influxdb_client/client/_base.py index 81f27abf..651cf1dc 100644 --- a/influxdb_client/client/_base.py +++ b/influxdb_client/client/_base.py @@ -2,8 +2,15 @@ from __future__ import absolute_import import base64 +import codecs +import csv +from typing import Iterator, List, Generator, Any + +from urllib3 import HTTPResponse from influxdb_client import Configuration +from influxdb_client.client.flux_csv_parser import FluxResponseMetadataMode, FluxCsvParser, FluxSerializationMode +from influxdb_client.client.flux_table import FluxTable, FluxRecord # noinspection PyMethodMayBeStatic @@ -51,6 +58,50 @@ def _version(self, response) -> str: return "unknown" +# noinspection PyMethodMayBeStatic +class _BaseQueryApi(object): + """Base implementation for Queryable API.""" + + def _to_tables(self, response: HTTPResponse, query_options=None, + response_metadata_mode: FluxResponseMetadataMode = FluxResponseMetadataMode.full) -> List[FluxTable]: + """Parse HTTP response to FluxTables.""" + _parser = FluxCsvParser(response=response, serialization_mode=FluxSerializationMode.tables, + query_options=query_options, response_metadata_mode=response_metadata_mode) + list(_parser.generator()) + return _parser.table_list() + + def _to_csv(self, response: HTTPResponse) -> Iterator[List[str]]: + """Parse HTTP response to CSV.""" + return csv.reader(codecs.iterdecode(response, 'utf-8')) + + def _to_flux_record_stream(self, response, query_options=None, + response_metadata_mode: FluxResponseMetadataMode = FluxResponseMetadataMode.full) -> \ + Generator[FluxRecord, Any, None]: + """Parse HTTP response to FluxRecord stream.""" + _parser = FluxCsvParser(response=response, serialization_mode=FluxSerializationMode.stream, + query_options=query_options, response_metadata_mode=response_metadata_mode) + return _parser.generator() + + def _to_data_frame_stream(self, data_frame_index, response, query_options=None, + response_metadata_mode: FluxResponseMetadataMode = FluxResponseMetadataMode.full): + """Parse HTTP response to DataFrame stream.""" + _parser = FluxCsvParser(response=response, serialization_mode=FluxSerializationMode.dataFrame, + data_frame_index=data_frame_index, query_options=query_options, + response_metadata_mode=response_metadata_mode) + return _parser.generator() + + def _to_data_frames(self, _generator): + """Parse stream of DataFrames into expected type.""" + from ..extras import pd + _dataFrames = list(_generator) + if len(_dataFrames) == 0: + return pd.DataFrame(columns=[], index=None) + elif len(_dataFrames) == 1: + return _dataFrames[0] + else: + return _dataFrames + + class _Configuration(Configuration): def __init__(self): Configuration.__init__(self) diff --git a/influxdb_client/client/influxdb_client_async.py b/influxdb_client/client/influxdb_client_async.py index ab198b6b..c7322298 100644 --- a/influxdb_client/client/influxdb_client_async.py +++ b/influxdb_client/client/influxdb_client_async.py @@ -3,6 +3,8 @@ from influxdb_client import PingService from influxdb_client.client._base import _BaseClient +from influxdb_client.client.query_api import QueryOptions +from influxdb_client.client.query_api_async import QueryApiAsync logger = logging.getLogger('influxdb_client.client.influxdb_client') @@ -67,3 +69,12 @@ async def version(self) -> str: response = await ping_service.get_ping_with_http_info(_return_http_data_only=False) return self._version(response) + + def query_api(self, query_options: QueryOptions = QueryOptions()) -> QueryApiAsync: + """ + Create an asynchronous Query API instance. + + :param query_options: optional query api configuration + :return: Query api instance + """ + return QueryApiAsync(self, query_options) diff --git a/influxdb_client/client/invocable_scripts_api.py b/influxdb_client/client/invocable_scripts_api.py index ec52e2e8..ad130e59 100644 --- a/influxdb_client/client/invocable_scripts_api.py +++ b/influxdb_client/client/invocable_scripts_api.py @@ -9,12 +9,12 @@ from influxdb_client import Script, InvocableScriptsService, ScriptCreateRequest, ScriptUpdateRequest, \ ScriptInvocationParams +from influxdb_client.client._base import _BaseQueryApi from influxdb_client.client.flux_csv_parser import FluxResponseMetadataMode from influxdb_client.client.flux_table import FluxTable, FluxRecord -from influxdb_client.client.queryable_api import QueryableApi -class InvocableScriptsApi(QueryableApi): +class InvocableScriptsApi(_BaseQueryApi): """Use API invokable scripts to create custom InfluxDB API endpoints that query, process, and shape data.""" def __init__(self, influxdb_client): diff --git a/influxdb_client/client/query_api.py b/influxdb_client/client/query_api.py index cda86de3..6d9194ef 100644 --- a/influxdb_client/client/query_api.py +++ b/influxdb_client/client/query_api.py @@ -1,5 +1,5 @@ """ -Querying InfluxDB bu FluxLang. +Querying InfluxDB by FluxLang. Flux is InfluxData’s functional data scripting language designed for querying, analyzing, and acting on data. """ @@ -11,8 +11,8 @@ VariableAssignment, Identifier, OptionStatement, File, DurationLiteral, Duration, UnaryExpression, Expression, \ ImportDeclaration, MemberAssignment, MemberExpression, ArrayExpression from influxdb_client import Query, QueryService +from influxdb_client.client._base import _BaseQueryApi from influxdb_client.client.flux_table import FluxTable, FluxRecord -from influxdb_client.client.queryable_api import QueryableApi from influxdb_client.client.util.date_utils import get_date_helper from influxdb_client.client.util.helpers import get_org_query_param @@ -31,7 +31,7 @@ def __init__(self, profilers: List[str] = None, profiler_callback: Callable = No self.profiler_callback = profiler_callback -class QueryApi(QueryableApi): +class QueryApi(_BaseQueryApi): """Implementation for '/api/v2/query' endpoint.""" default_dialect = Dialect(header=True, delimiter=",", comment_prefix="#", diff --git a/influxdb_client/client/query_api_async.py b/influxdb_client/client/query_api_async.py new file mode 100644 index 00000000..b77dec0c --- /dev/null +++ b/influxdb_client/client/query_api_async.py @@ -0,0 +1,23 @@ +""" +Querying InfluxDB by FluxLang. + +Flux is InfluxData’s functional data scripting language designed for querying, analyzing, and acting on data. +""" + +from influxdb_client import QueryService +from influxdb_client.client._base import _BaseQueryApi +from influxdb_client.client.query_api import QueryOptions + + +class QueryApiAsync(_BaseQueryApi): + """Asynchronous implementation for '/api/v2/query' endpoint.""" + + def __init__(self, influxdb_client, query_options=QueryOptions()): + """ + Initialize query client. + + :param influxdb_client: influxdb client + """ + self._influxdb_client = influxdb_client + self._query_options = query_options + self._query_api = QueryService(influxdb_client.api_client) diff --git a/influxdb_client/client/queryable_api.py b/influxdb_client/client/queryable_api.py deleted file mode 100644 index de270a12..00000000 --- a/influxdb_client/client/queryable_api.py +++ /dev/null @@ -1,53 +0,0 @@ -"""Helper to share queryable function between APIs - query_api, invocable_scripts_api.""" -import codecs -import csv -from typing import List, Iterator, Generator, Any - -from urllib3 import HTTPResponse - -from influxdb_client.client.flux_csv_parser import FluxCsvParser, FluxSerializationMode, FluxResponseMetadataMode -from influxdb_client.client.flux_table import FluxTable, FluxRecord - - -# noinspection PyMethodMayBeStatic -class QueryableApi(object): - """Base implementation for Queryable API.""" - - def _to_tables(self, response: HTTPResponse, query_options=None, - response_metadata_mode: FluxResponseMetadataMode = FluxResponseMetadataMode.full) -> List[FluxTable]: - """Parse HTTP response to FluxTables.""" - _parser = FluxCsvParser(response=response, serialization_mode=FluxSerializationMode.tables, - query_options=query_options, response_metadata_mode=response_metadata_mode) - list(_parser.generator()) - return _parser.table_list() - - def _to_csv(self, response: HTTPResponse) -> Iterator[List[str]]: - """Parse HTTP response to CSV.""" - return csv.reader(codecs.iterdecode(response, 'utf-8')) - - def _to_flux_record_stream(self, response, query_options=None, - response_metadata_mode: FluxResponseMetadataMode = FluxResponseMetadataMode.full) -> \ - Generator['FluxRecord', Any, None]: - """Parse HTTP response to FluxRecord stream.""" - _parser = FluxCsvParser(response=response, serialization_mode=FluxSerializationMode.stream, - query_options=query_options, response_metadata_mode=response_metadata_mode) - return _parser.generator() - - def _to_data_frame_stream(self, data_frame_index, response, query_options=None, - response_metadata_mode: FluxResponseMetadataMode = FluxResponseMetadataMode.full): - """Parse HTTP response to DataFrame stream.""" - _parser = FluxCsvParser(response=response, serialization_mode=FluxSerializationMode.dataFrame, - data_frame_index=data_frame_index, query_options=query_options, - response_metadata_mode=response_metadata_mode) - return _parser.generator() - - def _to_data_frames(self, _generator): - """Parse stream of DataFrames into expected type.""" - from ..extras import pd - _dataFrames = list(_generator) - if len(_dataFrames) == 0: - return pd.DataFrame(columns=[], index=None) - elif len(_dataFrames) == 1: - return _dataFrames[0] - else: - return _dataFrames diff --git a/tests/test_InfluxDBClientAsync.py b/tests/test_InfluxDBClientAsync.py index 75318fd1..7d73411f 100644 --- a/tests/test_InfluxDBClientAsync.py +++ b/tests/test_InfluxDBClientAsync.py @@ -7,6 +7,7 @@ def async_test(coro): def wrapper(*args, **kwargs): return asyncio.get_event_loop().run_until_complete(coro(*args, **kwargs)) + return wrapper @@ -33,3 +34,7 @@ async def test_ping(self): async def test_version(self): version = await self.client.version() self.assertTrue(len(version) > 0) + + def test_create_query_api(self): + query_api = self.client.query_api() + self.assertIsNotNone(query_api) From 01dcceb382535b104181015fe08256621f9bc3f5 Mon Sep 17 00:00:00 2001 From: Jakub Bednar Date: Mon, 7 Mar 2022 13:31:36 +0100 Subject: [PATCH 12/46] chore: add async support into FluxCSVParser --- examples/asynchronous.py | 30 +++ examples/query.py | 2 - influxdb_client/client/_base.py | 147 ++++++++++++++- influxdb_client/client/flux_csv_parser.py | 220 +++++++++++++++++----- influxdb_client/client/query_api.py | 122 +----------- influxdb_client/client/query_api_async.py | 25 ++- tests/test_InfluxDBClientAsync.py | 30 +++ 7 files changed, 404 insertions(+), 172 deletions(-) diff --git a/examples/asynchronous.py b/examples/asynchronous.py index 3e284c4a..54fda7d3 100644 --- a/examples/asynchronous.py +++ b/examples/asynchronous.py @@ -3,7 +3,9 @@ """ import asyncio +from influxdb_client import InfluxDBClient, Point from influxdb_client.client.influxdb_client_async import InfluxDBClientAsync +from influxdb_client.client.write_api import SYNCHRONOUS async def main(): @@ -14,6 +16,34 @@ async def main(): version = await client.version() print(f"InfluxDB: {version}") + """ + Prepare data + """ + # tmp solution before implements WriteApiAsync + with InfluxDBClient(url="http://localhost:8086", token="my-token", org="my-org", debug=True) as client_sync: + write_api = client_sync.write_api(write_options=SYNCHRONOUS) + + """ + Prepare data + """ + _point1 = Point("my_measurement").tag("location", "Prague").field("temperature", 25.3) + _point2 = Point("my_measurement").tag("location", "New York").field("temperature", 24.3) + write_api.write(bucket="my-bucket", record=[_point1, _point2]) + + """ + Query: using Table structure + """ + query_api = client.query_api() + tables = await query_api.query('from(bucket:"my-bucket") |> range(start: -10m)') + + for table in tables: + print(table) + for record in table.records: + print(record.values) + + print() + print() + if __name__ == "__main__": asyncio.run(main()) diff --git a/examples/query.py b/examples/query.py index adf29844..c913ab4f 100644 --- a/examples/query.py +++ b/examples/query.py @@ -10,10 +10,8 @@ """ Prepare data """ - _point1 = Point("my_measurement").tag("location", "Prague").field("temperature", 25.3) _point2 = Point("my_measurement").tag("location", "New York").field("temperature", 24.3) - write_api.write(bucket="my-bucket", record=[_point1, _point2]) query_api = client.query_api() diff --git a/influxdb_client/client/_base.py b/influxdb_client/client/_base.py index 651cf1dc..64331a1a 100644 --- a/influxdb_client/client/_base.py +++ b/influxdb_client/client/_base.py @@ -4,13 +4,18 @@ import base64 import codecs import csv -from typing import Iterator, List, Generator, Any +from datetime import datetime, timedelta +from typing import Iterator, List, Generator, Any, Union, Iterable from urllib3 import HTTPResponse -from influxdb_client import Configuration +from influxdb_client import Configuration, Dialect, Query, OptionStatement, VariableAssignment, Identifier, \ + Expression, BooleanLiteral, IntegerLiteral, FloatLiteral, DateTimeLiteral, UnaryExpression, DurationLiteral, \ + Duration, StringLiteral, ArrayExpression, ImportDeclaration, MemberExpression, MemberAssignment, File from influxdb_client.client.flux_csv_parser import FluxResponseMetadataMode, FluxCsvParser, FluxSerializationMode from influxdb_client.client.flux_table import FluxTable, FluxRecord +from influxdb_client.client.util.date_utils import get_date_helper +from influxdb_client.client.util.helpers import get_org_query_param # noinspection PyMethodMayBeStatic @@ -60,16 +65,43 @@ def _version(self, response) -> str: # noinspection PyMethodMayBeStatic class _BaseQueryApi(object): + default_dialect = Dialect(header=True, delimiter=",", comment_prefix="#", + annotations=["datatype", "group", "default"], date_time_format="RFC3339") + + def __init__(self, influxdb_client, query_options=None): + from influxdb_client.client.query_api import QueryOptions + self._query_options = QueryOptions() if query_options is None else query_options + self._influxdb_client = influxdb_client + """Base implementation for Queryable API.""" - def _to_tables(self, response: HTTPResponse, query_options=None, - response_metadata_mode: FluxResponseMetadataMode = FluxResponseMetadataMode.full) -> List[FluxTable]: - """Parse HTTP response to FluxTables.""" - _parser = FluxCsvParser(response=response, serialization_mode=FluxSerializationMode.tables, - query_options=query_options, response_metadata_mode=response_metadata_mode) + def _to_tables(self, response, query_options=None, response_metadata_mode: + FluxResponseMetadataMode = FluxResponseMetadataMode.full) -> List[FluxTable]: + """ + Parse HTTP response to FluxTables. + + :param response: HTTP response from a HTTP client. Expected type: `urllib3.response.HTTPResponse`. + """ + _parser = self.to_tables_parser(response, query_options, response_metadata_mode) list(_parser.generator()) return _parser.table_list() + async def _to_tables_async(self, response, query_options=None, response_metadata_mode: + FluxResponseMetadataMode = FluxResponseMetadataMode.full) -> List[FluxTable]: + """ + Parse HTTP response to FluxTables. + + :param response: HTTP response from a HTTP client. Expected type: `aiohttp.client_reqrep.ClientResponse`. + """ + async with self.to_tables_parser(response, query_options, response_metadata_mode) as parser: + async for _ in parser.generator_async(): + pass + return parser.table_list() + + def to_tables_parser(self, response, query_options, response_metadata_mode): + return FluxCsvParser(response=response, serialization_mode=FluxSerializationMode.tables, + query_options=query_options, response_metadata_mode=response_metadata_mode) + def _to_csv(self, response: HTTPResponse) -> Iterator[List[str]]: """Parse HTTP response to CSV.""" return csv.reader(codecs.iterdecode(response, 'utf-8')) @@ -101,6 +133,107 @@ def _to_data_frames(self, _generator): else: return _dataFrames + def _org_param(self, org): + return get_org_query_param(org=org, client=self._influxdb_client) + + def _get_query_options(self): + if self._query_options and self._query_options.profilers: + return self._query_options + elif self._influxdb_client.profilers: + from influxdb_client.client.query_api import QueryOptions + return QueryOptions(profilers=self._influxdb_client.profilers) + + def _create_query(self, query, dialect=default_dialect, params: dict = None): + query_options = self._get_query_options() + profilers = query_options.profilers if query_options is not None else None + q = Query(query=query, dialect=dialect, extern=_BaseQueryApi._build_flux_ast(params, profilers)) + + if profilers: + print("\n===============") + print("Profiler: query") + print("===============") + print(query) + + return q + + @staticmethod + def _params_to_extern_ast(params: dict) -> List['OptionStatement']: + + statements = [] + for key, value in params.items(): + expression = _BaseQueryApi._parm_to_extern_ast(value) + if expression is None: + continue + + statements.append(OptionStatement("OptionStatement", + VariableAssignment("VariableAssignment", Identifier("Identifier", key), + expression))) + return statements + + @staticmethod + def _parm_to_extern_ast(value) -> Union[Expression, None]: + if value is None: + return None + if isinstance(value, bool): + return BooleanLiteral("BooleanLiteral", value) + elif isinstance(value, int): + return IntegerLiteral("IntegerLiteral", str(value)) + elif isinstance(value, float): + return FloatLiteral("FloatLiteral", value) + elif isinstance(value, datetime): + value = get_date_helper().to_utc(value) + return DateTimeLiteral("DateTimeLiteral", value.strftime('%Y-%m-%dT%H:%M:%S.%fZ')) + elif isinstance(value, timedelta): + _micro_delta = int(value / timedelta(microseconds=1)) + if _micro_delta < 0: + return UnaryExpression("UnaryExpression", argument=DurationLiteral("DurationLiteral", [ + Duration(magnitude=-_micro_delta, unit="us")]), operator="-") + else: + return DurationLiteral("DurationLiteral", [Duration(magnitude=_micro_delta, unit="us")]) + elif isinstance(value, str): + return StringLiteral("StringLiteral", str(value)) + elif isinstance(value, Iterable): + return ArrayExpression("ArrayExpression", + elements=list(map(lambda it: _BaseQueryApi._parm_to_extern_ast(it), value))) + else: + return value + + @staticmethod + def _build_flux_ast(params: dict = None, profilers: List[str] = None): + + imports = [] + body = [] + + if profilers is not None and len(profilers) > 0: + imports.append(ImportDeclaration( + "ImportDeclaration", + path=StringLiteral("StringLiteral", "profiler"))) + + elements = [] + for profiler in profilers: + elements.append(StringLiteral("StringLiteral", value=profiler)) + + member = MemberExpression( + "MemberExpression", + object=Identifier("Identifier", "profiler"), + _property=Identifier("Identifier", "enabledProfilers")) + + prof = OptionStatement( + "OptionStatement", + assignment=MemberAssignment( + "MemberAssignment", + member=member, + init=ArrayExpression( + "ArrayExpression", + elements=elements))) + + body.append(prof) + + if params is not None: + body.extend(_BaseQueryApi._params_to_extern_ast(params)) + + return File(package=None, name=None, type=None, imports=imports, body=body) + class _Configuration(Configuration): def __init__(self): diff --git a/influxdb_client/client/flux_csv_parser.py b/influxdb_client/client/flux_csv_parser.py index 7870cbc8..d0ef9480 100644 --- a/influxdb_client/client/flux_csv_parser.py +++ b/influxdb_client/client/flux_csv_parser.py @@ -7,8 +7,6 @@ from enum import Enum from typing import List -from urllib3 import HTTPResponse - from influxdb_client.client.flux_table import FluxTable, FluxColumn, FluxRecord from influxdb_client.client.util.date_utils import get_date_helper @@ -49,13 +47,28 @@ class FluxResponseMetadataMode(Enum): only_names = 2 +class _FluxCsvParserMetadata(object): + def __init__(self): + self.table_index = 0 + self.table_id = -1 + self.start_new_table = False + self.table = None + self.groups = [] + self.parsing_state_error = False + + class FluxCsvParser(object): """Parse to processing response from InfluxDB to FluxStructures or DataFrame.""" - def __init__(self, response: HTTPResponse, serialization_mode: FluxSerializationMode, + def __init__(self, response, serialization_mode: FluxSerializationMode, data_frame_index: List[str] = None, query_options=None, response_metadata_mode: FluxResponseMetadataMode = FluxResponseMetadataMode.full) -> None: - """Initialize defaults.""" + """ + Initialize defaults. + + :param response: HTTP response from a HTTP client. + Acceptable types: `urllib3.response.HTTPResponse`, `aiohttp.client_reqrep.ClientResponse`. + """ self._response = response self.tables = [] self._serialization_mode = serialization_mode @@ -64,7 +77,7 @@ def __init__(self, response: HTTPResponse, serialization_mode: FluxSerialization self._data_frame_values = [] self._profilers = query_options.profilers if query_options is not None else None self._profiler_callback = query_options.profiler_callback if query_options is not None else None - pass + self._async_mode = True if 'ClientResponse' in type(response).__name__ else False def __enter__(self): """Initialize CSV reader.""" @@ -75,106 +88,219 @@ def __exit__(self, exc_type, exc_val, exc_tb): """Close HTTP response.""" self._response.close() + async def __aenter__(self) -> 'FluxCsvParser': + """Initialize CSV reader.""" + self._reader = self._stream_reader_to_csv(self._response.content) + + return self + + async def _stream_reader_to_csv(self, stream): + async for line in stream: + yield list(csv_parser.reader(line.decode('utf-8').splitlines(), delimiter=','))[0] + + async def __aexit__(self, exc_type, exc_val, exc_tb) -> None: + """Shutdown the client.""" + self.__exit__(exc_type, exc_val, exc_tb) + def generator(self): """Return Python generator.""" with self as parser: yield from parser._parse_flux_response() + def generator_async(self): + """Return Python async-generator.""" + return self._parse_flux_response_async() + def _parse_flux_response(self): - table_index = 0 - table_id = -1 - start_new_table = False - table = None - groups = [] - parsing_state_error = False + metadata = _FluxCsvParserMetadata() for csv in self._reader: - # debug - # print("parsing: ", csv) + # Response has HTTP status ok, but response is error. + if len(csv) < 1: + continue + + if "error" == csv[1] and "reference" == csv[2]: + metadata.parsing_state_error = True + continue + + # Throw InfluxException with error response + if metadata.parsing_state_error: + error = csv[1] + reference_value = csv[2] + raise FluxQueryException(error, reference_value) + + token = csv[0] + # start new table + if (token in ANNOTATIONS and not metadata.start_new_table) or \ + (self._response_metadata_mode is FluxResponseMetadataMode.only_names and not metadata.table): + + # Return already parsed DataFrame + if (self._serialization_mode is FluxSerializationMode.dataFrame) & hasattr(self, '_data_frame'): + df = self._prepare_data_frame() + if not self._is_profiler_table(metadata.table): + yield df + + metadata.start_new_table = True + metadata.table = FluxTable() + self._insert_table(metadata.table, metadata.table_index) + metadata.table_index = metadata.table_index + 1 + metadata.table_id = -1 + elif metadata.table is None: + raise FluxCsvParserException("Unable to parse CSV response. FluxTable definition was not found.") + + # # datatype,string,long,dateTime:RFC3339,dateTime:RFC3339,dateTime:RFC3339,double,string,string,string + if ANNOTATION_DATATYPE == token: + self.add_data_types(metadata.table, csv) + + elif ANNOTATION_GROUP == token: + metadata.groups = csv + + elif ANNOTATION_DEFAULT == token: + self.add_default_empty_values(metadata.table, csv) + + else: + # parse column names + if metadata.start_new_table: + # Invocable scripts doesn't supports dialect => all columns are string + if not metadata.table.columns and \ + self._response_metadata_mode is FluxResponseMetadataMode.only_names: + self.add_data_types(metadata.table, list(map(lambda column: 'string', csv))) + metadata.groups = list(map(lambda column: 'false', csv)) + self.add_groups(metadata.table, metadata.groups) + self.add_column_names_and_tags(metadata.table, csv) + metadata.start_new_table = False + # Create DataFrame with default values + if self._serialization_mode is FluxSerializationMode.dataFrame: + from ..extras import pd + labels = list(map(lambda it: it.label, metadata.table.columns)) + self._data_frame = pd.DataFrame(data=[], columns=labels, index=None) + pass + continue + + # to int converions todo + current_id = int(csv[2]) + if metadata.table_id == -1: + metadata.table_id = current_id + + if metadata.table_id != current_id: + # create new table with previous column headers settings + flux_columns = metadata.table.columns + metadata.table = FluxTable() + metadata.table.columns.extend(flux_columns) + self._insert_table(metadata.table, metadata.table_index) + metadata.table_index = metadata.table_index + 1 + metadata.table_id = current_id + + flux_record = self.parse_record(metadata.table_index - 1, metadata.table, csv) + + if self._is_profiler_record(flux_record): + self._print_profiler_info(flux_record) + continue + + if self._serialization_mode is FluxSerializationMode.tables: + self.tables[metadata.table_index - 1].records.append(flux_record) + + if self._serialization_mode is FluxSerializationMode.stream: + yield flux_record + + if self._serialization_mode is FluxSerializationMode.dataFrame: + self._data_frame_values.append(flux_record.values) + pass + + # Return latest DataFrame + if (self._serialization_mode is FluxSerializationMode.dataFrame) & hasattr(self, '_data_frame'): + df = self._prepare_data_frame() + if not self._is_profiler_table(metadata.table): + yield df + + async def _parse_flux_response_async(self): + metadata = _FluxCsvParserMetadata() + async for csv in self._reader: # Response has HTTP status ok, but response is error. if len(csv) < 1: continue if "error" == csv[1] and "reference" == csv[2]: - parsing_state_error = True + metadata.parsing_state_error = True continue # Throw InfluxException with error response - if parsing_state_error: + if metadata.parsing_state_error: error = csv[1] reference_value = csv[2] raise FluxQueryException(error, reference_value) token = csv[0] # start new table - if (token in ANNOTATIONS and not start_new_table) or \ - (self._response_metadata_mode is FluxResponseMetadataMode.only_names and not table): + if (token in ANNOTATIONS and not metadata.start_new_table) or \ + (self._response_metadata_mode is FluxResponseMetadataMode.only_names and not metadata.table): # Return already parsed DataFrame if (self._serialization_mode is FluxSerializationMode.dataFrame) & hasattr(self, '_data_frame'): df = self._prepare_data_frame() - if not self._is_profiler_table(table): + if not self._is_profiler_table(metadata.table): yield df - start_new_table = True - table = FluxTable() - self._insert_table(table, table_index) - table_index = table_index + 1 - table_id = -1 - elif table is None: + metadata.start_new_table = True + metadata.table = FluxTable() + self._insert_table(metadata.table, metadata.table_index) + metadata.table_index = metadata.table_index + 1 + metadata.table_id = -1 + elif metadata.table is None: raise FluxCsvParserException("Unable to parse CSV response. FluxTable definition was not found.") # # datatype,string,long,dateTime:RFC3339,dateTime:RFC3339,dateTime:RFC3339,double,string,string,string if ANNOTATION_DATATYPE == token: - self.add_data_types(table, csv) + self.add_data_types(metadata.table, csv) elif ANNOTATION_GROUP == token: - groups = csv + metadata.groups = csv elif ANNOTATION_DEFAULT == token: - self.add_default_empty_values(table, csv) + self.add_default_empty_values(metadata.table, csv) else: # parse column names - if start_new_table: + if metadata.start_new_table: # Invocable scripts doesn't supports dialect => all columns are string - if not table.columns and self._response_metadata_mode is FluxResponseMetadataMode.only_names: - self.add_data_types(table, list(map(lambda column: 'string', csv))) - groups = list(map(lambda column: 'false', csv)) - self.add_groups(table, groups) - self.add_column_names_and_tags(table, csv) - start_new_table = False + if not metadata.table.columns and \ + self._response_metadata_mode is FluxResponseMetadataMode.only_names: + self.add_data_types(metadata.table, list(map(lambda column: 'string', csv))) + metadata.groups = list(map(lambda column: 'false', csv)) + self.add_groups(metadata.table, metadata.groups) + self.add_column_names_and_tags(metadata.table, csv) + metadata.start_new_table = False # Create DataFrame with default values if self._serialization_mode is FluxSerializationMode.dataFrame: from ..extras import pd - labels = list(map(lambda it: it.label, table.columns)) + labels = list(map(lambda it: it.label, metadata.table.columns)) self._data_frame = pd.DataFrame(data=[], columns=labels, index=None) pass continue # to int converions todo current_id = int(csv[2]) - if table_id == -1: - table_id = current_id + if metadata.table_id == -1: + metadata.table_id = current_id - if table_id != current_id: + if metadata.table_id != current_id: # create new table with previous column headers settings - flux_columns = table.columns - table = FluxTable() - table.columns.extend(flux_columns) - self._insert_table(table, table_index) - table_index = table_index + 1 - table_id = current_id + flux_columns = metadata.table.columns + metadata.table = FluxTable() + metadata.table.columns.extend(flux_columns) + self._insert_table(metadata.table, metadata.table_index) + metadata.table_index = metadata.table_index + 1 + metadata.table_id = current_id - flux_record = self.parse_record(table_index - 1, table, csv) + flux_record = self.parse_record(metadata.table_index - 1, metadata.table, csv) if self._is_profiler_record(flux_record): self._print_profiler_info(flux_record) continue if self._serialization_mode is FluxSerializationMode.tables: - self.tables[table_index - 1].records.append(flux_record) + self.tables[metadata.table_index - 1].records.append(flux_record) if self._serialization_mode is FluxSerializationMode.stream: yield flux_record @@ -186,7 +312,7 @@ def _parse_flux_response(self): # Return latest DataFrame if (self._serialization_mode is FluxSerializationMode.dataFrame) & hasattr(self, '_data_frame'): df = self._prepare_data_frame() - if not self._is_profiler_table(table): + if not self._is_profiler_table(metadata.table): yield df def _prepare_data_frame(self): diff --git a/influxdb_client/client/query_api.py b/influxdb_client/client/query_api.py index 6d9194ef..10f2f0b0 100644 --- a/influxdb_client/client/query_api.py +++ b/influxdb_client/client/query_api.py @@ -4,17 +4,12 @@ Flux is InfluxData’s functional data scripting language designed for querying, analyzing, and acting on data. """ -from datetime import datetime, timedelta -from typing import List, Generator, Any, Union, Iterable, Callable +from typing import List, Generator, Any, Callable -from influxdb_client import Dialect, IntegerLiteral, BooleanLiteral, FloatLiteral, DateTimeLiteral, StringLiteral, \ - VariableAssignment, Identifier, OptionStatement, File, DurationLiteral, Duration, UnaryExpression, Expression, \ - ImportDeclaration, MemberAssignment, MemberExpression, ArrayExpression -from influxdb_client import Query, QueryService +from influxdb_client import Dialect +from influxdb_client import QueryService from influxdb_client.client._base import _BaseQueryApi from influxdb_client.client.flux_table import FluxTable, FluxRecord -from influxdb_client.client.util.date_utils import get_date_helper -from influxdb_client.client.util.helpers import get_org_query_param class QueryOptions(object): @@ -34,20 +29,17 @@ def __init__(self, profilers: List[str] = None, profiler_callback: Callable = No class QueryApi(_BaseQueryApi): """Implementation for '/api/v2/query' endpoint.""" - default_dialect = Dialect(header=True, delimiter=",", comment_prefix="#", - annotations=["datatype", "group", "default"], date_time_format="RFC3339") - def __init__(self, influxdb_client, query_options=QueryOptions()): """ Initialize query client. :param influxdb_client: influxdb client """ - self._influxdb_client = influxdb_client - self._query_options = query_options + super().__init__(influxdb_client=influxdb_client, query_options=query_options) + self._query_api = QueryService(influxdb_client.api_client) - def query_csv(self, query: str, org=None, dialect: Dialect = default_dialect, params: dict = None): + def query_csv(self, query: str, org=None, dialect: Dialect = _BaseQueryApi.default_dialect, params: dict = None): """ Execute the Flux query and return results as a CSV iterator. Each iteration returns a row of the CSV file. @@ -66,7 +58,7 @@ def query_csv(self, query: str, org=None, dialect: Dialect = default_dialect, pa return self._to_csv(response) - def query_raw(self, query: str, org=None, dialect=default_dialect, params: dict = None): + def query_raw(self, query: str, org=None, dialect=_BaseQueryApi.default_dialect, params: dict = None): """ Execute synchronous Flux query and return result as raw unprocessed result as a str. @@ -161,106 +153,6 @@ def query_data_frame_stream(self, query: str, org=None, data_frame_index: List[s response=response, query_options=self._get_query_options()) - def _get_query_options(self): - if self._query_options and self._query_options.profilers: - return self._query_options - elif self._influxdb_client.profilers: - return QueryOptions(profilers=self._influxdb_client.profilers) - - def _create_query(self, query, dialect=default_dialect, params: dict = None): - query_options = self._get_query_options() - profilers = query_options.profilers if query_options is not None else None - q = Query(query=query, dialect=dialect, extern=QueryApi._build_flux_ast(params, profilers)) - - if profilers: - print("\n===============") - print("Profiler: query") - print("===============") - print(query) - - return q - - def _org_param(self, org): - return get_org_query_param(org=org, client=self._influxdb_client) - - @staticmethod - def _params_to_extern_ast(params: dict) -> List['OptionStatement']: - - statements = [] - for key, value in params.items(): - expression = QueryApi._parm_to_extern_ast(value) - if expression is None: - continue - - statements.append(OptionStatement("OptionStatement", - VariableAssignment("VariableAssignment", Identifier("Identifier", key), - expression))) - return statements - - @staticmethod - def _parm_to_extern_ast(value) -> Union[Expression, None]: - if value is None: - return None - if isinstance(value, bool): - return BooleanLiteral("BooleanLiteral", value) - elif isinstance(value, int): - return IntegerLiteral("IntegerLiteral", str(value)) - elif isinstance(value, float): - return FloatLiteral("FloatLiteral", value) - elif isinstance(value, datetime): - value = get_date_helper().to_utc(value) - return DateTimeLiteral("DateTimeLiteral", value.strftime('%Y-%m-%dT%H:%M:%S.%fZ')) - elif isinstance(value, timedelta): - _micro_delta = int(value / timedelta(microseconds=1)) - if _micro_delta < 0: - return UnaryExpression("UnaryExpression", argument=DurationLiteral("DurationLiteral", [ - Duration(magnitude=-_micro_delta, unit="us")]), operator="-") - else: - return DurationLiteral("DurationLiteral", [Duration(magnitude=_micro_delta, unit="us")]) - elif isinstance(value, str): - return StringLiteral("StringLiteral", str(value)) - elif isinstance(value, Iterable): - return ArrayExpression("ArrayExpression", - elements=list(map(lambda it: QueryApi._parm_to_extern_ast(it), value))) - else: - return value - - @staticmethod - def _build_flux_ast(params: dict = None, profilers: List[str] = None): - - imports = [] - body = [] - - if profilers is not None and len(profilers) > 0: - imports.append(ImportDeclaration( - "ImportDeclaration", - path=StringLiteral("StringLiteral", "profiler"))) - - elements = [] - for profiler in profilers: - elements.append(StringLiteral("StringLiteral", value=profiler)) - - member = MemberExpression( - "MemberExpression", - object=Identifier("Identifier", "profiler"), - _property=Identifier("Identifier", "enabledProfilers")) - - prof = OptionStatement( - "OptionStatement", - assignment=MemberAssignment( - "MemberAssignment", - member=member, - init=ArrayExpression( - "ArrayExpression", - elements=elements))) - - body.append(prof) - - if params is not None: - body.extend(QueryApi._params_to_extern_ast(params)) - - return File(package=None, name=None, type=None, imports=imports, body=body) - def __del__(self): """Close QueryAPI.""" pass diff --git a/influxdb_client/client/query_api_async.py b/influxdb_client/client/query_api_async.py index b77dec0c..d031127f 100644 --- a/influxdb_client/client/query_api_async.py +++ b/influxdb_client/client/query_api_async.py @@ -3,9 +3,11 @@ Flux is InfluxData’s functional data scripting language designed for querying, analyzing, and acting on data. """ +from typing import List from influxdb_client import QueryService from influxdb_client.client._base import _BaseQueryApi +from influxdb_client.client.flux_table import FluxTable from influxdb_client.client.query_api import QueryOptions @@ -18,6 +20,27 @@ def __init__(self, influxdb_client, query_options=QueryOptions()): :param influxdb_client: influxdb client """ - self._influxdb_client = influxdb_client + super().__init__(influxdb_client=influxdb_client) + self._query_options = query_options self._query_api = QueryService(influxdb_client.api_client) + + async def query(self, query: str, org=None, params: dict = None) -> List['FluxTable']: + """ + Execute asynchronous Flux query and return result as a List['FluxTable']. + + :param query: the Flux query + :param str, Organization org: specifies the organization for executing the query; + Take the ``ID``, ``Name`` or ``Organization``. + If not specified the default value from ``InfluxDBClient.org`` is used. + :param params: bind parameters + :return: + """ + org = self._org_param(org) + + response = await self._query_api.post_query_async(org=org, + query=self._create_query(query, self.default_dialect, params), + async_req=False, _preload_content=False, + _return_http_data_only=True) + + return await self._to_tables_async(response, query_options=self._get_query_options()) diff --git a/tests/test_InfluxDBClientAsync.py b/tests/test_InfluxDBClientAsync.py index 7d73411f..2e76cc5f 100644 --- a/tests/test_InfluxDBClientAsync.py +++ b/tests/test_InfluxDBClientAsync.py @@ -1,7 +1,10 @@ import asyncio import unittest +from influxdb_client import InfluxDBClient, Point from influxdb_client.client.influxdb_client_async import InfluxDBClientAsync +from influxdb_client.client.write_api import SYNCHRONOUS +from tests.base_test import generate_name def async_test(coro): @@ -11,6 +14,7 @@ def wrapper(*args, **kwargs): return wrapper +# noinspection PyMethodMayBeStatic class InfluxDBClientAsyncTest(unittest.TestCase): @async_test @@ -38,3 +42,29 @@ async def test_version(self): def test_create_query_api(self): query_api = self.client.query_api() self.assertIsNotNone(query_api) + + @async_test + async def test_query_tables(self): + measurement = generate_name("measurement") + self._prepare_data(measurement) + query = f''' + from(bucket:"my-bucket") + |> range(start: -10m) + |> filter(fn: (r) => r["_measurement"] == "{measurement}") + ''' + query_api = self.client.query_api() + tables = await query_api.query(query) + self.assertEqual(2, len(tables)) + self.assertEqual(1, len(tables[0].records)) + self.assertEqual(1, len(tables[1].records)) + + def _prepare_data(self, measurement: str): + with InfluxDBClient(url="http://localhost:8086", token="my-token", org="my-org", debug=True) as client_sync: + write_api = client_sync.write_api(write_options=SYNCHRONOUS) + + """ + Prepare data + """ + _point1 = Point(measurement).tag("location", "Prague").field("temperature", 25.3) + _point2 = Point(measurement).tag("location", "New York").field("temperature", 24.3) + write_api.write(bucket="my-bucket", record=[_point1, _point2]) From b9014ffe1db86da1d64a7571414047ba0817b329 Mon Sep 17 00:00:00 2001 From: Jakub Bednar Date: Mon, 7 Mar 2022 14:37:20 +0100 Subject: [PATCH 13/46] chore: reuse `_parse_flux_response_row` --- examples/asynchronous.py | 7 +- influxdb_client/client/flux_csv_parser.py | 197 ++++++---------------- tests/test_InfluxDBClientAsync.py | 4 + 3 files changed, 64 insertions(+), 144 deletions(-) diff --git a/examples/asynchronous.py b/examples/asynchronous.py index 54fda7d3..eef60397 100644 --- a/examples/asynchronous.py +++ b/examples/asynchronous.py @@ -14,13 +14,14 @@ async def main(): Check the version of the InfluxDB """ version = await client.version() + print(f"\n------- Version -------\n") print(f"InfluxDB: {version}") """ Prepare data """ # tmp solution before implements WriteApiAsync - with InfluxDBClient(url="http://localhost:8086", token="my-token", org="my-org", debug=True) as client_sync: + with InfluxDBClient(url="http://localhost:8086", token="my-token", org="my-org", debug=False) as client_sync: write_api = client_sync.write_api(write_options=SYNCHRONOUS) """ @@ -33,13 +34,13 @@ async def main(): """ Query: using Table structure """ + print(f"\n------- Query -------\n") query_api = client.query_api() tables = await query_api.query('from(bucket:"my-bucket") |> range(start: -10m)') for table in tables: - print(table) for record in table.records: - print(record.values) + print(f'Temperature in {record["location"]} is {record["_value"]}') print() print() diff --git a/influxdb_client/client/flux_csv_parser.py b/influxdb_client/client/flux_csv_parser.py index d0ef9480..7949368f 100644 --- a/influxdb_client/client/flux_csv_parser.py +++ b/influxdb_client/client/flux_csv_parser.py @@ -10,6 +10,8 @@ from influxdb_client.client.flux_table import FluxTable, FluxColumn, FluxRecord from influxdb_client.client.util.date_utils import get_date_helper +_CSV_ENCODING = 'utf-8' + ANNOTATION_DEFAULT = "#default" ANNOTATION_GROUP = "#group" ANNOTATION_DATATYPE = "#datatype" @@ -81,7 +83,7 @@ def __init__(self, response, serialization_mode: FluxSerializationMode, def __enter__(self): """Initialize CSV reader.""" - self._reader = csv_parser.reader(codecs.iterdecode(self._response, 'utf-8')) + self._reader = csv_parser.reader(codecs.iterdecode(self._response, _CSV_ENCODING)) return self def __exit__(self, exc_type, exc_val, exc_tb): @@ -90,14 +92,10 @@ def __exit__(self, exc_type, exc_val, exc_tb): async def __aenter__(self) -> 'FluxCsvParser': """Initialize CSV reader.""" - self._reader = self._stream_reader_to_csv(self._response.content) + self._reader = self._response.content return self - async def _stream_reader_to_csv(self, stream): - async for line in stream: - yield list(csv_parser.reader(line.decode('utf-8').splitlines(), delimiter=','))[0] - async def __aexit__(self, exc_type, exc_val, exc_tb) -> None: """Shutdown the client.""" self.__exit__(exc_type, exc_val, exc_tb) @@ -105,7 +103,8 @@ async def __aexit__(self, exc_type, exc_val, exc_tb) -> None: def generator(self): """Return Python generator.""" with self as parser: - yield from parser._parse_flux_response() + for val in parser._parse_flux_response(): + yield val def generator_async(self): """Return Python async-generator.""" @@ -115,97 +114,8 @@ def _parse_flux_response(self): metadata = _FluxCsvParserMetadata() for csv in self._reader: - # Response has HTTP status ok, but response is error. - if len(csv) < 1: - continue - - if "error" == csv[1] and "reference" == csv[2]: - metadata.parsing_state_error = True - continue - - # Throw InfluxException with error response - if metadata.parsing_state_error: - error = csv[1] - reference_value = csv[2] - raise FluxQueryException(error, reference_value) - - token = csv[0] - # start new table - if (token in ANNOTATIONS and not metadata.start_new_table) or \ - (self._response_metadata_mode is FluxResponseMetadataMode.only_names and not metadata.table): - - # Return already parsed DataFrame - if (self._serialization_mode is FluxSerializationMode.dataFrame) & hasattr(self, '_data_frame'): - df = self._prepare_data_frame() - if not self._is_profiler_table(metadata.table): - yield df - - metadata.start_new_table = True - metadata.table = FluxTable() - self._insert_table(metadata.table, metadata.table_index) - metadata.table_index = metadata.table_index + 1 - metadata.table_id = -1 - elif metadata.table is None: - raise FluxCsvParserException("Unable to parse CSV response. FluxTable definition was not found.") - - # # datatype,string,long,dateTime:RFC3339,dateTime:RFC3339,dateTime:RFC3339,double,string,string,string - if ANNOTATION_DATATYPE == token: - self.add_data_types(metadata.table, csv) - - elif ANNOTATION_GROUP == token: - metadata.groups = csv - - elif ANNOTATION_DEFAULT == token: - self.add_default_empty_values(metadata.table, csv) - - else: - # parse column names - if metadata.start_new_table: - # Invocable scripts doesn't supports dialect => all columns are string - if not metadata.table.columns and \ - self._response_metadata_mode is FluxResponseMetadataMode.only_names: - self.add_data_types(metadata.table, list(map(lambda column: 'string', csv))) - metadata.groups = list(map(lambda column: 'false', csv)) - self.add_groups(metadata.table, metadata.groups) - self.add_column_names_and_tags(metadata.table, csv) - metadata.start_new_table = False - # Create DataFrame with default values - if self._serialization_mode is FluxSerializationMode.dataFrame: - from ..extras import pd - labels = list(map(lambda it: it.label, metadata.table.columns)) - self._data_frame = pd.DataFrame(data=[], columns=labels, index=None) - pass - continue - - # to int converions todo - current_id = int(csv[2]) - if metadata.table_id == -1: - metadata.table_id = current_id - - if metadata.table_id != current_id: - # create new table with previous column headers settings - flux_columns = metadata.table.columns - metadata.table = FluxTable() - metadata.table.columns.extend(flux_columns) - self._insert_table(metadata.table, metadata.table_index) - metadata.table_index = metadata.table_index + 1 - metadata.table_id = current_id - - flux_record = self.parse_record(metadata.table_index - 1, metadata.table, csv) - - if self._is_profiler_record(flux_record): - self._print_profiler_info(flux_record) - continue - - if self._serialization_mode is FluxSerializationMode.tables: - self.tables[metadata.table_index - 1].records.append(flux_record) - - if self._serialization_mode is FluxSerializationMode.stream: - yield flux_record - - if self._serialization_mode is FluxSerializationMode.dataFrame: - self._data_frame_values.append(flux_record.values) - pass + for val in self._parse_flux_response_row(metadata, csv): + yield val # Return latest DataFrame if (self._serialization_mode is FluxSerializationMode.dataFrame) & hasattr(self, '_data_frame'): @@ -216,15 +126,27 @@ def _parse_flux_response(self): async def _parse_flux_response_async(self): metadata = _FluxCsvParserMetadata() - async for csv in self._reader: + async for line in self._reader: + csv = list(csv_parser.reader([line.decode(_CSV_ENCODING)])) + if len(csv) >= 1: + for val in self._parse_flux_response_row(metadata, csv[0]): + yield val + + # Return latest DataFrame + if (self._serialization_mode is FluxSerializationMode.dataFrame) & hasattr(self, '_data_frame'): + df = self._prepare_data_frame() + if not self._is_profiler_table(metadata.table): + yield df + + def _parse_flux_response_row(self, metadata, csv): + if len(csv) < 1: # Response has HTTP status ok, but response is error. - if len(csv) < 1: - continue + pass - if "error" == csv[1] and "reference" == csv[2]: - metadata.parsing_state_error = True - continue + elif "error" == csv[1] and "reference" == csv[2]: + metadata.parsing_state_error = True + else: # Throw InfluxException with error response if metadata.parsing_state_error: error = csv[1] @@ -277,43 +199,36 @@ async def _parse_flux_response_async(self): labels = list(map(lambda it: it.label, metadata.table.columns)) self._data_frame = pd.DataFrame(data=[], columns=labels, index=None) pass - continue - - # to int converions todo - current_id = int(csv[2]) - if metadata.table_id == -1: - metadata.table_id = current_id - - if metadata.table_id != current_id: - # create new table with previous column headers settings - flux_columns = metadata.table.columns - metadata.table = FluxTable() - metadata.table.columns.extend(flux_columns) - self._insert_table(metadata.table, metadata.table_index) - metadata.table_index = metadata.table_index + 1 - metadata.table_id = current_id - - flux_record = self.parse_record(metadata.table_index - 1, metadata.table, csv) - - if self._is_profiler_record(flux_record): - self._print_profiler_info(flux_record) - continue - - if self._serialization_mode is FluxSerializationMode.tables: - self.tables[metadata.table_index - 1].records.append(flux_record) - - if self._serialization_mode is FluxSerializationMode.stream: - yield flux_record - - if self._serialization_mode is FluxSerializationMode.dataFrame: - self._data_frame_values.append(flux_record.values) - pass - - # Return latest DataFrame - if (self._serialization_mode is FluxSerializationMode.dataFrame) & hasattr(self, '_data_frame'): - df = self._prepare_data_frame() - if not self._is_profiler_table(metadata.table): - yield df + else: + + # to int converions todo + current_id = int(csv[2]) + if metadata.table_id == -1: + metadata.table_id = current_id + + if metadata.table_id != current_id: + # create new table with previous column headers settings + flux_columns = metadata.table.columns + metadata.table = FluxTable() + metadata.table.columns.extend(flux_columns) + self._insert_table(metadata.table, metadata.table_index) + metadata.table_index = metadata.table_index + 1 + metadata.table_id = current_id + + flux_record = self.parse_record(metadata.table_index - 1, metadata.table, csv) + + if self._is_profiler_record(flux_record): + self._print_profiler_info(flux_record) + else: + if self._serialization_mode is FluxSerializationMode.tables: + self.tables[metadata.table_index - 1].records.append(flux_record) + + if self._serialization_mode is FluxSerializationMode.stream: + yield flux_record + + if self._serialization_mode is FluxSerializationMode.dataFrame: + self._data_frame_values.append(flux_record.values) + pass def _prepare_data_frame(self): from ..extras import pd diff --git a/tests/test_InfluxDBClientAsync.py b/tests/test_InfluxDBClientAsync.py index 2e76cc5f..3fab977b 100644 --- a/tests/test_InfluxDBClientAsync.py +++ b/tests/test_InfluxDBClientAsync.py @@ -56,7 +56,11 @@ async def test_query_tables(self): tables = await query_api.query(query) self.assertEqual(2, len(tables)) self.assertEqual(1, len(tables[0].records)) + self.assertEqual("New York", tables[0].records[0]['location']) + self.assertEqual(24.3, tables[0].records[0]['_value']) self.assertEqual(1, len(tables[1].records)) + self.assertEqual("Prague", tables[1].records[0]['location']) + self.assertEqual(25.3, tables[1].records[0]['_value']) def _prepare_data(self, measurement: str): with InfluxDBClient(url="http://localhost:8086", token="my-token", org="my-org", debug=True) as client_sync: From a02f1787ad9728e5af19a51d8b2595b732dfd9a1 Mon Sep 17 00:00:00 2001 From: Jakub Bednar Date: Mon, 7 Mar 2022 15:07:30 +0100 Subject: [PATCH 14/46] feat: add async query into raw output --- examples/asynchronous.py | 12 ++++++++---- influxdb_client/client/_base.py | 5 +++-- influxdb_client/client/flux_csv_parser.py | 6 +++--- influxdb_client/client/query_api_async.py | 21 ++++++++++++++++++++- tests/test_InfluxDBClientAsync.py | 18 ++++++++++++++++++ 5 files changed, 52 insertions(+), 10 deletions(-) diff --git a/examples/asynchronous.py b/examples/asynchronous.py index eef60397..68504c8f 100644 --- a/examples/asynchronous.py +++ b/examples/asynchronous.py @@ -34,7 +34,7 @@ async def main(): """ Query: using Table structure """ - print(f"\n------- Query -------\n") + print(f"\n------- Query: using Table structure -------\n") query_api = client.query_api() tables = await query_api.query('from(bucket:"my-bucket") |> range(start: -10m)') @@ -42,9 +42,13 @@ async def main(): for record in table.records: print(f'Temperature in {record["location"]} is {record["_value"]}') - print() - print() - + """ + Query: using raw str output + """ + print(f"\n------- Query: using raw str output -------\n") + query_api = client.query_api() + raw = await query_api.query_raw('from(bucket:"my-bucket") |> range(start: -10m)') + print(raw) if __name__ == "__main__": asyncio.run(main()) diff --git a/influxdb_client/client/_base.py b/influxdb_client/client/_base.py index 64331a1a..bf8217d0 100644 --- a/influxdb_client/client/_base.py +++ b/influxdb_client/client/_base.py @@ -12,7 +12,8 @@ from influxdb_client import Configuration, Dialect, Query, OptionStatement, VariableAssignment, Identifier, \ Expression, BooleanLiteral, IntegerLiteral, FloatLiteral, DateTimeLiteral, UnaryExpression, DurationLiteral, \ Duration, StringLiteral, ArrayExpression, ImportDeclaration, MemberExpression, MemberAssignment, File -from influxdb_client.client.flux_csv_parser import FluxResponseMetadataMode, FluxCsvParser, FluxSerializationMode +from influxdb_client.client.flux_csv_parser import FluxResponseMetadataMode, FluxCsvParser, FluxSerializationMode, \ + CSV_ENCODING from influxdb_client.client.flux_table import FluxTable, FluxRecord from influxdb_client.client.util.date_utils import get_date_helper from influxdb_client.client.util.helpers import get_org_query_param @@ -104,7 +105,7 @@ def to_tables_parser(self, response, query_options, response_metadata_mode): def _to_csv(self, response: HTTPResponse) -> Iterator[List[str]]: """Parse HTTP response to CSV.""" - return csv.reader(codecs.iterdecode(response, 'utf-8')) + return csv.reader(codecs.iterdecode(response, CSV_ENCODING)) def _to_flux_record_stream(self, response, query_options=None, response_metadata_mode: FluxResponseMetadataMode = FluxResponseMetadataMode.full) -> \ diff --git a/influxdb_client/client/flux_csv_parser.py b/influxdb_client/client/flux_csv_parser.py index 7949368f..6d38a2d3 100644 --- a/influxdb_client/client/flux_csv_parser.py +++ b/influxdb_client/client/flux_csv_parser.py @@ -10,7 +10,7 @@ from influxdb_client.client.flux_table import FluxTable, FluxColumn, FluxRecord from influxdb_client.client.util.date_utils import get_date_helper -_CSV_ENCODING = 'utf-8' +CSV_ENCODING = 'utf-8' ANNOTATION_DEFAULT = "#default" ANNOTATION_GROUP = "#group" @@ -83,7 +83,7 @@ def __init__(self, response, serialization_mode: FluxSerializationMode, def __enter__(self): """Initialize CSV reader.""" - self._reader = csv_parser.reader(codecs.iterdecode(self._response, _CSV_ENCODING)) + self._reader = csv_parser.reader(codecs.iterdecode(self._response, CSV_ENCODING)) return self def __exit__(self, exc_type, exc_val, exc_tb): @@ -127,7 +127,7 @@ async def _parse_flux_response_async(self): metadata = _FluxCsvParserMetadata() async for line in self._reader: - csv = list(csv_parser.reader([line.decode(_CSV_ENCODING)])) + csv = list(csv_parser.reader([line.decode(CSV_ENCODING)])) if len(csv) >= 1: for val in self._parse_flux_response_row(metadata, csv[0]): yield val diff --git a/influxdb_client/client/query_api_async.py b/influxdb_client/client/query_api_async.py index d031127f..7bd1e4cb 100644 --- a/influxdb_client/client/query_api_async.py +++ b/influxdb_client/client/query_api_async.py @@ -6,7 +6,7 @@ from typing import List from influxdb_client import QueryService -from influxdb_client.client._base import _BaseQueryApi +from influxdb_client.client._base import _BaseQueryApi, CSV_ENCODING from influxdb_client.client.flux_table import FluxTable from influxdb_client.client.query_api import QueryOptions @@ -44,3 +44,22 @@ async def query(self, query: str, org=None, params: dict = None) -> List['FluxTa _return_http_data_only=True) return await self._to_tables_async(response, query_options=self._get_query_options()) + + async def query_raw(self, query: str, org=None, dialect=_BaseQueryApi.default_dialect, params: dict = None): + """ + Execute asynchronous Flux query and return result as raw unprocessed result as a str. + + :param query: a Flux query + :param str, Organization org: specifies the organization for executing the query; + Take the ``ID``, ``Name`` or ``Organization``. + If not specified the default value from ``InfluxDBClient.org`` is used. + :param dialect: csv dialect format + :param params: bind parameters + :return: str + """ + org = self._org_param(org) + result = await self._query_api.post_query_async(org=org, query=self._create_query(query, dialect, params), + async_req=False, _preload_content=False, + _return_http_data_only=True) + raw_bytes = await result.read() + return raw_bytes.decode(CSV_ENCODING) diff --git a/tests/test_InfluxDBClientAsync.py b/tests/test_InfluxDBClientAsync.py index 3fab977b..9750e5c9 100644 --- a/tests/test_InfluxDBClientAsync.py +++ b/tests/test_InfluxDBClientAsync.py @@ -53,6 +53,7 @@ async def test_query_tables(self): |> filter(fn: (r) => r["_measurement"] == "{measurement}") ''' query_api = self.client.query_api() + tables = await query_api.query(query) self.assertEqual(2, len(tables)) self.assertEqual(1, len(tables[0].records)) @@ -62,6 +63,23 @@ async def test_query_tables(self): self.assertEqual("Prague", tables[1].records[0]['location']) self.assertEqual(25.3, tables[1].records[0]['_value']) + @async_test + async def test_query_raw(self): + measurement = generate_name("measurement") + self._prepare_data(measurement) + query = f''' + from(bucket:"my-bucket") + |> range(start: -10m) + |> filter(fn: (r) => r["_measurement"] == "{measurement}") + |> drop(columns: ["_start", "_stop", "_time", "_measurement"]) + ''' + query_api = self.client.query_api() + + raw = await query_api.query_raw(query) + self.assertEqual(7, len(raw.splitlines())) + self.assertEqual(',,0,24.3,temperature,New York', raw.splitlines()[4]) + self.assertEqual(',,1,25.3,temperature,Prague', raw.splitlines()[5]) + def _prepare_data(self, measurement: str): with InfluxDBClient(url="http://localhost:8086", token="my-token", org="my-org", debug=True) as client_sync: write_api = client_sync.write_api(write_options=SYNCHRONOUS) From 0b091a16b7594a55ea1f0a9b4c4d63fb184e3340 Mon Sep 17 00:00:00 2001 From: Jakub Bednar Date: Mon, 7 Mar 2022 15:10:41 +0100 Subject: [PATCH 15/46] feat: add async query into raw output --- examples/asynchronous.py | 12 ++++++++---- influxdb_client/client/_base.py | 4 ++-- influxdb_client/client/flux_csv_parser.py | 6 +++--- influxdb_client/client/query_api_async.py | 4 ++-- 4 files changed, 15 insertions(+), 11 deletions(-) diff --git a/examples/asynchronous.py b/examples/asynchronous.py index 68504c8f..c7be010d 100644 --- a/examples/asynchronous.py +++ b/examples/asynchronous.py @@ -27,8 +27,8 @@ async def main(): """ Prepare data """ - _point1 = Point("my_measurement").tag("location", "Prague").field("temperature", 25.3) - _point2 = Point("my_measurement").tag("location", "New York").field("temperature", 24.3) + _point1 = Point("async_m").tag("location", "Prague").field("temperature", 25.3) + _point2 = Point("async_m").tag("location", "New York").field("temperature", 24.3) write_api.write(bucket="my-bucket", record=[_point1, _point2]) """ @@ -36,7 +36,9 @@ async def main(): """ print(f"\n------- Query: using Table structure -------\n") query_api = client.query_api() - tables = await query_api.query('from(bucket:"my-bucket") |> range(start: -10m)') + tables = await query_api.query('from(bucket:"my-bucket") ' + '|> range(start: -10m) ' + '|> filter(fn: (r) => r["_measurement"] == "async_m")') for table in tables: for record in table.records: @@ -47,7 +49,9 @@ async def main(): """ print(f"\n------- Query: using raw str output -------\n") query_api = client.query_api() - raw = await query_api.query_raw('from(bucket:"my-bucket") |> range(start: -10m)') + raw = await query_api.query_raw('from(bucket:"my-bucket") ' + '|> range(start: -10m) ' + '|> filter(fn: (r) => r["_measurement"] == "async_m")') print(raw) if __name__ == "__main__": diff --git a/influxdb_client/client/_base.py b/influxdb_client/client/_base.py index bf8217d0..2dd8a435 100644 --- a/influxdb_client/client/_base.py +++ b/influxdb_client/client/_base.py @@ -13,7 +13,7 @@ Expression, BooleanLiteral, IntegerLiteral, FloatLiteral, DateTimeLiteral, UnaryExpression, DurationLiteral, \ Duration, StringLiteral, ArrayExpression, ImportDeclaration, MemberExpression, MemberAssignment, File from influxdb_client.client.flux_csv_parser import FluxResponseMetadataMode, FluxCsvParser, FluxSerializationMode, \ - CSV_ENCODING + _CSV_ENCODING from influxdb_client.client.flux_table import FluxTable, FluxRecord from influxdb_client.client.util.date_utils import get_date_helper from influxdb_client.client.util.helpers import get_org_query_param @@ -105,7 +105,7 @@ def to_tables_parser(self, response, query_options, response_metadata_mode): def _to_csv(self, response: HTTPResponse) -> Iterator[List[str]]: """Parse HTTP response to CSV.""" - return csv.reader(codecs.iterdecode(response, CSV_ENCODING)) + return csv.reader(codecs.iterdecode(response, _CSV_ENCODING)) def _to_flux_record_stream(self, response, query_options=None, response_metadata_mode: FluxResponseMetadataMode = FluxResponseMetadataMode.full) -> \ diff --git a/influxdb_client/client/flux_csv_parser.py b/influxdb_client/client/flux_csv_parser.py index 6d38a2d3..7949368f 100644 --- a/influxdb_client/client/flux_csv_parser.py +++ b/influxdb_client/client/flux_csv_parser.py @@ -10,7 +10,7 @@ from influxdb_client.client.flux_table import FluxTable, FluxColumn, FluxRecord from influxdb_client.client.util.date_utils import get_date_helper -CSV_ENCODING = 'utf-8' +_CSV_ENCODING = 'utf-8' ANNOTATION_DEFAULT = "#default" ANNOTATION_GROUP = "#group" @@ -83,7 +83,7 @@ def __init__(self, response, serialization_mode: FluxSerializationMode, def __enter__(self): """Initialize CSV reader.""" - self._reader = csv_parser.reader(codecs.iterdecode(self._response, CSV_ENCODING)) + self._reader = csv_parser.reader(codecs.iterdecode(self._response, _CSV_ENCODING)) return self def __exit__(self, exc_type, exc_val, exc_tb): @@ -127,7 +127,7 @@ async def _parse_flux_response_async(self): metadata = _FluxCsvParserMetadata() async for line in self._reader: - csv = list(csv_parser.reader([line.decode(CSV_ENCODING)])) + csv = list(csv_parser.reader([line.decode(_CSV_ENCODING)])) if len(csv) >= 1: for val in self._parse_flux_response_row(metadata, csv[0]): yield val diff --git a/influxdb_client/client/query_api_async.py b/influxdb_client/client/query_api_async.py index 7bd1e4cb..81bc30b6 100644 --- a/influxdb_client/client/query_api_async.py +++ b/influxdb_client/client/query_api_async.py @@ -6,7 +6,7 @@ from typing import List from influxdb_client import QueryService -from influxdb_client.client._base import _BaseQueryApi, CSV_ENCODING +from influxdb_client.client._base import _BaseQueryApi, _CSV_ENCODING from influxdb_client.client.flux_table import FluxTable from influxdb_client.client.query_api import QueryOptions @@ -62,4 +62,4 @@ async def query_raw(self, query: str, org=None, dialect=_BaseQueryApi.default_di async_req=False, _preload_content=False, _return_http_data_only=True) raw_bytes = await result.read() - return raw_bytes.decode(CSV_ENCODING) + return raw_bytes.decode(_CSV_ENCODING) From 1fed67c11e0399ff987da9b06fee808e84f366c9 Mon Sep 17 00:00:00 2001 From: Jakub Bednar Date: Mon, 7 Mar 2022 21:23:56 +0100 Subject: [PATCH 16/46] feat: add async query into FluxRecord stream --- examples/asynchronous.py | 11 ++++++ influxdb_client/client/_base.py | 42 ++++++++++++++++------- influxdb_client/client/flux_csv_parser.py | 30 +++++++++------- influxdb_client/client/query_api.py | 2 +- influxdb_client/client/query_api_async.py | 26 ++++++++++++-- tests/test_InfluxDBClientAsync.py | 23 ++++++++++++- 6 files changed, 105 insertions(+), 29 deletions(-) diff --git a/examples/asynchronous.py b/examples/asynchronous.py index c7be010d..7c76ca4a 100644 --- a/examples/asynchronous.py +++ b/examples/asynchronous.py @@ -44,6 +44,17 @@ async def main(): for record in table.records: print(f'Temperature in {record["location"]} is {record["_value"]}') + """ + Query: using stream FluxRecords + """ + print(f"\n------- Query: using stream FluxRecords -------\n") + query_api = client.query_api() + records = await query_api.query_stream('from(bucket:"my-bucket") ' + '|> range(start: -10m) ' + '|> filter(fn: (r) => r["_measurement"] == "async_m")') + async for record in records: + print(record) + """ Query: using raw str output """ diff --git a/influxdb_client/client/_base.py b/influxdb_client/client/_base.py index 2dd8a435..bd708e24 100644 --- a/influxdb_client/client/_base.py +++ b/influxdb_client/client/_base.py @@ -5,7 +5,7 @@ import codecs import csv from datetime import datetime, timedelta -from typing import Iterator, List, Generator, Any, Union, Iterable +from typing import Iterator, List, Generator, Any, Union, Iterable, AsyncGenerator from urllib3 import HTTPResponse @@ -81,9 +81,9 @@ def _to_tables(self, response, query_options=None, response_metadata_mode: """ Parse HTTP response to FluxTables. - :param response: HTTP response from a HTTP client. Expected type: `urllib3.response.HTTPResponse`. + :param response: HTTP response from an HTTP client. Expected type: `urllib3.response.HTTPResponse`. """ - _parser = self.to_tables_parser(response, query_options, response_metadata_mode) + _parser = self._to_tables_parser(response, query_options, response_metadata_mode) list(_parser.generator()) return _parser.table_list() @@ -92,17 +92,13 @@ async def _to_tables_async(self, response, query_options=None, response_metadata """ Parse HTTP response to FluxTables. - :param response: HTTP response from a HTTP client. Expected type: `aiohttp.client_reqrep.ClientResponse`. + :param response: HTTP response from an HTTP client. Expected type: `aiohttp.client_reqrep.ClientResponse`. """ - async with self.to_tables_parser(response, query_options, response_metadata_mode) as parser: + async with self._to_tables_parser(response, query_options, response_metadata_mode) as parser: async for _ in parser.generator_async(): pass return parser.table_list() - def to_tables_parser(self, response, query_options, response_metadata_mode): - return FluxCsvParser(response=response, serialization_mode=FluxSerializationMode.tables, - query_options=query_options, response_metadata_mode=response_metadata_mode) - def _to_csv(self, response: HTTPResponse) -> Iterator[List[str]]: """Parse HTTP response to CSV.""" return csv.reader(codecs.iterdecode(response, _CSV_ENCODING)) @@ -110,11 +106,25 @@ def _to_csv(self, response: HTTPResponse) -> Iterator[List[str]]: def _to_flux_record_stream(self, response, query_options=None, response_metadata_mode: FluxResponseMetadataMode = FluxResponseMetadataMode.full) -> \ Generator[FluxRecord, Any, None]: - """Parse HTTP response to FluxRecord stream.""" - _parser = FluxCsvParser(response=response, serialization_mode=FluxSerializationMode.stream, - query_options=query_options, response_metadata_mode=response_metadata_mode) + """ + Parse HTTP response to FluxRecord stream. + + :param response: HTTP response from an HTTP client. Expected type: `urllib3.response.HTTPResponse`. + """ + _parser = self._to_flux_record_stream_parser(query_options, response, response_metadata_mode) return _parser.generator() + async def _to_flux_record_stream_async(self, response, query_options=None, response_metadata_mode: + FluxResponseMetadataMode = FluxResponseMetadataMode.full) -> \ + AsyncGenerator['FluxRecord', None]: + """ + Parse HTTP response to FluxRecord stream. + + :param response: HTTP response from an HTTP client. Expected type: `aiohttp.client_reqrep.ClientResponse`. + """ + _parser = self._to_flux_record_stream_parser(query_options, response, response_metadata_mode) + return (await _parser.__aenter__()).generator_async() + def _to_data_frame_stream(self, data_frame_index, response, query_options=None, response_metadata_mode: FluxResponseMetadataMode = FluxResponseMetadataMode.full): """Parse HTTP response to DataFrame stream.""" @@ -123,6 +133,14 @@ def _to_data_frame_stream(self, data_frame_index, response, query_options=None, response_metadata_mode=response_metadata_mode) return _parser.generator() + def _to_tables_parser(self, response, query_options, response_metadata_mode): + return FluxCsvParser(response=response, serialization_mode=FluxSerializationMode.tables, + query_options=query_options, response_metadata_mode=response_metadata_mode) + + def _to_flux_record_stream_parser(self, query_options, response, response_metadata_mode): + return FluxCsvParser(response=response, serialization_mode=FluxSerializationMode.stream, + query_options=query_options, response_metadata_mode=response_metadata_mode) + def _to_data_frames(self, _generator): """Parse stream of DataFrames into expected type.""" from ..extras import pd diff --git a/influxdb_client/client/flux_csv_parser.py b/influxdb_client/client/flux_csv_parser.py index 7949368f..c5d03d19 100644 --- a/influxdb_client/client/flux_csv_parser.py +++ b/influxdb_client/client/flux_csv_parser.py @@ -81,6 +81,9 @@ def __init__(self, response, serialization_mode: FluxSerializationMode, self._profiler_callback = query_options.profiler_callback if query_options is not None else None self._async_mode = True if 'ClientResponse' in type(response).__name__ else False + def _close(self): + self._response.close() + def __enter__(self): """Initialize CSV reader.""" self._reader = csv_parser.reader(codecs.iterdecode(self._response, _CSV_ENCODING)) @@ -88,7 +91,7 @@ def __enter__(self): def __exit__(self, exc_type, exc_val, exc_tb): """Close HTTP response.""" - self._response.close() + self._close() async def __aenter__(self) -> 'FluxCsvParser': """Initialize CSV reader.""" @@ -126,17 +129,20 @@ def _parse_flux_response(self): async def _parse_flux_response_async(self): metadata = _FluxCsvParserMetadata() - async for line in self._reader: - csv = list(csv_parser.reader([line.decode(_CSV_ENCODING)])) - if len(csv) >= 1: - for val in self._parse_flux_response_row(metadata, csv[0]): - yield val - - # Return latest DataFrame - if (self._serialization_mode is FluxSerializationMode.dataFrame) & hasattr(self, '_data_frame'): - df = self._prepare_data_frame() - if not self._is_profiler_table(metadata.table): - yield df + try: + async for line in self._reader: + csv = list(csv_parser.reader([line.decode(_CSV_ENCODING)])) + if len(csv) >= 1: + for val in self._parse_flux_response_row(metadata, csv[0]): + yield val + + # Return latest DataFrame + if (self._serialization_mode is FluxSerializationMode.dataFrame) & hasattr(self, '_data_frame'): + df = self._prepare_data_frame() + if not self._is_profiler_table(metadata.table): + yield df + finally: + self._close() def _parse_flux_response_row(self, metadata, csv): if len(csv) < 1: diff --git a/influxdb_client/client/query_api.py b/influxdb_client/client/query_api.py index 10f2f0b0..6783524d 100644 --- a/influxdb_client/client/query_api.py +++ b/influxdb_client/client/query_api.py @@ -103,7 +103,7 @@ def query_stream(self, query: str, org=None, params: dict = None) -> Generator[' Take the ``ID``, ``Name`` or ``Organization``. If not specified the default value from ``InfluxDBClient.org`` is used. :param params: bind parameters - :return: + :return: Generator['FluxRecord'] """ org = self._org_param(org) diff --git a/influxdb_client/client/query_api_async.py b/influxdb_client/client/query_api_async.py index 81bc30b6..5feb23de 100644 --- a/influxdb_client/client/query_api_async.py +++ b/influxdb_client/client/query_api_async.py @@ -3,11 +3,11 @@ Flux is InfluxData’s functional data scripting language designed for querying, analyzing, and acting on data. """ -from typing import List +from typing import List, AsyncGenerator from influxdb_client import QueryService from influxdb_client.client._base import _BaseQueryApi, _CSV_ENCODING -from influxdb_client.client.flux_table import FluxTable +from influxdb_client.client.flux_table import FluxTable, FluxRecord from influxdb_client.client.query_api import QueryOptions @@ -34,7 +34,7 @@ async def query(self, query: str, org=None, params: dict = None) -> List['FluxTa Take the ``ID``, ``Name`` or ``Organization``. If not specified the default value from ``InfluxDBClient.org`` is used. :param params: bind parameters - :return: + :return: List of FluxTable. """ org = self._org_param(org) @@ -45,6 +45,26 @@ async def query(self, query: str, org=None, params: dict = None) -> List['FluxTa return await self._to_tables_async(response, query_options=self._get_query_options()) + async def query_stream(self, query: str, org=None, params: dict = None) -> AsyncGenerator['FluxRecord', None]: + """ + Execute asynchronous Flux query and return stream of FluxRecord as a Generator['FluxRecord']. + + :param query: the Flux query + :param str, Organization org: specifies the organization for executing the query; + Take the ``ID``, ``Name`` or ``Organization``. + If not specified the default value from ``InfluxDBClient.org`` is used. + :param params: bind parameters + :return: AsyncGenerator['FluxRecord'] + """ + org = self._org_param(org) + + response = await self._query_api.post_query_async(org=org, + query=self._create_query(query, self.default_dialect, params), + async_req=False, _preload_content=False, + _return_http_data_only=True) + + return await self._to_flux_record_stream_async(response, query_options=self._get_query_options()) + async def query_raw(self, query: str, org=None, dialect=_BaseQueryApi.default_dialect, params: dict = None): """ Execute asynchronous Flux query and return result as raw unprocessed result as a str. diff --git a/tests/test_InfluxDBClientAsync.py b/tests/test_InfluxDBClientAsync.py index 9750e5c9..4e4a91e0 100644 --- a/tests/test_InfluxDBClientAsync.py +++ b/tests/test_InfluxDBClientAsync.py @@ -80,8 +80,29 @@ async def test_query_raw(self): self.assertEqual(',,0,24.3,temperature,New York', raw.splitlines()[4]) self.assertEqual(',,1,25.3,temperature,Prague', raw.splitlines()[5]) + @async_test + async def test_query_stream_records(self): + measurement = generate_name("measurement") + self._prepare_data(measurement) + query = f''' + from(bucket:"my-bucket") + |> range(start: -10m) + |> filter(fn: (r) => r["_measurement"] == "{measurement}") + ''' + query_api = self.client.query_api() + + records = [] + async for record in await query_api.query_stream(query): + records.append(record) + + self.assertEqual(2, len(records)) + self.assertEqual("New York", records[0]['location']) + self.assertEqual(24.3, records[0]['_value']) + self.assertEqual("Prague", records[1]['location']) + self.assertEqual(25.3, records[1]['_value']) + def _prepare_data(self, measurement: str): - with InfluxDBClient(url="http://localhost:8086", token="my-token", org="my-org", debug=True) as client_sync: + with InfluxDBClient(url="http://localhost:8086", token="my-token", org="my-org") as client_sync: write_api = client_sync.write_api(write_options=SYNCHRONOUS) """ From 2fe01da23802875589b123c4425e1a9fa39aadd8 Mon Sep 17 00:00:00 2001 From: Jakub Bednar Date: Tue, 8 Mar 2022 07:43:08 +0100 Subject: [PATCH 17/46] docs: add Async API Reference --- docs/api.rst | 11 ++++++----- docs/api_async.rst | 15 +++++++++++++++ docs/index.rst | 1 + 3 files changed, 22 insertions(+), 5 deletions(-) create mode 100644 docs/api_async.rst diff --git a/docs/api.rst b/docs/api.rst index 3a1731b0..02c100f1 100644 --- a/docs/api.rst +++ b/docs/api.rst @@ -14,6 +14,12 @@ QueryApi .. autoclass:: influxdb_client.QueryApi :members: +.. autoclass:: influxdb_client.client.flux_table.FluxTable + :members: + +.. autoclass:: influxdb_client.client.flux_table.FluxRecord + :members: + WriteApi """""""" .. autoclass:: influxdb_client.WriteApi @@ -81,11 +87,6 @@ DeleteApi .. autoclass:: influxdb_client.domain.DeletePredicateRequest :members: -InfluxDBClientAsync -""""""""""""""""""" -.. autoclass:: influxdb_client.client.influxdb_client_async.InfluxDBClientAsync - :members: - Helpers """"""" .. autoclass:: influxdb_client.client.util.date_utils.DateHelper diff --git a/docs/api_async.rst b/docs/api_async.rst new file mode 100644 index 00000000..a5b5a13a --- /dev/null +++ b/docs/api_async.rst @@ -0,0 +1,15 @@ +Async API Reference +=================== + +.. contents:: + :local: + +InfluxDBClientAsync +""""""""""""""""""" +.. autoclass:: influxdb_client.client.influxdb_client_async.InfluxDBClientAsync + :members: + +QueryApiAsync +""""""""""""" +.. autoclass:: influxdb_client.client.query_api_async.QueryApiAsync + :members: diff --git a/docs/index.rst b/docs/index.rst index b7504766..ac6751b7 100644 --- a/docs/index.rst +++ b/docs/index.rst @@ -8,6 +8,7 @@ InfluxDB 2.0 python client usage api + api_async migration .. include:: ../README.rst From 2b44aa6539429e6aa1bfc8dbcedac2abaf0ab115 Mon Sep 17 00:00:00 2001 From: Jakub Bednar Date: Tue, 8 Mar 2022 09:13:51 +0100 Subject: [PATCH 18/46] feat: add async query into Pandas Dataframe --- examples/asynchronous.py | 12 ++++++ influxdb_client/client/_base.py | 31 +++++++++++--- influxdb_client/client/query_api.py | 2 +- influxdb_client/client/query_api_async.py | 52 ++++++++++++++++++++++- tests/test_InfluxDBClientAsync.py | 24 +++++++++++ 5 files changed, 114 insertions(+), 7 deletions(-) diff --git a/examples/asynchronous.py b/examples/asynchronous.py index 7c76ca4a..23601d77 100644 --- a/examples/asynchronous.py +++ b/examples/asynchronous.py @@ -55,6 +55,17 @@ async def main(): async for record in records: print(record) + """ + Query: using Pandas DataFrame + """ + print(f"\n------- Query: using Pandas DataFrame -------\n") + query_api = client.query_api() + dataframe = await query_api.query_data_frame('from(bucket:"my-bucket") ' + '|> range(start: -10m) ' + '|> filter(fn: (r) => r["_measurement"] == "async_m")' + ' |> group()') + print(dataframe) + """ Query: using raw str output """ @@ -65,5 +76,6 @@ async def main(): '|> filter(fn: (r) => r["_measurement"] == "async_m")') print(raw) + if __name__ == "__main__": asyncio.run(main()) diff --git a/influxdb_client/client/_base.py b/influxdb_client/client/_base.py index bd708e24..783fc1c8 100644 --- a/influxdb_client/client/_base.py +++ b/influxdb_client/client/_base.py @@ -127,12 +127,24 @@ async def _to_flux_record_stream_async(self, response, query_options=None, respo def _to_data_frame_stream(self, data_frame_index, response, query_options=None, response_metadata_mode: FluxResponseMetadataMode = FluxResponseMetadataMode.full): - """Parse HTTP response to DataFrame stream.""" - _parser = FluxCsvParser(response=response, serialization_mode=FluxSerializationMode.dataFrame, - data_frame_index=data_frame_index, query_options=query_options, - response_metadata_mode=response_metadata_mode) + """ + Parse HTTP response to DataFrame stream. + + :param response: HTTP response from an HTTP client. Expected type: `urllib3.response.HTTPResponse`. + """ + _parser = self._to_data_frame_stream_parser(data_frame_index, query_options, response, response_metadata_mode) return _parser.generator() + async def _to_data_frame_stream_async(self, data_frame_index, response, query_options=None, response_metadata_mode: + FluxResponseMetadataMode = FluxResponseMetadataMode.full): + """ + Parse HTTP response to DataFrame stream. + + :param response: HTTP response from an HTTP client. Expected type: `aiohttp.client_reqrep.ClientResponse`. + """ + _parser = self._to_data_frame_stream_parser(data_frame_index, query_options, response, response_metadata_mode) + return (await _parser.__aenter__()).generator_async() + def _to_tables_parser(self, response, query_options, response_metadata_mode): return FluxCsvParser(response=response, serialization_mode=FluxSerializationMode.tables, query_options=query_options, response_metadata_mode=response_metadata_mode) @@ -141,10 +153,19 @@ def _to_flux_record_stream_parser(self, query_options, response, response_metada return FluxCsvParser(response=response, serialization_mode=FluxSerializationMode.stream, query_options=query_options, response_metadata_mode=response_metadata_mode) + def _to_data_frame_stream_parser(self, data_frame_index, query_options, response, response_metadata_mode): + return FluxCsvParser(response=response, serialization_mode=FluxSerializationMode.dataFrame, + data_frame_index=data_frame_index, query_options=query_options, + response_metadata_mode=response_metadata_mode) + def _to_data_frames(self, _generator): """Parse stream of DataFrames into expected type.""" from ..extras import pd - _dataFrames = list(_generator) + if isinstance(_generator, list): + _dataFrames = _generator + else: + _dataFrames = list(_generator) + if len(_dataFrames) == 0: return pd.DataFrame(columns=[], index=None) elif len(_dataFrames) == 1: diff --git a/influxdb_client/client/query_api.py b/influxdb_client/client/query_api.py index 6783524d..61f9a9c5 100644 --- a/influxdb_client/client/query_api.py +++ b/influxdb_client/client/query_api.py @@ -124,7 +124,7 @@ def query_data_frame(self, query: str, org=None, data_frame_index: List[str] = N If not specified the default value from ``InfluxDBClient.org`` is used. :param data_frame_index: the list of columns that are used as DataFrame index :param params: bind parameters - :return: + :return: DataFrame or List of DataFrames """ _generator = self.query_data_frame_stream(query, org=org, data_frame_index=data_frame_index, params=params) return self._to_data_frames(_generator) diff --git a/influxdb_client/client/query_api_async.py b/influxdb_client/client/query_api_async.py index 5feb23de..f2d8d09f 100644 --- a/influxdb_client/client/query_api_async.py +++ b/influxdb_client/client/query_api_async.py @@ -47,7 +47,7 @@ async def query(self, query: str, org=None, params: dict = None) -> List['FluxTa async def query_stream(self, query: str, org=None, params: dict = None) -> AsyncGenerator['FluxRecord', None]: """ - Execute asynchronous Flux query and return stream of FluxRecord as a Generator['FluxRecord']. + Execute asynchronous Flux query and return stream of FluxRecord as an AsyncGenerator['FluxRecord']. :param query: the Flux query :param str, Organization org: specifies the organization for executing the query; @@ -65,6 +65,56 @@ async def query_stream(self, query: str, org=None, params: dict = None) -> Async return await self._to_flux_record_stream_async(response, query_options=self._get_query_options()) + async def query_data_frame(self, query: str, org=None, data_frame_index: List[str] = None, params: dict = None): + """ + Execute asynchronous Flux query and return Pandas DataFrame. + + Note that if a query returns tables with differing schemas than the client generates + a DataFrame for each of them. + + :param query: the Flux query + :param str, Organization org: specifies the organization for executing the query; + Take the ``ID``, ``Name`` or ``Organization``. + If not specified the default value from ``InfluxDBClient.org`` is used. + :param data_frame_index: the list of columns that are used as DataFrame index + :param params: bind parameters + :return: DataFrame or List of DataFrames + """ + _generator = await self.query_data_frame_stream(query, org=org, data_frame_index=data_frame_index, + params=params) + + dataframes = [] + async for dataframe in _generator: + dataframes.append(dataframe) + + return self._to_data_frames(dataframes) + + async def query_data_frame_stream(self, query: str, org=None, data_frame_index: List[str] = None, + params: dict = None): + """ + Execute asynchronous Flux query and return stream of Pandas DataFrame as an AsyncGenerator['pd.DataFrame']. + + Note that if a query returns tables with differing schemas than the client generates + a DataFrame for each of them. + + :param query: the Flux query + :param str, Organization org: specifies the organization for executing the query; + Take the ``ID``, ``Name`` or ``Organization``. + If not specified the default value from ``InfluxDBClient.org`` is used. + :param data_frame_index: the list of columns that are used as DataFrame index + :param params: bind parameters + :return: AsyncGenerator['pd.DataFrame'] + """ + org = self._org_param(org) + + response = await self._query_api.post_query_async(org=org, + query=self._create_query(query, self.default_dialect, params), + async_req=False, _preload_content=False, + _return_http_data_only=True) + + return await self._to_data_frame_stream_async(data_frame_index=data_frame_index, response=response, + query_options=self._get_query_options()) + async def query_raw(self, query: str, org=None, dialect=_BaseQueryApi.default_dialect, params: dict = None): """ Execute asynchronous Flux query and return result as raw unprocessed result as a str. diff --git a/tests/test_InfluxDBClientAsync.py b/tests/test_InfluxDBClientAsync.py index 4e4a91e0..1b9b581d 100644 --- a/tests/test_InfluxDBClientAsync.py +++ b/tests/test_InfluxDBClientAsync.py @@ -101,6 +101,30 @@ async def test_query_stream_records(self): self.assertEqual("Prague", records[1]['location']) self.assertEqual(25.3, records[1]['_value']) + @async_test + async def test_query_data_frame(self): + measurement = generate_name("measurement") + self._prepare_data(measurement) + query = f''' + from(bucket:"my-bucket") + |> range(start: -10m) + |> filter(fn: (r) => r["_measurement"] == "{measurement}") + |> group() + ''' + query_api = self.client.query_api() + + dataframe = await query_api.query_data_frame(query) + self.assertIsNotNone(dataframe) + self.assertEqual(2, len(dataframe)) + self.assertEqual(24.3, dataframe['_value'][0]) + self.assertEqual(25.3, dataframe['_value'][1]) + self.assertEqual('temperature', dataframe['_field'][0]) + self.assertEqual('temperature', dataframe['_field'][1]) + self.assertEqual(measurement, dataframe['_measurement'][0]) + self.assertEqual(measurement, dataframe['_measurement'][1]) + self.assertEqual('New York', dataframe['location'][0]) + self.assertEqual('Prague', dataframe['location'][1]) + def _prepare_data(self, measurement: str): with InfluxDBClient(url="http://localhost:8086", token="my-token", org="my-org") as client_sync: write_api = client_sync.write_api(write_options=SYNCHRONOUS) From 6d694240b20635774f37135a26c471ebbee0d90f Mon Sep 17 00:00:00 2001 From: Jakub Bednar Date: Tue, 8 Mar 2022 09:21:34 +0100 Subject: [PATCH 19/46] fix: check example --- .circleci/config.yml | 1 + 1 file changed, 1 insertion(+) diff --git a/.circleci/config.yml b/.circleci/config.yml index e2506cba..2493314c 100644 --- a/.circleci/config.yml +++ b/.circleci/config.yml @@ -129,6 +129,7 @@ jobs: command: | pip install -e . --user pip install -e .\[async\] --user + pip install -e .\[extra\] --user export PYTHONPATH="$PWD" python examples/monitoring_and_alerting.py python examples/buckets_management.py From 02f4770bca8f3beb81d6cbf2ec85e5fbca6e56b9 Mon Sep 17 00:00:00 2001 From: Jakub Bednar Date: Tue, 8 Mar 2022 10:27:39 +0100 Subject: [PATCH 20/46] feat: prepare async version of WriteApi --- docs/api_async.rst | 5 ++++ influxdb_client/client/_base.py | 11 +++++++- influxdb_client/client/influxdb_client.py | 2 +- .../client/influxdb_client_async.py | 23 +++++++++++++++ influxdb_client/client/query_api.py | 3 -- influxdb_client/client/query_api_async.py | 6 +--- influxdb_client/client/write_api.py | 11 ++++---- influxdb_client/client/write_api_async.py | 28 +++++++++++++++++++ tests/test_InfluxDBClientAsync.py | 4 +++ 9 files changed, 77 insertions(+), 16 deletions(-) create mode 100644 influxdb_client/client/write_api_async.py diff --git a/docs/api_async.rst b/docs/api_async.rst index a5b5a13a..4937e6c8 100644 --- a/docs/api_async.rst +++ b/docs/api_async.rst @@ -13,3 +13,8 @@ QueryApiAsync """"""""""""" .. autoclass:: influxdb_client.client.query_api_async.QueryApiAsync :members: + +WriteApiAsync +""""""""""""" +.. autoclass:: influxdb_client.client.write_api_async.WriteApiAsync + :members: diff --git a/influxdb_client/client/_base.py b/influxdb_client/client/_base.py index 783fc1c8..69bd811c 100644 --- a/influxdb_client/client/_base.py +++ b/influxdb_client/client/_base.py @@ -11,7 +11,8 @@ from influxdb_client import Configuration, Dialect, Query, OptionStatement, VariableAssignment, Identifier, \ Expression, BooleanLiteral, IntegerLiteral, FloatLiteral, DateTimeLiteral, UnaryExpression, DurationLiteral, \ - Duration, StringLiteral, ArrayExpression, ImportDeclaration, MemberExpression, MemberAssignment, File + Duration, StringLiteral, ArrayExpression, ImportDeclaration, MemberExpression, MemberAssignment, File, \ + WriteService, QueryService from influxdb_client.client.flux_csv_parser import FluxResponseMetadataMode, FluxCsvParser, FluxSerializationMode, \ _CSV_ENCODING from influxdb_client.client.flux_table import FluxTable, FluxRecord @@ -73,6 +74,7 @@ def __init__(self, influxdb_client, query_options=None): from influxdb_client.client.query_api import QueryOptions self._query_options = QueryOptions() if query_options is None else query_options self._influxdb_client = influxdb_client + self._query_api = QueryService(influxdb_client.api_client) """Base implementation for Queryable API.""" @@ -275,6 +277,13 @@ def _build_flux_ast(params: dict = None, profilers: List[str] = None): return File(package=None, name=None, type=None, imports=imports, body=body) +class _BaseWriteApi(object): + def __init__(self, influxdb_client, point_settings=None): + self._influxdb_client = influxdb_client + self._point_settings = point_settings + self._write_service = WriteService(influxdb_client.api_client) + + class _Configuration(Configuration): def __init__(self): Configuration.__init__(self) diff --git a/influxdb_client/client/influxdb_client.py b/influxdb_client/client/influxdb_client.py index 081c648c..731110c0 100644 --- a/influxdb_client/client/influxdb_client.py +++ b/influxdb_client/client/influxdb_client.py @@ -226,7 +226,7 @@ def from_env_properties(cls, debug=None, enable_gzip=False): def write_api(self, write_options=WriteOptions(), point_settings=PointSettings(), **kwargs) -> WriteApi: """ - Create a Write API instance. + Create Write API instance. Example: .. code-block:: python diff --git a/influxdb_client/client/influxdb_client_async.py b/influxdb_client/client/influxdb_client_async.py index c7322298..2f041901 100644 --- a/influxdb_client/client/influxdb_client_async.py +++ b/influxdb_client/client/influxdb_client_async.py @@ -5,6 +5,8 @@ from influxdb_client.client._base import _BaseClient from influxdb_client.client.query_api import QueryOptions from influxdb_client.client.query_api_async import QueryApiAsync +from influxdb_client.client.write_api import PointSettings +from influxdb_client.client.write_api_async import WriteApiAsync logger = logging.getLogger('influxdb_client.client.influxdb_client') @@ -78,3 +80,24 @@ def query_api(self, query_options: QueryOptions = QueryOptions()) -> QueryApiAsy :return: Query api instance """ return QueryApiAsync(self, query_options) + + def write_api(self, point_settings=PointSettings()) -> WriteApiAsync: + """ + Create an asynchronous Write API instance. + + Example: + .. code-block:: python + + from influxdb_client_async import InfluxDBClientAsync + + + # Initialize async/await instance of Write API + async with InfluxDBClientAsync(url="http://localhost:8086", token="my-token", org="my-org") as client: + write_api = client.write_api() + + If you would like to use a **background batching**, you have to configure client like this: + + :param point_settings: settings to store default tags + :return: write api instance + """ + return WriteApiAsync(influxdb_client=self, point_settings=point_settings) diff --git a/influxdb_client/client/query_api.py b/influxdb_client/client/query_api.py index 61f9a9c5..00e654a6 100644 --- a/influxdb_client/client/query_api.py +++ b/influxdb_client/client/query_api.py @@ -7,7 +7,6 @@ from typing import List, Generator, Any, Callable from influxdb_client import Dialect -from influxdb_client import QueryService from influxdb_client.client._base import _BaseQueryApi from influxdb_client.client.flux_table import FluxTable, FluxRecord @@ -37,8 +36,6 @@ def __init__(self, influxdb_client, query_options=QueryOptions()): """ super().__init__(influxdb_client=influxdb_client, query_options=query_options) - self._query_api = QueryService(influxdb_client.api_client) - def query_csv(self, query: str, org=None, dialect: Dialect = _BaseQueryApi.default_dialect, params: dict = None): """ Execute the Flux query and return results as a CSV iterator. Each iteration returns a row of the CSV file. diff --git a/influxdb_client/client/query_api_async.py b/influxdb_client/client/query_api_async.py index f2d8d09f..e6444abb 100644 --- a/influxdb_client/client/query_api_async.py +++ b/influxdb_client/client/query_api_async.py @@ -5,7 +5,6 @@ """ from typing import List, AsyncGenerator -from influxdb_client import QueryService from influxdb_client.client._base import _BaseQueryApi, _CSV_ENCODING from influxdb_client.client.flux_table import FluxTable, FluxRecord from influxdb_client.client.query_api import QueryOptions @@ -20,10 +19,7 @@ def __init__(self, influxdb_client, query_options=QueryOptions()): :param influxdb_client: influxdb client """ - super().__init__(influxdb_client=influxdb_client) - - self._query_options = query_options - self._query_api = QueryService(influxdb_client.api_client) + super().__init__(influxdb_client=influxdb_client, query_options=query_options) async def query(self, query: str, org=None, params: dict = None) -> List['FluxTable']: """ diff --git a/influxdb_client/client/write_api.py b/influxdb_client/client/write_api.py index 54a506d4..0dcd1573 100644 --- a/influxdb_client/client/write_api.py +++ b/influxdb_client/client/write_api.py @@ -1,4 +1,4 @@ -"""Collect and write time series data to InfluxDB Cloud and InfluxDB OSS.""" +"""Collect and write time series data to InfluxDB Cloud or InfluxDB OSS.""" # coding: utf-8 import logging @@ -15,7 +15,8 @@ from rx.scheduler import ThreadPoolScheduler from rx.subject import Subject -from influxdb_client import WritePrecision, WriteService +from influxdb_client import WritePrecision +from influxdb_client.client._base import _BaseWriteApi from influxdb_client.client.util.helpers import get_org_query_param from influxdb_client.client.write.dataframe_serializer import DataframeSerializer from influxdb_client.client.write.point import Point, DEFAULT_WRITE_PRECISION @@ -191,7 +192,7 @@ def _body_reduce(batch_items): return b'\n'.join(map(lambda batch_item: batch_item.data, batch_items)) -class WriteApi: +class WriteApi(_BaseWriteApi): """ Implementation for '/api/v2/write' endpoint. @@ -242,10 +243,8 @@ def __init__(self, **[batching mode]** """ - self._influxdb_client = influxdb_client - self._write_service = WriteService(influxdb_client.api_client) + super().__init__(influxdb_client=influxdb_client, point_settings=point_settings) self._write_options = write_options - self._point_settings = point_settings self._success_callback = kwargs.get('success_callback', None) self._error_callback = kwargs.get('error_callback', None) self._retry_callback = kwargs.get('retry_callback', None) diff --git a/influxdb_client/client/write_api_async.py b/influxdb_client/client/write_api_async.py new file mode 100644 index 00000000..39e12e52 --- /dev/null +++ b/influxdb_client/client/write_api_async.py @@ -0,0 +1,28 @@ +"""Collect and async write time series data to InfluxDB Cloud or InfluxDB OSS.""" +from influxdb_client.client._base import _BaseWriteApi +from influxdb_client.client.write_api import PointSettings + + +class WriteApiAsync(_BaseWriteApi): + """ + Implementation for '/api/v2/write' endpoint. + + Example: + .. code-block:: python + + from influxdb_client_async import InfluxDBClientAsync + + + # Initialize async/await instance of Write API + async with InfluxDBClientAsync(url="http://localhost:8086", token="my-token", org="my-org") as client: + write_api = client.write_api() + """ + + def __init__(self, influxdb_client, point_settings: PointSettings = PointSettings()) -> None: + """ + Initialize defaults. + + :param influxdb_client: with default settings (organization) + :param point_settings: settings to store default tags. + """ + super().__init__(influxdb_client=influxdb_client, point_settings=point_settings) diff --git a/tests/test_InfluxDBClientAsync.py b/tests/test_InfluxDBClientAsync.py index 1b9b581d..d54ca376 100644 --- a/tests/test_InfluxDBClientAsync.py +++ b/tests/test_InfluxDBClientAsync.py @@ -43,6 +43,10 @@ def test_create_query_api(self): query_api = self.client.query_api() self.assertIsNotNone(query_api) + def test_create_write_api(self): + write_api = self.client.write_api() + self.assertIsNotNone(write_api) + @async_test async def test_query_tables(self): measurement = generate_name("measurement") From 1cae01c9e39ac3e11b35bdddacdb316b649b2496 Mon Sep 17 00:00:00 2001 From: Jakub Bednar Date: Tue, 8 Mar 2022 12:51:41 +0100 Subject: [PATCH 21/46] feat: async version of WriteApi --- examples/asynchronous.py | 19 ++--- influxdb_client/client/_base.py | 57 ++++++++++++++ influxdb_client/client/write/point.py | 10 ++- influxdb_client/client/write_api.py | 53 +------------ influxdb_client/client/write_api_async.py | 95 ++++++++++++++++++++++- tests/test_InfluxDBClientAsync.py | 65 ++++++++++++---- 6 files changed, 217 insertions(+), 82 deletions(-) diff --git a/examples/asynchronous.py b/examples/asynchronous.py index 23601d77..c61eac77 100644 --- a/examples/asynchronous.py +++ b/examples/asynchronous.py @@ -3,9 +3,8 @@ """ import asyncio -from influxdb_client import InfluxDBClient, Point +from influxdb_client import Point from influxdb_client.client.influxdb_client_async import InfluxDBClientAsync -from influxdb_client.client.write_api import SYNCHRONOUS async def main(): @@ -20,22 +19,16 @@ async def main(): """ Prepare data """ - # tmp solution before implements WriteApiAsync - with InfluxDBClient(url="http://localhost:8086", token="my-token", org="my-org", debug=False) as client_sync: - write_api = client_sync.write_api(write_options=SYNCHRONOUS) - - """ - Prepare data - """ - _point1 = Point("async_m").tag("location", "Prague").field("temperature", 25.3) - _point2 = Point("async_m").tag("location", "New York").field("temperature", 24.3) - write_api.write(bucket="my-bucket", record=[_point1, _point2]) + write_api = client.write_api() + _point1 = Point("async_m").tag("location", "Prague").field("temperature", 25.3) + _point2 = Point("async_m").tag("location", "New York").field("temperature", 24.3) + await write_api.write(bucket="my-bucket", record=[_point1, _point2]) """ Query: using Table structure """ - print(f"\n------- Query: using Table structure -------\n") query_api = client.query_api() + print(f"\n------- Query: using Table structure -------\n") tables = await query_api.query('from(bucket:"my-bucket") ' '|> range(start: -10m) ' '|> filter(fn: (r) => r["_measurement"] == "async_m")') diff --git a/influxdb_client/client/_base.py b/influxdb_client/client/_base.py index 69bd811c..a1cc77b7 100644 --- a/influxdb_client/client/_base.py +++ b/influxdb_client/client/_base.py @@ -18,6 +18,14 @@ from influxdb_client.client.flux_table import FluxTable, FluxRecord from influxdb_client.client.util.date_utils import get_date_helper from influxdb_client.client.util.helpers import get_org_query_param +from influxdb_client.client.write.dataframe_serializer import DataframeSerializer + +try: + import dataclasses + + _HAS_DATACLASS = True +except ModuleNotFoundError: + _HAS_DATACLASS = False # noinspection PyMethodMayBeStatic @@ -282,6 +290,55 @@ def __init__(self, influxdb_client, point_settings=None): self._influxdb_client = influxdb_client self._point_settings = point_settings self._write_service = WriteService(influxdb_client.api_client) + if influxdb_client.default_tags: + for key, value in influxdb_client.default_tags.items(): + self._point_settings.add_default_tag(key, value) + + def _append_default_tag(self, key, val, record): + from influxdb_client import Point + if isinstance(record, bytes) or isinstance(record, str): + pass + elif isinstance(record, Point): + record.tag(key, val) + elif isinstance(record, dict): + record.setdefault("tags", {}) + record.get("tags")[key] = val + elif isinstance(record, Iterable): + for item in record: + self._append_default_tag(key, val, item) + + def _append_default_tags(self, record): + if self._point_settings.defaultTags and record is not None: + for key, val in self._point_settings.defaultTags.items(): + self._append_default_tag(key, val, record) + + def _serialize(self, record, write_precision, payload, **kwargs): + from influxdb_client import Point + if isinstance(record, bytes): + payload[write_precision].append(record) + + elif isinstance(record, str): + self._serialize(record.encode("utf-8"), write_precision, payload, **kwargs) + + elif isinstance(record, Point): + precision_from_point = kwargs.get('precision_from_point', True) + precision = record.write_precision if precision_from_point else write_precision + self._serialize(record.to_line_protocol(precision=precision), precision, payload, **kwargs) + + elif isinstance(record, dict): + self._serialize(Point.from_dict(record, write_precision=write_precision, **kwargs), + write_precision, payload, **kwargs) + elif 'DataFrame' in type(record).__name__: + serializer = DataframeSerializer(record, self._point_settings, write_precision, **kwargs) + self._serialize(serializer.serialize(), write_precision, payload, **kwargs) + elif hasattr(record, "_asdict"): + # noinspection PyProtectedMember + self._serialize(record._asdict(), write_precision, payload, **kwargs) + elif _HAS_DATACLASS and dataclasses.is_dataclass(record): + self._serialize(dataclasses.asdict(record), write_precision, payload, **kwargs) + elif isinstance(record, Iterable): + for item in record: + self._serialize(item, write_precision, payload, **kwargs) class _Configuration(Configuration): diff --git a/influxdb_client/client/write/point.py b/influxdb_client/client/write/point.py index 96d2261e..b4ad29b5 100644 --- a/influxdb_client/client/write/point.py +++ b/influxdb_client/client/write/point.py @@ -177,14 +177,18 @@ def field(self, field, value): self._fields[field] = value return self - def to_line_protocol(self): - """Create LineProtocol.""" + def to_line_protocol(self, precision=None): + """ + Create LineProtocol. + + :param precision: required precision of LineProtocol. If it's not set then use the precision from Point. + """ _measurement = _escape_key(self._name, _ESCAPE_MEASUREMENT) _tags = _append_tags(self._tags) _fields = _append_fields(self._fields) if not _fields: return "" - _time = _append_time(self._time, self._write_precision) + _time = _append_time(self._time, self._write_precision if precision is None else precision) return f"{_measurement}{_tags}{_fields}{_time}" diff --git a/influxdb_client/client/write_api.py b/influxdb_client/client/write_api.py index 0dcd1573..12a3e865 100644 --- a/influxdb_client/client/write_api.py +++ b/influxdb_client/client/write_api.py @@ -16,7 +16,7 @@ from rx.subject import Subject from influxdb_client import WritePrecision -from influxdb_client.client._base import _BaseWriteApi +from influxdb_client.client._base import _BaseWriteApi, _HAS_DATACLASS from influxdb_client.client.util.helpers import get_org_query_param from influxdb_client.client.write.dataframe_serializer import DataframeSerializer from influxdb_client.client.write.point import Point, DEFAULT_WRITE_PRECISION @@ -25,14 +25,10 @@ logger = logging.getLogger(__name__) -try: +if _HAS_DATACLASS: import dataclasses from dataclasses import dataclass - _HAS_DATACLASS = True -except ModuleNotFoundError: - _HAS_DATACLASS = False - class WriteType(Enum): """Configuration which type of writes will client use.""" @@ -249,10 +245,6 @@ def __init__(self, self._error_callback = kwargs.get('error_callback', None) self._retry_callback = kwargs.get('retry_callback', None) - if influxdb_client.default_tags: - for key, value in influxdb_client.default_tags.items(): - self._point_settings.add_default_tag(key, value) - if self._write_options.write_type is WriteType.batching: # Define Subject that listen incoming data and produces writes into InfluxDB self._subject = Subject() @@ -350,9 +342,7 @@ def write(self, bucket: str, org: str = None, """ # noqa: E501 org = get_org_query_param(org=org, client=self._influxdb_client) - if self._point_settings.defaultTags and record is not None: - for key, val in self._point_settings.defaultTags.items(): - self._append_default_tag(key, val, record) + self._append_default_tags(record) if self._write_options.write_type is WriteType.batching: return self._write_batching(bucket, org, record, @@ -413,31 +403,6 @@ def __del__(self): self._disposable = None pass - def _serialize(self, record, write_precision, payload, **kwargs): - if isinstance(record, bytes): - payload[write_precision].append(record) - - elif isinstance(record, str): - self._serialize(record.encode("utf-8"), write_precision, payload, **kwargs) - - elif isinstance(record, Point): - self._serialize(record.to_line_protocol(), record.write_precision, payload, **kwargs) - - elif isinstance(record, dict): - self._serialize(Point.from_dict(record, write_precision=write_precision, **kwargs), - write_precision, payload, **kwargs) - elif 'DataFrame' in type(record).__name__: - serializer = DataframeSerializer(record, self._point_settings, write_precision, **kwargs) - self._serialize(serializer.serialize(), write_precision, payload, **kwargs) - elif hasattr(record, "_asdict"): - # noinspection PyProtectedMember - self._serialize(record._asdict(), write_precision, payload, **kwargs) - elif _HAS_DATACLASS and dataclasses.is_dataclass(record): - self._serialize(dataclasses.asdict(record), write_precision, payload, **kwargs) - elif isinstance(record, Iterable): - for item in record: - self._serialize(item, write_precision, payload, **kwargs) - def _write_batching(self, bucket, org, data, precision=DEFAULT_WRITE_PRECISION, **kwargs): @@ -480,18 +445,6 @@ def _write_batching(self, bucket, org, data, return None - def _append_default_tag(self, key, val, record): - if isinstance(record, bytes) or isinstance(record, str): - pass - elif isinstance(record, Point): - record.tag(key, val) - elif isinstance(record, dict): - record.setdefault("tags", {}) - record.get("tags")[key] = val - elif isinstance(record, Iterable): - for item in record: - self._append_default_tag(key, val, item) - def _http(self, batch_item: _BatchItem): logger.debug("Write time series data into InfluxDB: %s", batch_item) diff --git a/influxdb_client/client/write_api_async.py b/influxdb_client/client/write_api_async.py index 39e12e52..9f5283ec 100644 --- a/influxdb_client/client/write_api_async.py +++ b/influxdb_client/client/write_api_async.py @@ -1,7 +1,19 @@ """Collect and async write time series data to InfluxDB Cloud or InfluxDB OSS.""" -from influxdb_client.client._base import _BaseWriteApi +import logging +from collections import defaultdict +from typing import Union, Iterable, NamedTuple, Any + +from influxdb_client import Point, WritePrecision +from influxdb_client.client._base import _BaseWriteApi, _HAS_DATACLASS +from influxdb_client.client.util.helpers import get_org_query_param +from influxdb_client.client.write.point import DEFAULT_WRITE_PRECISION from influxdb_client.client.write_api import PointSettings +logger = logging.getLogger('influxdb_client.client.influxdb_client') + +if _HAS_DATACLASS: + from dataclasses import dataclass + class WriteApiAsync(_BaseWriteApi): """ @@ -26,3 +38,84 @@ def __init__(self, influxdb_client, point_settings: PointSettings = PointSetting :param point_settings: settings to store default tags. """ super().__init__(influxdb_client=influxdb_client, point_settings=point_settings) + + async def write(self, bucket: str, org: str = None, + record: Union[str, Iterable['str'], Point, Iterable['Point'], dict, Iterable['dict'], bytes, + Iterable['bytes'], NamedTuple, Iterable['NamedTuple'], 'dataclass', + Iterable['dataclass']] = None, + write_precision: WritePrecision = DEFAULT_WRITE_PRECISION, **kwargs) -> bool: + """ + Write time-series data into InfluxDB. + + :param str bucket: specifies the destination bucket for writes (required) + :param str, Organization org: specifies the destination organization for writes; + take the ID, Name or Organization. + If not specified the default value from ``InfluxDBClient.org`` is used. + :param WritePrecision write_precision: specifies the precision for the unix timestamps within + the body line-protocol. The precision specified on a Point has precedes + and is use for write. + :param record: Point, Line Protocol, Dictionary, NamedTuple, Data Classes, Pandas DataFrame + :key data_frame_measurement_name: name of measurement for writing Pandas DataFrame - ``DataFrame`` + :key data_frame_tag_columns: list of DataFrame columns which are tags, + rest columns will be fields - ``DataFrame`` + :key record_measurement_key: key of record with specified measurement - + ``dictionary``, ``NamedTuple``, ``dataclass`` + :key record_measurement_name: static measurement name - ``dictionary``, ``NamedTuple``, ``dataclass`` + :key record_time_key: key of record with specified timestamp - ``dictionary``, ``NamedTuple``, ``dataclass`` + :key record_tag_keys: list of record keys to use as a tag - ``dictionary``, ``NamedTuple``, ``dataclass`` + :key record_field_keys: list of record keys to use as a field - ``dictionary``, ``NamedTuple``, ``dataclass`` + :return: ``True`` for successfully accepted data, otherwise raise an exception + + Example: + .. code-block:: python + + # Record as Line Protocol + await write_api.write("my-bucket", "my-org", "h2o_feet,location=us-west level=125i 1") + + # Record as Dictionary + dictionary = { + "measurement": "h2o_feet", + "tags": {"location": "us-west"}, + "fields": {"level": 125}, + "time": 1 + } + await write_api.write("my-bucket", "my-org", dictionary) + + # Record as Point + from influxdb_client import Point + point = Point("h2o_feet").tag("location", "us-west").field("level", 125).time(1) + await write_api.write("my-bucket", "my-org", point) + + DataFrame: + The index of `Pandas DataFrame `_ + is used as a ``timestamp`` for written data. The index should be `PeriodIndex `_ + or its must be transformable to ``datetime`` by + `pandas.to_datetime `_. + + If you would like to transform a column to ``PeriodIndex``, you can use something like: + + .. code-block:: python + + import pandas as pd + + # DataFrame + data_frame = ... + # Set column as Index + data_frame.set_index('column_name', inplace=True) + # Transform index to PeriodIndex + data_frame.index = pd.to_datetime(data_frame.index, unit='s') + + """ # noqa: E501 + org = get_org_query_param(org=org, client=self._influxdb_client) + self._append_default_tags(record) + + payloads = defaultdict(list) + self._serialize(record, write_precision, payloads, precision_from_point=False, **kwargs) + + # joint list by \n + body = b'\n'.join(payloads[write_precision]) + response = await self._write_service.post_write_async(org=org, bucket=bucket, body=body, + precision=write_precision, async_req=False, + content_encoding="identity", + content_type="text/plain; charset=utf-8") + return response[1] == 204 diff --git a/tests/test_InfluxDBClientAsync.py b/tests/test_InfluxDBClientAsync.py index d54ca376..301743a4 100644 --- a/tests/test_InfluxDBClientAsync.py +++ b/tests/test_InfluxDBClientAsync.py @@ -1,9 +1,9 @@ import asyncio import unittest +from datetime import datetime -from influxdb_client import InfluxDBClient, Point +from influxdb_client import Point, WritePrecision from influxdb_client.client.influxdb_client_async import InfluxDBClientAsync -from influxdb_client.client.write_api import SYNCHRONOUS from tests.base_test import generate_name @@ -50,7 +50,7 @@ def test_create_write_api(self): @async_test async def test_query_tables(self): measurement = generate_name("measurement") - self._prepare_data(measurement) + await self._prepare_data(measurement) query = f''' from(bucket:"my-bucket") |> range(start: -10m) @@ -70,7 +70,7 @@ async def test_query_tables(self): @async_test async def test_query_raw(self): measurement = generate_name("measurement") - self._prepare_data(measurement) + await self._prepare_data(measurement) query = f''' from(bucket:"my-bucket") |> range(start: -10m) @@ -87,7 +87,7 @@ async def test_query_raw(self): @async_test async def test_query_stream_records(self): measurement = generate_name("measurement") - self._prepare_data(measurement) + await self._prepare_data(measurement) query = f''' from(bucket:"my-bucket") |> range(start: -10m) @@ -108,7 +108,7 @@ async def test_query_stream_records(self): @async_test async def test_query_data_frame(self): measurement = generate_name("measurement") - self._prepare_data(measurement) + await self._prepare_data(measurement) query = f''' from(bucket:"my-bucket") |> range(start: -10m) @@ -129,13 +129,48 @@ async def test_query_data_frame(self): self.assertEqual('New York', dataframe['location'][0]) self.assertEqual('Prague', dataframe['location'][1]) - def _prepare_data(self, measurement: str): - with InfluxDBClient(url="http://localhost:8086", token="my-token", org="my-org") as client_sync: - write_api = client_sync.write_api(write_options=SYNCHRONOUS) + @async_test + async def test_write_response_type(self): + measurement = generate_name("measurement") + point = Point(measurement).tag("location", "Prague").field("temperature", 25.3) + response = await self.client.write_api().write(bucket="my-bucket", record=point) + + self.assertEqual(True, response) + + @async_test + async def test_write_empty_data(self): + measurement = generate_name("measurement") + point = Point(measurement).tag("location", "Prague") + response = await self.client.write_api().write(bucket="my-bucket", record=point) + + self.assertEqual(True, response) + + @async_test + async def test_write_points_different_precision(self): + measurement = generate_name("measurement") + _point1 = Point(measurement).tag("location", "Prague").field("temperature", 25.3) \ + .time(datetime.utcfromtimestamp(0), write_precision=WritePrecision.S) + _point2 = Point(measurement).tag("location", "New York").field("temperature", 24.3) \ + .time(datetime.utcfromtimestamp(1), write_precision=WritePrecision.MS) + _point3 = Point(measurement).tag("location", "Berlin").field("temperature", 24.3) \ + .time(datetime.utcfromtimestamp(2), write_precision=WritePrecision.NS) + await self.client.write_api().write(bucket="my-bucket", record=[_point1, _point2, _point3], + write_precision=WritePrecision.NS) + query = f''' + from(bucket:"my-bucket") + |> range(start: 0) + |> filter(fn: (r) => r["_measurement"] == "{measurement}") + |> keep(columns: ["_time"]) + ''' + query_api = self.client.query_api() - """ - Prepare data - """ - _point1 = Point(measurement).tag("location", "Prague").field("temperature", 25.3) - _point2 = Point(measurement).tag("location", "New York").field("temperature", 24.3) - write_api.write(bucket="my-bucket", record=[_point1, _point2]) + raw = await query_api.query_raw(query) + self.assertEqual(8, len(raw.splitlines())) + self.assertEqual(',,0,1970-01-01T00:00:02Z', raw.splitlines()[4]) + self.assertEqual(',,0,1970-01-01T00:00:01Z', raw.splitlines()[5]) + self.assertEqual(',,0,1970-01-01T00:00:00Z', raw.splitlines()[6]) + + async def _prepare_data(self, measurement: str): + _point1 = Point(measurement).tag("location", "Prague").field("temperature", 25.3) + _point2 = Point(measurement).tag("location", "New York").field("temperature", 24.3) + await self.client.write_api().write(bucket="my-bucket", record=[_point1, _point2]) From 85736364a86f0edea0f2fc3e55496e7eb2fc4fa8 Mon Sep 17 00:00:00 2001 From: Jakub Bednar Date: Tue, 8 Mar 2022 12:56:25 +0100 Subject: [PATCH 22/46] fix: code style --- README.rst | 25 ++--------------------- influxdb_client/client/write_api_async.py | 2 +- 2 files changed, 3 insertions(+), 24 deletions(-) diff --git a/README.rst b/README.rst index 7cd9c72a..f1a25ab1 100644 --- a/README.rst +++ b/README.rst @@ -124,7 +124,7 @@ If your application uses async/await in Python you can install with the ``async` $ pip install influxdb-client[async] -For more info se `How to use asyncio`_. +For more info se `How to use Asyncio`_. Setuptools ^^^^^^^^^^ @@ -587,27 +587,6 @@ Examples: self.client = InfluxDBClient.from_env_properties() -Asynchronous client -""""""""""""""""""" - -Data are writes in an asynchronous HTTP request. - -.. code-block:: python - - from influxdb_client import InfluxDBClient, Point - from influxdb_client.client.write_api import ASYNCHRONOUS - - client = InfluxDBClient(url="http://localhost:8086", token="my-token", org="my-org") - write_api = client.write_api(write_options=ASYNCHRONOUS) - - _point1 = Point("my_measurement").tag("location", "Prague").field("temperature", 25.3) - _point2 = Point("my_measurement").tag("location", "New York").field("temperature", 24.3) - - async_result = write_api.write(bucket="my-bucket", record=[_point1, _point2]) - async_result.get() - - client.close() - Synchronous client """""""""""""""""" @@ -1330,7 +1309,7 @@ that is replacement for python ``datetime.datetime`` object and also you should .. marker-nanosecond-end -How to use asyncio +How to use Asyncio ^^^^^^^^^^^^^^^^^^ .. marker-asyncio-start diff --git a/influxdb_client/client/write_api_async.py b/influxdb_client/client/write_api_async.py index 9f5283ec..e0b23587 100644 --- a/influxdb_client/client/write_api_async.py +++ b/influxdb_client/client/write_api_async.py @@ -1,7 +1,7 @@ """Collect and async write time series data to InfluxDB Cloud or InfluxDB OSS.""" import logging from collections import defaultdict -from typing import Union, Iterable, NamedTuple, Any +from typing import Union, Iterable, NamedTuple from influxdb_client import Point, WritePrecision from influxdb_client.client._base import _BaseWriteApi, _HAS_DATACLASS From e8bcc46cc6e68fb57a20ed44ee0fd4f9dfbab9b4 Mon Sep 17 00:00:00 2001 From: Jakub Bednar Date: Tue, 8 Mar 2022 12:57:55 +0100 Subject: [PATCH 23/46] chore: delete_service is able to run async request --- influxdb_client/service/delete_service.py | 98 +++++++++++++++++++++++ 1 file changed, 98 insertions(+) diff --git a/influxdb_client/service/delete_service.py b/influxdb_client/service/delete_service.py index 174d6ce6..7e625be8 100644 --- a/influxdb_client/service/delete_service.py +++ b/influxdb_client/service/delete_service.py @@ -155,3 +155,101 @@ def post_delete_with_http_info(self, delete_predicate_request, **kwargs): # noq _request_timeout=local_var_params.get('_request_timeout'), collection_formats=collection_formats, urlopen_kw=urlopen_kw) + + async def post_delete_async(self, delete_predicate_request, **kwargs): # noqa: E501,D401,D403 + """Delete data. + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.post_delete_with_http_info(delete_predicate_request, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param DeletePredicateRequest delete_predicate_request: Deletes data from an InfluxDB bucket. (required) + :param str zap_trace_span: OpenTracing span context + :param str org: Specifies the organization to delete data from. + :param str bucket: Specifies the bucket to delete data from. + :param str org_id: Specifies the organization ID of the resource. + :param str bucket_id: Specifies the bucket ID to delete data from. + :return: None + If the method is called asynchronously, + returns the request thread. + """ # noqa: E501 + local_var_params = locals() + + all_params = ['delete_predicate_request', 'zap_trace_span', 'org', 'bucket', 'org_id', 'bucket_id'] # noqa: E501 + all_params.append('async_req') + all_params.append('_return_http_data_only') + all_params.append('_preload_content') + all_params.append('_request_timeout') + all_params.append('urlopen_kw') + + for key, val in six.iteritems(local_var_params['kwargs']): + if key not in all_params: + raise TypeError( + "Got an unexpected keyword argument '%s'" + " to method post_delete" % key + ) + local_var_params[key] = val + del local_var_params['kwargs'] + # verify the required parameter 'delete_predicate_request' is set + if ('delete_predicate_request' not in local_var_params or + local_var_params['delete_predicate_request'] is None): + raise ValueError("Missing the required parameter `delete_predicate_request` when calling `post_delete`") # noqa: E501 + + collection_formats = {} + + path_params = {} + + query_params = [] + if 'org' in local_var_params: + query_params.append(('org', local_var_params['org'])) # noqa: E501 + if 'bucket' in local_var_params: + query_params.append(('bucket', local_var_params['bucket'])) # noqa: E501 + if 'org_id' in local_var_params: + query_params.append(('orgID', local_var_params['org_id'])) # noqa: E501 + if 'bucket_id' in local_var_params: + query_params.append(('bucketID', local_var_params['bucket_id'])) # noqa: E501 + + header_params = {} + if 'zap_trace_span' in local_var_params: + header_params['Zap-Trace-Span'] = local_var_params['zap_trace_span'] # noqa: E501 + + form_params = [] + local_var_files = {} + + body_params = None + if 'delete_predicate_request' in local_var_params: + body_params = local_var_params['delete_predicate_request'] + # HTTP header `Accept` + header_params['Accept'] = self.api_client.select_header_accept( + ['application/json']) # noqa: E501 + + # HTTP header `Content-Type` + header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501 + ['application/json']) # noqa: E501 + + # Authentication setting + auth_settings = [] # noqa: E501 + + # urlopen optional setting + urlopen_kw = None + if 'urlopen_kw' in kwargs: + urlopen_kw = kwargs['urlopen_kw'] + + return await self.api_client.call_api( + '/api/v2/delete', 'POST', + path_params, + query_params, + header_params, + body=body_params, + post_params=form_params, + files=local_var_files, + response_type=None, # noqa: E501 + auth_settings=auth_settings, + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats=collection_formats, + urlopen_kw=urlopen_kw) From e3b1dcd876735acb46ee503dd13a4c39c20f6132 Mon Sep 17 00:00:00 2001 From: Jakub Bednar Date: Tue, 8 Mar 2022 13:16:17 +0100 Subject: [PATCH 24/46] chore: delete_service is able to run async request --- docs/api_async.rst | 5 +++ influxdb_client/client/_base.py | 18 +++++++++- influxdb_client/client/delete_api.py | 17 +++------ influxdb_client/client/delete_api_async.py | 36 +++++++++++++++++++ .../client/influxdb_client_async.py | 9 +++++ influxdb_client/client/query_api_async.py | 10 +++--- influxdb_client/client/write_api_async.py | 2 +- tests/test_InfluxDBClientAsync.py | 23 ++++++++++++ 8 files changed, 101 insertions(+), 19 deletions(-) create mode 100644 influxdb_client/client/delete_api_async.py diff --git a/docs/api_async.rst b/docs/api_async.rst index 4937e6c8..8f70247a 100644 --- a/docs/api_async.rst +++ b/docs/api_async.rst @@ -18,3 +18,8 @@ WriteApiAsync """"""""""""" .. autoclass:: influxdb_client.client.write_api_async.WriteApiAsync :members: + +DeleteApiAsync +"""""""""""""" +.. autoclass:: influxdb_client.client.delete_api_async.DeleteApiAsync + :members: diff --git a/influxdb_client/client/_base.py b/influxdb_client/client/_base.py index a1cc77b7..3ea977ec 100644 --- a/influxdb_client/client/_base.py +++ b/influxdb_client/client/_base.py @@ -12,7 +12,7 @@ from influxdb_client import Configuration, Dialect, Query, OptionStatement, VariableAssignment, Identifier, \ Expression, BooleanLiteral, IntegerLiteral, FloatLiteral, DateTimeLiteral, UnaryExpression, DurationLiteral, \ Duration, StringLiteral, ArrayExpression, ImportDeclaration, MemberExpression, MemberAssignment, File, \ - WriteService, QueryService + WriteService, QueryService, DeleteService, DeletePredicateRequest from influxdb_client.client.flux_csv_parser import FluxResponseMetadataMode, FluxCsvParser, FluxSerializationMode, \ _CSV_ENCODING from influxdb_client.client.flux_table import FluxTable, FluxRecord @@ -341,6 +341,22 @@ def _serialize(self, record, write_precision, payload, **kwargs): self._serialize(item, write_precision, payload, **kwargs) +# noinspection PyMethodMayBeStatic +class _BaseDeleteApi(object): + def __init__(self, influxdb_client): + self._influxdb_client = influxdb_client + self._service = DeleteService(influxdb_client.api_client) + + def _prepare_predicate_request(self, start, stop, predicate): + date_helper = get_date_helper() + if isinstance(start, datetime): + start = date_helper.to_utc(start) + if isinstance(stop, datetime): + stop = date_helper.to_utc(stop) + predicate_request = DeletePredicateRequest(start=start, stop=stop, predicate=predicate) + return predicate_request + + class _Configuration(Configuration): def __init__(self): Configuration.__init__(self) diff --git a/influxdb_client/client/delete_api.py b/influxdb_client/client/delete_api.py index ef76339f..5f9da471 100644 --- a/influxdb_client/client/delete_api.py +++ b/influxdb_client/client/delete_api.py @@ -3,18 +3,17 @@ from datetime import datetime from typing import Union -from influxdb_client import DeleteService, DeletePredicateRequest, Organization -from influxdb_client.client.util.date_utils import get_date_helper +from influxdb_client import Organization +from influxdb_client.client._base import _BaseDeleteApi from influxdb_client.client.util.helpers import get_org_query_param -class DeleteApi(object): +class DeleteApi(_BaseDeleteApi): """Implementation for '/api/v2/delete' endpoint.""" def __init__(self, influxdb_client): """Initialize defaults.""" - self._influxdb_client = influxdb_client - self._service = DeleteService(influxdb_client.api_client) + super().__init__(influxdb_client) def delete(self, start: Union[str, datetime], stop: Union[str, datetime], predicate: str, bucket: str, org: Union[str, Organization, None] = None) -> None: @@ -30,13 +29,7 @@ def delete(self, start: Union[str, datetime], stop: Union[str, datetime], predic If not specified the default value from ``InfluxDBClient.org`` is used. :return: """ - date_helper = get_date_helper() - if isinstance(start, datetime): - start = date_helper.to_utc(start) - if isinstance(stop, datetime): - stop = date_helper.to_utc(stop) - + predicate_request = self._prepare_predicate_request(start, stop, predicate) org_param = get_org_query_param(org=org, client=self._influxdb_client, required_id=False) - predicate_request = DeletePredicateRequest(start=start, stop=stop, predicate=predicate) return self._service.post_delete(delete_predicate_request=predicate_request, bucket=bucket, org=org_param) diff --git a/influxdb_client/client/delete_api_async.py b/influxdb_client/client/delete_api_async.py new file mode 100644 index 00000000..d304b5a8 --- /dev/null +++ b/influxdb_client/client/delete_api_async.py @@ -0,0 +1,36 @@ +"""Delete time series data from InfluxDB.""" + +from datetime import datetime +from typing import Union + +from influxdb_client import Organization +from influxdb_client.client._base import _BaseDeleteApi +from influxdb_client.client.util.helpers import get_org_query_param + + +class DeleteApiAsync(_BaseDeleteApi): + """Async implementation for '/api/v2/delete' endpoint.""" + + def __init__(self, influxdb_client): + """Initialize defaults.""" + super().__init__(influxdb_client) + + async def delete(self, start: Union[str, datetime], stop: Union[str, datetime], predicate: str, bucket: str, + org: Union[str, Organization, None] = None) -> None: + """ + Delete Time series data from InfluxDB. + + :param str, datetime.datetime start: start time + :param str, datetime.datetime stop: stop time + :param str predicate: predicate + :param str bucket: bucket id or name from which data will be deleted + :param str, Organization org: specifies the organization to delete data from. + Take the ``ID``, ``Name`` or ``Organization``. + If not specified the default value from ``InfluxDBClientAsync.org`` is used. + :return: + """ + predicate_request = self._prepare_predicate_request(start, stop, predicate) + org_param = get_org_query_param(org=org, client=self._influxdb_client, required_id=False) + + return await self._service.post_delete_async(delete_predicate_request=predicate_request, bucket=bucket, + org=org_param) diff --git a/influxdb_client/client/influxdb_client_async.py b/influxdb_client/client/influxdb_client_async.py index 2f041901..8d4fdcdf 100644 --- a/influxdb_client/client/influxdb_client_async.py +++ b/influxdb_client/client/influxdb_client_async.py @@ -3,6 +3,7 @@ from influxdb_client import PingService from influxdb_client.client._base import _BaseClient +from influxdb_client.client.delete_api_async import DeleteApiAsync from influxdb_client.client.query_api import QueryOptions from influxdb_client.client.query_api_async import QueryApiAsync from influxdb_client.client.write_api import PointSettings @@ -101,3 +102,11 @@ def write_api(self, point_settings=PointSettings()) -> WriteApiAsync: :return: write api instance """ return WriteApiAsync(influxdb_client=self, point_settings=point_settings) + + def delete_api(self) -> DeleteApiAsync: + """ + Get the asynchronous delete metrics API instance. + + :return: delete api + """ + return DeleteApiAsync(self) diff --git a/influxdb_client/client/query_api_async.py b/influxdb_client/client/query_api_async.py index e6444abb..e832ddbd 100644 --- a/influxdb_client/client/query_api_async.py +++ b/influxdb_client/client/query_api_async.py @@ -28,7 +28,7 @@ async def query(self, query: str, org=None, params: dict = None) -> List['FluxTa :param query: the Flux query :param str, Organization org: specifies the organization for executing the query; Take the ``ID``, ``Name`` or ``Organization``. - If not specified the default value from ``InfluxDBClient.org`` is used. + If not specified the default value from ``InfluxDBClientAsync.org`` is used. :param params: bind parameters :return: List of FluxTable. """ @@ -48,7 +48,7 @@ async def query_stream(self, query: str, org=None, params: dict = None) -> Async :param query: the Flux query :param str, Organization org: specifies the organization for executing the query; Take the ``ID``, ``Name`` or ``Organization``. - If not specified the default value from ``InfluxDBClient.org`` is used. + If not specified the default value from ``InfluxDBClientAsync.org`` is used. :param params: bind parameters :return: AsyncGenerator['FluxRecord'] """ @@ -71,7 +71,7 @@ async def query_data_frame(self, query: str, org=None, data_frame_index: List[st :param query: the Flux query :param str, Organization org: specifies the organization for executing the query; Take the ``ID``, ``Name`` or ``Organization``. - If not specified the default value from ``InfluxDBClient.org`` is used. + If not specified the default value from ``InfluxDBClientAsync.org`` is used. :param data_frame_index: the list of columns that are used as DataFrame index :param params: bind parameters :return: DataFrame or List of DataFrames @@ -96,7 +96,7 @@ async def query_data_frame_stream(self, query: str, org=None, data_frame_index: :param query: the Flux query :param str, Organization org: specifies the organization for executing the query; Take the ``ID``, ``Name`` or ``Organization``. - If not specified the default value from ``InfluxDBClient.org`` is used. + If not specified the default value from ``InfluxDBClientAsync.org`` is used. :param data_frame_index: the list of columns that are used as DataFrame index :param params: bind parameters :return: AsyncGenerator['pd.DataFrame'] @@ -118,7 +118,7 @@ async def query_raw(self, query: str, org=None, dialect=_BaseQueryApi.default_di :param query: a Flux query :param str, Organization org: specifies the organization for executing the query; Take the ``ID``, ``Name`` or ``Organization``. - If not specified the default value from ``InfluxDBClient.org`` is used. + If not specified the default value from ``InfluxDBClientAsync.org`` is used. :param dialect: csv dialect format :param params: bind parameters :return: str diff --git a/influxdb_client/client/write_api_async.py b/influxdb_client/client/write_api_async.py index e0b23587..50381016 100644 --- a/influxdb_client/client/write_api_async.py +++ b/influxdb_client/client/write_api_async.py @@ -50,7 +50,7 @@ async def write(self, bucket: str, org: str = None, :param str bucket: specifies the destination bucket for writes (required) :param str, Organization org: specifies the destination organization for writes; take the ID, Name or Organization. - If not specified the default value from ``InfluxDBClient.org`` is used. + If not specified the default value from ``InfluxDBClientAsync.org`` is used. :param WritePrecision write_precision: specifies the precision for the unix timestamps within the body line-protocol. The precision specified on a Point has precedes and is use for write. diff --git a/tests/test_InfluxDBClientAsync.py b/tests/test_InfluxDBClientAsync.py index 301743a4..be0f01b6 100644 --- a/tests/test_InfluxDBClientAsync.py +++ b/tests/test_InfluxDBClientAsync.py @@ -47,6 +47,10 @@ def test_create_write_api(self): write_api = self.client.write_api() self.assertIsNotNone(write_api) + def test_create_delete_api(self): + delete_api = self.client.delete_api() + self.assertIsNotNone(delete_api) + @async_test async def test_query_tables(self): measurement = generate_name("measurement") @@ -170,6 +174,25 @@ async def test_write_points_different_precision(self): self.assertEqual(',,0,1970-01-01T00:00:01Z', raw.splitlines()[5]) self.assertEqual(',,0,1970-01-01T00:00:00Z', raw.splitlines()[6]) + @async_test + async def test_delete_api(self): + measurement = generate_name("measurement") + await self._prepare_data(measurement) + + await self.client.delete_api().delete(start="1970-01-01T00:00:00Z", stop=datetime.now(), predicate="location = \"Prague\"", + bucket="my-bucket") + query = f''' + from(bucket:"my-bucket") + |> range(start: -10m) + |> filter(fn: (r) => r["_measurement"] == "{measurement}") + ''' + query_api = self.client.query_api() + tables = await query_api.query(query) + self.assertEqual(1, len(tables)) + self.assertEqual(1, len(tables[0].records)) + self.assertEqual("New York", tables[0].records[0]['location']) + self.assertEqual(24.3, tables[0].records[0]['_value']) + async def _prepare_data(self, measurement: str): _point1 = Point(measurement).tag("location", "Prague").field("temperature", 25.3) _point2 = Point(measurement).tag("location", "New York").field("temperature", 24.3) From e2a5a2a6ed5cb18a1485dd0ade203f193229c741 Mon Sep 17 00:00:00 2001 From: Jakub Bednar Date: Tue, 8 Mar 2022 13:26:34 +0100 Subject: [PATCH 25/46] docs: clarify used types of queries --- examples/asynchronous.py | 16 ++++++++-------- 1 file changed, 8 insertions(+), 8 deletions(-) diff --git a/examples/asynchronous.py b/examples/asynchronous.py index c61eac77..b02e4942 100644 --- a/examples/asynchronous.py +++ b/examples/asynchronous.py @@ -25,10 +25,10 @@ async def main(): await write_api.write(bucket="my-bucket", record=[_point1, _point2]) """ - Query: using Table structure + Query: List of FluxTables """ query_api = client.query_api() - print(f"\n------- Query: using Table structure -------\n") + print(f"\n------- Query: List of FluxTables -------\n") tables = await query_api.query('from(bucket:"my-bucket") ' '|> range(start: -10m) ' '|> filter(fn: (r) => r["_measurement"] == "async_m")') @@ -38,9 +38,9 @@ async def main(): print(f'Temperature in {record["location"]} is {record["_value"]}') """ - Query: using stream FluxRecords + Query: Stream of FluxRecords """ - print(f"\n------- Query: using stream FluxRecords -------\n") + print(f"\n------- Query: Stream of FluxRecords -------\n") query_api = client.query_api() records = await query_api.query_stream('from(bucket:"my-bucket") ' '|> range(start: -10m) ' @@ -49,9 +49,9 @@ async def main(): print(record) """ - Query: using Pandas DataFrame + Query: Pandas DataFrame """ - print(f"\n------- Query: using Pandas DataFrame -------\n") + print(f"\n------- Query: Pandas DataFrame -------\n") query_api = client.query_api() dataframe = await query_api.query_data_frame('from(bucket:"my-bucket") ' '|> range(start: -10m) ' @@ -60,9 +60,9 @@ async def main(): print(dataframe) """ - Query: using raw str output + Query: String output """ - print(f"\n------- Query: using raw str output -------\n") + print(f"\n------- Query: String output -------\n") query_api = client.query_api() raw = await query_api.query_raw('from(bucket:"my-bucket") ' '|> range(start: -10m) ' From 4ed75c10936422e2654a8fa89aa84d5521310855 Mon Sep 17 00:00:00 2001 From: Jakub Bednar Date: Tue, 8 Mar 2022 13:34:50 +0100 Subject: [PATCH 26/46] chore: delete api return True for successfully written data --- examples/asynchronous.py | 13 ++++++++++++- influxdb_client/client/delete_api_async.py | 9 +++++---- tests/test_InfluxDBClientAsync.py | 5 +++-- 3 files changed, 20 insertions(+), 7 deletions(-) diff --git a/examples/asynchronous.py b/examples/asynchronous.py index b02e4942..4205d461 100644 --- a/examples/asynchronous.py +++ b/examples/asynchronous.py @@ -2,6 +2,7 @@ How to use Asyncio with InfluxDB client. """ import asyncio +from datetime import datetime from influxdb_client import Point from influxdb_client.client.influxdb_client_async import InfluxDBClientAsync @@ -19,10 +20,12 @@ async def main(): """ Prepare data """ + print(f"\n------- Write data by async API: -------\n") write_api = client.write_api() _point1 = Point("async_m").tag("location", "Prague").field("temperature", 25.3) _point2 = Point("async_m").tag("location", "New York").field("temperature", 24.3) - await write_api.write(bucket="my-bucket", record=[_point1, _point2]) + successfully = await write_api.write(bucket="my-bucket", record=[_point1, _point2]) + print(f" > successfully: {successfully}") """ Query: List of FluxTables @@ -69,6 +72,14 @@ async def main(): '|> filter(fn: (r) => r["_measurement"] == "async_m")') print(raw) + """ + Delete data + """ + print(f"\n------- Delete data with location = 'Prague' -------\n") + successfully = await client.delete_api().delete(start=datetime.utcfromtimestamp(0), stop=datetime.now(), + predicate="location = \"Prague\"", bucket="my-bucket") + print(f" > successfully: {successfully}") + if __name__ == "__main__": asyncio.run(main()) diff --git a/influxdb_client/client/delete_api_async.py b/influxdb_client/client/delete_api_async.py index d304b5a8..989a0482 100644 --- a/influxdb_client/client/delete_api_async.py +++ b/influxdb_client/client/delete_api_async.py @@ -16,7 +16,7 @@ def __init__(self, influxdb_client): super().__init__(influxdb_client) async def delete(self, start: Union[str, datetime], stop: Union[str, datetime], predicate: str, bucket: str, - org: Union[str, Organization, None] = None) -> None: + org: Union[str, Organization, None] = None) -> bool: """ Delete Time series data from InfluxDB. @@ -27,10 +27,11 @@ async def delete(self, start: Union[str, datetime], stop: Union[str, datetime], :param str, Organization org: specifies the organization to delete data from. Take the ``ID``, ``Name`` or ``Organization``. If not specified the default value from ``InfluxDBClientAsync.org`` is used. - :return: + :return: ``True`` for successfully deleted data, otherwise raise an exception """ predicate_request = self._prepare_predicate_request(start, stop, predicate) org_param = get_org_query_param(org=org, client=self._influxdb_client, required_id=False) - return await self._service.post_delete_async(delete_predicate_request=predicate_request, bucket=bucket, - org=org_param) + response = await self._service.post_delete_async(delete_predicate_request=predicate_request, bucket=bucket, + org=org_param) + return response[1] == 204 diff --git a/tests/test_InfluxDBClientAsync.py b/tests/test_InfluxDBClientAsync.py index be0f01b6..51811967 100644 --- a/tests/test_InfluxDBClientAsync.py +++ b/tests/test_InfluxDBClientAsync.py @@ -179,8 +179,9 @@ async def test_delete_api(self): measurement = generate_name("measurement") await self._prepare_data(measurement) - await self.client.delete_api().delete(start="1970-01-01T00:00:00Z", stop=datetime.now(), predicate="location = \"Prague\"", - bucket="my-bucket") + successfully = await self.client.delete_api().delete(start=datetime.utcfromtimestamp(0), stop=datetime.now(), + predicate="location = \"Prague\"", bucket="my-bucket") + self.assertEqual(True, successfully) query = f''' from(bucket:"my-bucket") |> range(start: -10m) From db3fe2f94505f8fd12e70fa7ca655c95113afc58 Mon Sep 17 00:00:00 2001 From: Jakub Bednar Date: Tue, 8 Mar 2022 14:23:47 +0100 Subject: [PATCH 27/46] docs: polish documentation --- influxdb_client/client/write/point.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/influxdb_client/client/write/point.py b/influxdb_client/client/write/point.py index b4ad29b5..a8113da9 100644 --- a/influxdb_client/client/write/point.py +++ b/influxdb_client/client/write/point.py @@ -181,7 +181,7 @@ def to_line_protocol(self, precision=None): """ Create LineProtocol. - :param precision: required precision of LineProtocol. If it's not set then use the precision from Point. + :param precision: required precision of LineProtocol. If it's not set then use the precision from ``Point``. """ _measurement = _escape_key(self._name, _ESCAPE_MEASUREMENT) _tags = _append_tags(self._tags) From 54584d05949141f5a74e7992e198de2b04dc3178 Mon Sep 17 00:00:00 2001 From: Jakub Bednar Date: Wed, 9 Mar 2022 08:07:52 +0100 Subject: [PATCH 28/46] docs: for async client --- README.rst | 137 +++++++++++++++++- .../client/influxdb_client_async.py | 2 - influxdb_client/client/query_api_async.py | 21 +-- 3 files changed, 148 insertions(+), 12 deletions(-) diff --git a/README.rst b/README.rst index f1a25ab1..a572f630 100644 --- a/README.rst +++ b/README.rst @@ -1313,7 +1313,142 @@ How to use Asyncio ^^^^^^^^^^^^^^^^^^ .. marker-asyncio-start -TBD +Starting from version 1.27.0 for Python 3.6+ the ``influxdb-client`` package supports ``async/await`` based on +`asyncio `_ and `aiohttp `_. +You can install ``aiohttp`` directly: + + .. code-block:: bash + + $ python -m pip install influxdb-client aiohttp + +or use the ``[async]`` extra: + + .. code-block:: bash + + $ python -m pip install influxdb-client[async] + +Async APIs +"""""""""" +All async APIs are available via :class:`~influxdb_client.client.influxdb_client_async.InfluxDBClientAsync`. +The ``async`` version of the client supports following asynchronous APIs: + +* :class:`~influxdb_client.client.write_api_async.WriteApiAsync` +* :class:`~influxdb_client.client.query_api_async.QueryApiAsync` +* :class:`~influxdb_client.client.delete_api_async.DeleteApiAsync` + +and also check to readiness of the InfluxDB via ``/ping`` endpoint: + + .. code-block:: python + + import asyncio + + from influxdb_client.client.influxdb_client_async import InfluxDBClientAsync + + + async def main(): + async with InfluxDBClientAsync(url="http://localhost:8086", token="my-token", org="my-org") as client: + ready = await client.ping() + print(f"InfluxDB: {ready}") + + + if __name__ == "__main__": + asyncio.run(main()) + +Async Write API +""""""""""""""" + +The :class:`~influxdb_client.client.write_api_async.WriteApiAsync` supports ingesting data as: + +* ``string`` or ``bytes`` that is formatted as a InfluxDB's line protocol +* `Data Point `__ structure +* Dictionary style mapping with keys: ``measurement``, ``tags``, ``fields`` and ``time`` or custom structure +* `NamedTuple `_ +* `Data Classes `_ +* `Pandas DataFrame `_ +* List of above items + + .. code-block:: python + + import asyncio + + from influxdb_client import Point + from influxdb_client.client.influxdb_client_async import InfluxDBClientAsync + + + async def main(): + async with InfluxDBClientAsync(url="http://localhost:8086", token="my-token", org="my-org") as client: + + write_api = client.write_api() + + _point1 = Point("async_m").tag("location", "Prague").field("temperature", 25.3) + _point2 = Point("async_m").tag("location", "New York").field("temperature", 24.3) + + successfully = await write_api.write(bucket="my-bucket", record=[_point1, _point2]) + + print(f" > successfully: {successfully}") + + + if __name__ == "__main__": + asyncio.run(main()) + + +Async Query API +""""""""""""""" + +The :class:`~influxdb_client.client.query_api_async.QueryApiAsync` supports retrieve data as: + +* List of :class:`~influxdb_client.client.flux_table.FluxTable` +* Stream of :class:`~influxdb_client.client.flux_table.FluxRecord` via :class:`~typing.AsyncGenerator` +* `Pandas DataFrame `_ +* Stream of `Pandas DataFrame `_ via :class:`~typing.AsyncGenerator` +* Raw :class:`~str` output + + .. code-block:: python + + import asyncio + + from influxdb_client.client.influxdb_client_async import InfluxDBClientAsync + + + async def main(): + async with InfluxDBClientAsync(url="http://localhost:8086", token="my-token", org="my-org") as client: + # Stream of FluxRecords + query_api = client.query_api() + records = await query_api.query_stream('from(bucket:"my-bucket") ' + '|> range(start: -10m) ' + '|> filter(fn: (r) => r["_measurement"] == "async_m")') + async for record in records: + print(record) + + + if __name__ == "__main__": + asyncio.run(main()) + + +Async Delete API +"""""""""""""""" + + .. code-block:: python + + import asyncio + from datetime import datetime + + from influxdb_client.client.influxdb_client_async import InfluxDBClientAsync + + + async def main(): + async with InfluxDBClientAsync(url="http://localhost:8086", token="my-token", org="my-org") as client: + start = datetime.utcfromtimestamp(0) + stop = datetime.now() + # Delete data with location = 'Prague' + successfully = await client.delete_api().delete(start=start, stop=stop, bucket="my-bucket", + predicate="location = \"Prague\"") + print(f" > successfully: {successfully}") + + + if __name__ == "__main__": + asyncio.run(main()) + .. marker-asyncio-end diff --git a/influxdb_client/client/influxdb_client_async.py b/influxdb_client/client/influxdb_client_async.py index 8d4fdcdf..5dc79b67 100644 --- a/influxdb_client/client/influxdb_client_async.py +++ b/influxdb_client/client/influxdb_client_async.py @@ -96,8 +96,6 @@ def write_api(self, point_settings=PointSettings()) -> WriteApiAsync: async with InfluxDBClientAsync(url="http://localhost:8086", token="my-token", org="my-org") as client: write_api = client.write_api() - If you would like to use a **background batching**, you have to configure client like this: - :param point_settings: settings to store default tags :return: write api instance """ diff --git a/influxdb_client/client/query_api_async.py b/influxdb_client/client/query_api_async.py index e832ddbd..084eeb5c 100644 --- a/influxdb_client/client/query_api_async.py +++ b/influxdb_client/client/query_api_async.py @@ -23,14 +23,15 @@ def __init__(self, influxdb_client, query_options=QueryOptions()): async def query(self, query: str, org=None, params: dict = None) -> List['FluxTable']: """ - Execute asynchronous Flux query and return result as a List['FluxTable']. + Execute asynchronous Flux query and return result as + a List[:class:`~influxdb_client.client.flux_table.FluxTable`]. :param query: the Flux query :param str, Organization org: specifies the organization for executing the query; Take the ``ID``, ``Name`` or ``Organization``. If not specified the default value from ``InfluxDBClientAsync.org`` is used. :param params: bind parameters - :return: List of FluxTable. + :return: List of :class:`~influxdb_client.client.flux_table.FluxTable`. """ org = self._org_param(org) @@ -43,14 +44,15 @@ async def query(self, query: str, org=None, params: dict = None) -> List['FluxTa async def query_stream(self, query: str, org=None, params: dict = None) -> AsyncGenerator['FluxRecord', None]: """ - Execute asynchronous Flux query and return stream of FluxRecord as an AsyncGenerator['FluxRecord']. + Execute asynchronous Flux query and return stream of :class:`~influxdb_client.client.flux_table.FluxRecord` as + an AsyncGenerator[:class:`~influxdb_client.client.flux_table.FluxRecord`]. :param query: the Flux query :param str, Organization org: specifies the organization for executing the query; Take the ``ID``, ``Name`` or ``Organization``. If not specified the default value from ``InfluxDBClientAsync.org`` is used. :param params: bind parameters - :return: AsyncGenerator['FluxRecord'] + :return: AsyncGenerator[:class:`~influxdb_client.client.flux_table.FluxRecord`] """ org = self._org_param(org) @@ -63,7 +65,7 @@ async def query_stream(self, query: str, org=None, params: dict = None) -> Async async def query_data_frame(self, query: str, org=None, data_frame_index: List[str] = None, params: dict = None): """ - Execute asynchronous Flux query and return Pandas DataFrame. + Execute asynchronous Flux query and return :class:`~pandas.core.frame.DataFrame`. Note that if a query returns tables with differing schemas than the client generates a DataFrame for each of them. @@ -74,7 +76,7 @@ async def query_data_frame(self, query: str, org=None, data_frame_index: List[st If not specified the default value from ``InfluxDBClientAsync.org`` is used. :param data_frame_index: the list of columns that are used as DataFrame index :param params: bind parameters - :return: DataFrame or List of DataFrames + :return: :class:`~pandas.core.frame.DataFrame` or List of :class:`~pandas.core.frame.DataFrame` """ _generator = await self.query_data_frame_stream(query, org=org, data_frame_index=data_frame_index, params=params) @@ -88,7 +90,8 @@ async def query_data_frame(self, query: str, org=None, data_frame_index: List[st async def query_data_frame_stream(self, query: str, org=None, data_frame_index: List[str] = None, params: dict = None): """ - Execute asynchronous Flux query and return stream of Pandas DataFrame as an AsyncGenerator['pd.DataFrame']. + Execute asynchronous Flux query and return stream of :class:`~pandas.core.frame.DataFrame` + as an AsyncGenerator[:class:`~pandas.core.frame.DataFrame`]. Note that if a query returns tables with differing schemas than the client generates a DataFrame for each of them. @@ -99,7 +102,7 @@ async def query_data_frame_stream(self, query: str, org=None, data_frame_index: If not specified the default value from ``InfluxDBClientAsync.org`` is used. :param data_frame_index: the list of columns that are used as DataFrame index :param params: bind parameters - :return: AsyncGenerator['pd.DataFrame'] + :return: AsyncGenerator[:class:`~pandas.core.frame.DataFrame`] """ org = self._org_param(org) @@ -121,7 +124,7 @@ async def query_raw(self, query: str, org=None, dialect=_BaseQueryApi.default_di If not specified the default value from ``InfluxDBClientAsync.org`` is used. :param dialect: csv dialect format :param params: bind parameters - :return: str + :return: :class:`~str` """ org = self._org_param(org) result = await self._query_api.post_query_async(org=org, query=self._create_query(query, dialect, params), From 4200f048240b5bb00b0563632d30c3a803cff766 Mon Sep 17 00:00:00 2001 From: Jakub Bednar Date: Wed, 9 Mar 2022 08:16:21 +0100 Subject: [PATCH 29/46] fix: code style --- influxdb_client/client/query_api_async.py | 15 ++++++--------- 1 file changed, 6 insertions(+), 9 deletions(-) diff --git a/influxdb_client/client/query_api_async.py b/influxdb_client/client/query_api_async.py index 084eeb5c..b8746fb1 100644 --- a/influxdb_client/client/query_api_async.py +++ b/influxdb_client/client/query_api_async.py @@ -23,8 +23,7 @@ def __init__(self, influxdb_client, query_options=QueryOptions()): async def query(self, query: str, org=None, params: dict = None) -> List['FluxTable']: """ - Execute asynchronous Flux query and return result as - a List[:class:`~influxdb_client.client.flux_table.FluxTable`]. + Execute asynchronous Flux query and return result as a List[:class:`~influxdb_client.client.flux_table.FluxTable`]. :param query: the Flux query :param str, Organization org: specifies the organization for executing the query; @@ -32,7 +31,7 @@ async def query(self, query: str, org=None, params: dict = None) -> List['FluxTa If not specified the default value from ``InfluxDBClientAsync.org`` is used. :param params: bind parameters :return: List of :class:`~influxdb_client.client.flux_table.FluxTable`. - """ + """ # noqa: E501 org = self._org_param(org) response = await self._query_api.post_query_async(org=org, @@ -44,8 +43,7 @@ async def query(self, query: str, org=None, params: dict = None) -> List['FluxTa async def query_stream(self, query: str, org=None, params: dict = None) -> AsyncGenerator['FluxRecord', None]: """ - Execute asynchronous Flux query and return stream of :class:`~influxdb_client.client.flux_table.FluxRecord` as - an AsyncGenerator[:class:`~influxdb_client.client.flux_table.FluxRecord`]. + Execute asynchronous Flux query and return stream of :class:`~influxdb_client.client.flux_table.FluxRecord` as an AsyncGenerator[:class:`~influxdb_client.client.flux_table.FluxRecord`]. :param query: the Flux query :param str, Organization org: specifies the organization for executing the query; @@ -53,7 +51,7 @@ async def query_stream(self, query: str, org=None, params: dict = None) -> Async If not specified the default value from ``InfluxDBClientAsync.org`` is used. :param params: bind parameters :return: AsyncGenerator[:class:`~influxdb_client.client.flux_table.FluxRecord`] - """ + """ # noqa: E501 org = self._org_param(org) response = await self._query_api.post_query_async(org=org, @@ -90,8 +88,7 @@ async def query_data_frame(self, query: str, org=None, data_frame_index: List[st async def query_data_frame_stream(self, query: str, org=None, data_frame_index: List[str] = None, params: dict = None): """ - Execute asynchronous Flux query and return stream of :class:`~pandas.core.frame.DataFrame` - as an AsyncGenerator[:class:`~pandas.core.frame.DataFrame`]. + Execute asynchronous Flux query and return stream of :class:`~pandas.core.frame.DataFrame` as an AsyncGenerator[:class:`~pandas.core.frame.DataFrame`]. Note that if a query returns tables with differing schemas than the client generates a DataFrame for each of them. @@ -103,7 +100,7 @@ async def query_data_frame_stream(self, query: str, org=None, data_frame_index: :param data_frame_index: the list of columns that are used as DataFrame index :param params: bind parameters :return: AsyncGenerator[:class:`~pandas.core.frame.DataFrame`] - """ + """ # noqa: E501 org = self._org_param(org) response = await self._query_api.post_query_async(org=org, From ba4d57bb48dcfedb24fdd630b13799e09f18e489 Mon Sep 17 00:00:00 2001 From: Jakub Bednar Date: Wed, 9 Mar 2022 08:20:54 +0100 Subject: [PATCH 30/46] docs: update CHANGELOG.md --- CHANGELOG.md | 1 + 1 file changed, 1 insertion(+) diff --git a/CHANGELOG.md b/CHANGELOG.md index cdece1dd..112e85d3 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -4,6 +4,7 @@ 1. [#412](https://github.com/influxdata/influxdb-client-python/pull/412): `DeleteApi` uses default value from `InfluxDBClient.org` if an `org` parameter is not specified 1. [#405](https://github.com/influxdata/influxdb-client-python/pull/405): Add `InfluxLoggingHandler`. A handler to use the client in native python logging. 1. [#404](https://github.com/influxdata/influxdb-client-python/pull/404): Add `InvocableScriptsApi` to create, update, list, delete and invoke scripts by seamless way +1. [#413](https://github.com/influxdata/influxdb-client-python/pull/413): Add support for `async/await` with asyncio via `InfluxDBClientAsync`, for more info see: **How to use Asyncio** ### CI 1. [#411](https://github.com/influxdata/influxdb-client-python/pull/411): Use new Codecov uploader for reporting code coverage From 15a2bd4abbee435ec23191e8afcb021c8dc01a9b Mon Sep 17 00:00:00 2001 From: Jakub Bednar Date: Wed, 9 Mar 2022 09:11:28 +0100 Subject: [PATCH 31/46] fix: check twine --- setup.py | 7 ++++++- 1 file changed, 6 insertions(+), 1 deletion(-) diff --git a/setup.py b/setup.py index 785f1f42..d69d3560 100644 --- a/setup.py +++ b/setup.py @@ -39,7 +39,12 @@ ] with open('README.rst', 'r') as f: - readme = f.read() + # Remove `class` text role as it's not allowed on PyPI + lines = [] + for line in f: + lines.append(line.replace(":class:`~", "`")) + + readme = "".join(lines) NAME = "influxdb_client" From e62f8a5672160d41d615e8d21a0efbef0803d95b Mon Sep 17 00:00:00 2001 From: Jakub Bednar Date: Thu, 10 Mar 2022 09:15:30 +0100 Subject: [PATCH 32/46] feat: implement debug logging for async client --- influxdb_client/_async/rest.py | 36 ++++++++++++++++++- influxdb_client/client/_base.py | 10 +++--- influxdb_client/client/flux_csv_parser.py | 7 ++-- .../client/influxdb_client_async.py | 5 +-- influxdb_client/client/query_api_async.py | 5 +-- influxdb_client/client/write_api.py | 3 +- influxdb_client/rest.py | 2 ++ 7 files changed, 53 insertions(+), 15 deletions(-) diff --git a/influxdb_client/_async/rest.py b/influxdb_client/_async/rest.py index 50c79d19..47c496ba 100644 --- a/influxdb_client/_async/rest.py +++ b/influxdb_client/_async/rest.py @@ -19,10 +19,37 @@ from six.moves.urllib.parse import urlencode from influxdb_client.rest import ApiException +from influxdb_client.rest import _UTF_8_encoding logger = logging.getLogger(__name__) +async def _on_request_start(session, trace_config_ctx, params): + print(f">>> Request: '{params.method} {params.url}'") + print(f">>> Headers: '{params.headers}'") + + +async def _on_request_chunk_sent(session, context, params): + if params.chunk: + print(f">>> Body: {params.chunk}") + + +async def _on_request_end(session, trace_config_ctx, params): + print(f"<<< Response: {params.response.status}") + print(f"<<< Headers: '{params.response.headers}") + + response_content = params.response.content + data = bytearray() + while True: + chunk = await response_content.read(100) + if not chunk: + break + data += chunk + if data: + print(f"<<< Body: {data.decode(_UTF_8_encoding)}") + response_content.unread_data(data=data) + + class RESTResponseAsync(io.IOBase): """NOTE: This class is auto generated by OpenAPI Generator. @@ -77,10 +104,17 @@ def __init__(self, configuration, pools_size=4, maxsize=None): self.proxy = configuration.proxy self.proxy_headers = configuration.proxy_headers + # configure tracing + trace_config = aiohttp.TraceConfig() + trace_config.on_request_start.append(_on_request_start) + trace_config.on_request_chunk_sent.append(_on_request_chunk_sent) + trace_config.on_request_end.append(_on_request_end) + # https pool manager self.pool_manager = aiohttp.ClientSession( connector=connector, - trust_env=True + trust_env=True, + trace_configs=[trace_config] if configuration.debug else None ) async def close(self): diff --git a/influxdb_client/client/_base.py b/influxdb_client/client/_base.py index 3ea977ec..9db717c5 100644 --- a/influxdb_client/client/_base.py +++ b/influxdb_client/client/_base.py @@ -13,12 +13,12 @@ Expression, BooleanLiteral, IntegerLiteral, FloatLiteral, DateTimeLiteral, UnaryExpression, DurationLiteral, \ Duration, StringLiteral, ArrayExpression, ImportDeclaration, MemberExpression, MemberAssignment, File, \ WriteService, QueryService, DeleteService, DeletePredicateRequest -from influxdb_client.client.flux_csv_parser import FluxResponseMetadataMode, FluxCsvParser, FluxSerializationMode, \ - _CSV_ENCODING +from influxdb_client.client.flux_csv_parser import FluxResponseMetadataMode, FluxCsvParser, FluxSerializationMode from influxdb_client.client.flux_table import FluxTable, FluxRecord from influxdb_client.client.util.date_utils import get_date_helper from influxdb_client.client.util.helpers import get_org_query_param from influxdb_client.client.write.dataframe_serializer import DataframeSerializer +from influxdb_client.rest import _UTF_8_encoding try: import dataclasses @@ -111,7 +111,7 @@ async def _to_tables_async(self, response, query_options=None, response_metadata def _to_csv(self, response: HTTPResponse) -> Iterator[List[str]]: """Parse HTTP response to CSV.""" - return csv.reader(codecs.iterdecode(response, _CSV_ENCODING)) + return csv.reader(codecs.iterdecode(response, _UTF_8_encoding)) def _to_flux_record_stream(self, response, query_options=None, response_metadata_mode: FluxResponseMetadataMode = FluxResponseMetadataMode.full) -> \ @@ -318,7 +318,7 @@ def _serialize(self, record, write_precision, payload, **kwargs): payload[write_precision].append(record) elif isinstance(record, str): - self._serialize(record.encode("utf-8"), write_precision, payload, **kwargs) + self._serialize(record.encode(_UTF_8_encoding), write_precision, payload, **kwargs) elif isinstance(record, Point): precision_from_point = kwargs.get('precision_from_point', True) @@ -387,6 +387,6 @@ def update_request_body(self, path: str, body): if isinstance(_body, bytes): return gzip.compress(data=_body) else: - return gzip.compress(bytes(_body, "utf-8")) + return gzip.compress(bytes(_body, _UTF_8_encoding)) return _body diff --git a/influxdb_client/client/flux_csv_parser.py b/influxdb_client/client/flux_csv_parser.py index c5d03d19..72330689 100644 --- a/influxdb_client/client/flux_csv_parser.py +++ b/influxdb_client/client/flux_csv_parser.py @@ -9,8 +9,7 @@ from influxdb_client.client.flux_table import FluxTable, FluxColumn, FluxRecord from influxdb_client.client.util.date_utils import get_date_helper - -_CSV_ENCODING = 'utf-8' +from influxdb_client.rest import _UTF_8_encoding ANNOTATION_DEFAULT = "#default" ANNOTATION_GROUP = "#group" @@ -86,7 +85,7 @@ def _close(self): def __enter__(self): """Initialize CSV reader.""" - self._reader = csv_parser.reader(codecs.iterdecode(self._response, _CSV_ENCODING)) + self._reader = csv_parser.reader(codecs.iterdecode(self._response, _UTF_8_encoding)) return self def __exit__(self, exc_type, exc_val, exc_tb): @@ -131,7 +130,7 @@ async def _parse_flux_response_async(self): try: async for line in self._reader: - csv = list(csv_parser.reader([line.decode(_CSV_ENCODING)])) + csv = list(csv_parser.reader([line.decode(_UTF_8_encoding)])) if len(csv) >= 1: for val in self._parse_flux_response_row(metadata, csv[0]): yield val diff --git a/influxdb_client/client/influxdb_client_async.py b/influxdb_client/client/influxdb_client_async.py index 5dc79b67..6243b07a 100644 --- a/influxdb_client/client/influxdb_client_async.py +++ b/influxdb_client/client/influxdb_client_async.py @@ -15,15 +15,16 @@ class InfluxDBClientAsync(_BaseClient): """InfluxDBClientAsync is client for InfluxDB v2.""" - def __init__(self, url, token, org: str = None, **kwargs) -> None: + def __init__(self, url, token, org: str = None, debug=None, **kwargs) -> None: """ Initialize defaults. :param url: InfluxDB server API url (ex. http://localhost:8086). :param token: auth token :param org: organization name (used as a default in Query, Write and Delete API) + :param debug: enable verbose logging of http requests """ - super().__init__(url=url, token=token, org=org, **kwargs) + super().__init__(url=url, token=token, org=org, debug=debug, **kwargs) from .._async.api_client import ApiClientAsync self.api_client = ApiClientAsync(configuration=self.conf, header_name=self.auth_header_name, diff --git a/influxdb_client/client/query_api_async.py b/influxdb_client/client/query_api_async.py index b8746fb1..c0c06bae 100644 --- a/influxdb_client/client/query_api_async.py +++ b/influxdb_client/client/query_api_async.py @@ -5,9 +5,10 @@ """ from typing import List, AsyncGenerator -from influxdb_client.client._base import _BaseQueryApi, _CSV_ENCODING +from influxdb_client.client._base import _BaseQueryApi from influxdb_client.client.flux_table import FluxTable, FluxRecord from influxdb_client.client.query_api import QueryOptions +from influxdb_client.rest import _UTF_8_encoding class QueryApiAsync(_BaseQueryApi): @@ -128,4 +129,4 @@ async def query_raw(self, query: str, org=None, dialect=_BaseQueryApi.default_di async_req=False, _preload_content=False, _return_http_data_only=True) raw_bytes = await result.read() - return raw_bytes.decode(_CSV_ENCODING) + return raw_bytes.decode(_UTF_8_encoding) diff --git a/influxdb_client/client/write_api.py b/influxdb_client/client/write_api.py index 12a3e865..48c8d3d5 100644 --- a/influxdb_client/client/write_api.py +++ b/influxdb_client/client/write_api.py @@ -21,6 +21,7 @@ from influxdb_client.client.write.dataframe_serializer import DataframeSerializer from influxdb_client.client.write.point import Point, DEFAULT_WRITE_PRECISION from influxdb_client.client.write.retry import WritesRetry +from influxdb_client.rest import _UTF_8_encoding logger = logging.getLogger(__name__) @@ -411,7 +412,7 @@ def _write_batching(self, bucket, org, data, self._subject.on_next(_BatchItem(key=_key, data=data)) elif isinstance(data, str): - self._write_batching(bucket, org, data.encode("utf-8"), + self._write_batching(bucket, org, data.encode(_UTF_8_encoding), precision, **kwargs) elif isinstance(data, Point): diff --git a/influxdb_client/rest.py b/influxdb_client/rest.py index f348d9b1..9bff5a72 100644 --- a/influxdb_client/rest.py +++ b/influxdb_client/rest.py @@ -14,6 +14,8 @@ from influxdb_client.client.exceptions import InfluxDBError +_UTF_8_encoding = 'utf-8' + class ApiException(InfluxDBError): """NOTE: This class is auto generated by OpenAPI Generator. From e40611cdc78f504c7b31548510cbfb397c909f72 Mon Sep 17 00:00:00 2001 From: Jakub Bednar Date: Thu, 10 Mar 2022 10:06:14 +0100 Subject: [PATCH 33/46] feat: implement timeout for async client --- influxdb_client/_async/rest.py | 12 ++++++++++-- influxdb_client/client/influxdb_client_async.py | 7 +++++-- 2 files changed, 15 insertions(+), 4 deletions(-) diff --git a/influxdb_client/_async/rest.py b/influxdb_client/_async/rest.py index 47c496ba..4fc87b1d 100644 --- a/influxdb_client/_async/rest.py +++ b/influxdb_client/_async/rest.py @@ -16,6 +16,7 @@ import aiohttp # python 2 and python 3 compatibility library +import six from six.moves.urllib.parse import urlencode from influxdb_client.rest import ApiException @@ -110,10 +111,19 @@ def __init__(self, configuration, pools_size=4, maxsize=None): trace_config.on_request_chunk_sent.append(_on_request_chunk_sent) trace_config.on_request_end.append(_on_request_end) + # timeout + if isinstance(configuration.timeout, (int, float,) if six.PY3 else (int, long, float,)): # noqa: E501,F821 + timeout = aiohttp.ClientTimeout(total=configuration.timeout / 1_000) + elif isinstance(configuration.timeout, aiohttp.ClientTimeout): + timeout = configuration.timeout + else: + timeout = aiohttp.client.DEFAULT_TIMEOUT + # https pool manager self.pool_manager = aiohttp.ClientSession( connector=connector, trust_env=True, + timeout=timeout, trace_configs=[trace_config] if configuration.debug else None ) @@ -152,7 +162,6 @@ async def request(self, method, url, query_params=None, headers=None, post_params = post_params or {} headers = headers or {} - timeout = _request_timeout or 5 * 60 if 'Content-Type' not in headers: headers['Content-Type'] = 'application/json' @@ -160,7 +169,6 @@ async def request(self, method, url, query_params=None, headers=None, args = { "method": method, "url": url, - "timeout": timeout, "headers": headers } diff --git a/influxdb_client/client/influxdb_client_async.py b/influxdb_client/client/influxdb_client_async.py index 6243b07a..2ff92ae2 100644 --- a/influxdb_client/client/influxdb_client_async.py +++ b/influxdb_client/client/influxdb_client_async.py @@ -15,7 +15,7 @@ class InfluxDBClientAsync(_BaseClient): """InfluxDBClientAsync is client for InfluxDB v2.""" - def __init__(self, url, token, org: str = None, debug=None, **kwargs) -> None: + def __init__(self, url, token, org: str = None, debug=None, timeout=10_000, **kwargs) -> None: """ Initialize defaults. @@ -23,8 +23,11 @@ def __init__(self, url, token, org: str = None, debug=None, **kwargs) -> None: :param token: auth token :param org: organization name (used as a default in Query, Write and Delete API) :param debug: enable verbose logging of http requests + :param timeout: The maximal number of milliseconds for the whole HTTP request including + connection establishment, request sending and response reading. + It can also be a :class:`~aiohttp.ClientTimeout` which is directly pass to ``aiohttp``. """ - super().__init__(url=url, token=token, org=org, debug=debug, **kwargs) + super().__init__(url=url, token=token, org=org, debug=debug, timeout=timeout, **kwargs) from .._async.api_client import ApiClientAsync self.api_client = ApiClientAsync(configuration=self.conf, header_name=self.auth_header_name, From f032e052d8f583fdc6864c2a8ba1296207070273 Mon Sep 17 00:00:00 2001 From: Jakub Bednar Date: Thu, 10 Mar 2022 12:46:24 +0100 Subject: [PATCH 34/46] feat: implement gzip for async client --- influxdb_client/client/influxdb_client_async.py | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/influxdb_client/client/influxdb_client_async.py b/influxdb_client/client/influxdb_client_async.py index 2ff92ae2..e512ab81 100644 --- a/influxdb_client/client/influxdb_client_async.py +++ b/influxdb_client/client/influxdb_client_async.py @@ -15,7 +15,7 @@ class InfluxDBClientAsync(_BaseClient): """InfluxDBClientAsync is client for InfluxDB v2.""" - def __init__(self, url, token, org: str = None, debug=None, timeout=10_000, **kwargs) -> None: + def __init__(self, url, token, org: str = None, debug=None, timeout=10_000, enable_gzip=False, **kwargs) -> None: """ Initialize defaults. @@ -26,8 +26,10 @@ def __init__(self, url, token, org: str = None, debug=None, timeout=10_000, **kw :param timeout: The maximal number of milliseconds for the whole HTTP request including connection establishment, request sending and response reading. It can also be a :class:`~aiohttp.ClientTimeout` which is directly pass to ``aiohttp``. + :param enable_gzip: Enable Gzip compression for http requests. Currently, only the "Write" and "Query" endpoints + supports the Gzip compression. """ - super().__init__(url=url, token=token, org=org, debug=debug, timeout=timeout, **kwargs) + super().__init__(url=url, token=token, org=org, debug=debug, timeout=timeout, enable_gzip=enable_gzip, **kwargs) from .._async.api_client import ApiClientAsync self.api_client = ApiClientAsync(configuration=self.conf, header_name=self.auth_header_name, From 518f08d4fda1a914f8e33228356bff839807ee4f Mon Sep 17 00:00:00 2001 From: Jakub Bednar Date: Thu, 10 Mar 2022 13:20:27 +0100 Subject: [PATCH 35/46] docs: document features --- influxdb_client/client/influxdb_client_async.py | 11 +++++++++++ 1 file changed, 11 insertions(+) diff --git a/influxdb_client/client/influxdb_client_async.py b/influxdb_client/client/influxdb_client_async.py index e512ab81..9270f7eb 100644 --- a/influxdb_client/client/influxdb_client_async.py +++ b/influxdb_client/client/influxdb_client_async.py @@ -28,6 +28,17 @@ def __init__(self, url, token, org: str = None, debug=None, timeout=10_000, enab It can also be a :class:`~aiohttp.ClientTimeout` which is directly pass to ``aiohttp``. :param enable_gzip: Enable Gzip compression for http requests. Currently, only the "Write" and "Query" endpoints supports the Gzip compression. + :key bool verify_ssl: Set this to false to skip verifying SSL certificate when calling API from https server. + :key str ssl_ca_cert: Set this to customize the certificate file to verify the peer. + :key str proxy: Set this to configure the http proxy to be used (ex. http://localhost:3128) + :key str proxy_headers: A dictionary containing headers that will be sent to the proxy. Could be used for proxy + authentication. + :key int connection_pool_maxsize: The total number of simultaneous connections. + Defaults to "multiprocessing.cpu_count() * 5". + :key bool auth_basic: Set this to true to enable basic authentication when talking to a InfluxDB 1.8.x that + does not use auth-enabled but is protected by a reverse proxy with basic authentication. + (defaults to false, don't set to true when talking to InfluxDB 2) + :key list[str] profilers: list of enabled Flux profilers """ super().__init__(url=url, token=token, org=org, debug=debug, timeout=timeout, enable_gzip=enable_gzip, **kwargs) From b3ed1640c94a818363faea6cce75f7ebb11a6dfa Mon Sep 17 00:00:00 2001 From: Jakub Bednar Date: Thu, 10 Mar 2022 13:57:18 +0100 Subject: [PATCH 36/46] feat: add initialization from config and env variables --- influxdb_client/client/_base.py | 90 +++++++++++++++++++ influxdb_client/client/influxdb_client.py | 89 ++---------------- .../client/influxdb_client_async.py | 79 ++++++++++++++++ tests/test_InfluxDBClientAsync.py | 38 +++++++- 4 files changed, 208 insertions(+), 88 deletions(-) diff --git a/influxdb_client/client/_base.py b/influxdb_client/client/_base.py index 9db717c5..4130d04e 100644 --- a/influxdb_client/client/_base.py +++ b/influxdb_client/client/_base.py @@ -3,7 +3,9 @@ import base64 import codecs +import configparser import csv +import os from datetime import datetime, timedelta from typing import Iterator, List, Generator, Any, Union, Iterable, AsyncGenerator @@ -72,6 +74,86 @@ def _version(self, response) -> str: return "unknown" + @classmethod + def _from_config_file(cls, config_file: str = "config.ini", debug=None, enable_gzip=False): + config = configparser.ConfigParser() + config.read(config_file) + + def config_value(key: str): + return config['influx2'][key].strip('"') + + url = config_value('url') + token = config_value('token') + + timeout = None + if config.has_option('influx2', 'timeout'): + timeout = config_value('timeout') + + org = None + if config.has_option('influx2', 'org'): + org = config_value('org') + + verify_ssl = True + if config.has_option('influx2', 'verify_ssl'): + verify_ssl = config_value('verify_ssl') + + ssl_ca_cert = None + if config.has_option('influx2', 'ssl_ca_cert'): + ssl_ca_cert = config_value('ssl_ca_cert') + + connection_pool_maxsize = None + if config.has_option('influx2', 'connection_pool_maxsize'): + connection_pool_maxsize = config_value('connection_pool_maxsize') + + auth_basic = False + if config.has_option('influx2', 'auth_basic'): + auth_basic = config_value('auth_basic') + + default_tags = None + if config.has_section('tags'): + tags = {k: v.strip('"') for k, v in config.items('tags')} + default_tags = dict(tags) + + profilers = None + if config.has_option('influx2', 'profilers'): + profilers = [x.strip() for x in config_value('profilers').split(',')] + + proxy = None + if config.has_option('influx2', 'proxy'): + proxy = config_value('proxy') + + return cls(url, token, debug=debug, timeout=_to_int(timeout), org=org, default_tags=default_tags, + enable_gzip=enable_gzip, verify_ssl=_to_bool(verify_ssl), ssl_ca_cert=ssl_ca_cert, + connection_pool_maxsize=_to_int(connection_pool_maxsize), auth_basic=_to_bool(auth_basic), + profilers=profilers, proxy=proxy) + + @classmethod + def _from_env_properties(cls, debug=None, enable_gzip=False): + url = os.getenv('INFLUXDB_V2_URL', "http://localhost:8086") + token = os.getenv('INFLUXDB_V2_TOKEN', "my-token") + timeout = os.getenv('INFLUXDB_V2_TIMEOUT', "10000") + org = os.getenv('INFLUXDB_V2_ORG', "my-org") + verify_ssl = os.getenv('INFLUXDB_V2_VERIFY_SSL', "True") + ssl_ca_cert = os.getenv('INFLUXDB_V2_SSL_CA_CERT', None) + connection_pool_maxsize = os.getenv('INFLUXDB_V2_CONNECTION_POOL_MAXSIZE', None) + auth_basic = os.getenv('INFLUXDB_V2_AUTH_BASIC', "False") + + prof = os.getenv("INFLUXDB_V2_PROFILERS", None) + profilers = None + if prof is not None: + profilers = [x.strip() for x in prof.split(',')] + + default_tags = dict() + + for key, value in os.environ.items(): + if key.startswith("INFLUXDB_V2_TAG_"): + default_tags[key[16:].lower()] = value + + return cls(url, token, debug=debug, timeout=_to_int(timeout), org=org, default_tags=default_tags, + enable_gzip=enable_gzip, verify_ssl=_to_bool(verify_ssl), ssl_ca_cert=ssl_ca_cert, + connection_pool_maxsize=_to_int(connection_pool_maxsize), auth_basic=_to_bool(auth_basic), + profilers=profilers) + # noinspection PyMethodMayBeStatic class _BaseQueryApi(object): @@ -390,3 +472,11 @@ def update_request_body(self, path: str, body): return gzip.compress(bytes(_body, _UTF_8_encoding)) return _body + + +def _to_bool(bool_value): + return str(bool_value).lower() in ("yes", "true") + + +def _to_int(int_value): + return int(int_value) if int_value is not None else None diff --git a/influxdb_client/client/influxdb_client.py b/influxdb_client/client/influxdb_client.py index 731110c0..413bcb21 100644 --- a/influxdb_client/client/influxdb_client.py +++ b/influxdb_client/client/influxdb_client.py @@ -2,9 +2,7 @@ from __future__ import absolute_import -import configparser import logging -import os import warnings from influxdb_client import HealthCheck, HealthService, Ready, ReadyService, PingService, \ @@ -133,56 +131,8 @@ def from_config_file(cls, config_file: str = "config.ini", debug=None, enable_gz data_center = "${env.data_center}" """ - config = configparser.ConfigParser() - config.read(config_file) - - def config_value(key: str): - return config['influx2'][key].strip('"') - - url = config_value('url') - token = config_value('token') - - timeout = None - if config.has_option('influx2', 'timeout'): - timeout = config_value('timeout') - - org = None - if config.has_option('influx2', 'org'): - org = config_value('org') - - verify_ssl = True - if config.has_option('influx2', 'verify_ssl'): - verify_ssl = config_value('verify_ssl') - - ssl_ca_cert = None - if config.has_option('influx2', 'ssl_ca_cert'): - ssl_ca_cert = config_value('ssl_ca_cert') - - connection_pool_maxsize = None - if config.has_option('influx2', 'connection_pool_maxsize'): - connection_pool_maxsize = config_value('connection_pool_maxsize') - - auth_basic = False - if config.has_option('influx2', 'auth_basic'): - auth_basic = config_value('auth_basic') - - default_tags = None - if config.has_section('tags'): - tags = {k: v.strip('"') for k, v in config.items('tags')} - default_tags = dict(tags) - - profilers = None - if config.has_option('influx2', 'profilers'): - profilers = [x.strip() for x in config_value('profilers').split(',')] - - proxy = None - if config.has_option('influx2', 'proxy'): - proxy = config_value('proxy') - - return cls(url, token, debug=debug, timeout=_to_int(timeout), org=org, default_tags=default_tags, - enable_gzip=enable_gzip, verify_ssl=_to_bool(verify_ssl), ssl_ca_cert=ssl_ca_cert, - connection_pool_maxsize=_to_int(connection_pool_maxsize), auth_basic=_to_bool(auth_basic), - profilers=profilers, proxy=proxy) + return super(InfluxDBClient, cls)._from_config_file(config_file=config_file, debug=debug, + enable_gzip=enable_gzip) @classmethod def from_env_properties(cls, debug=None, enable_gzip=False): @@ -198,31 +148,10 @@ def from_env_properties(cls, debug=None, enable_gzip=False): - INFLUXDB_V2_SSL_CA_CERT - INFLUXDB_V2_CONNECTION_POOL_MAXSIZE - INFLUXDB_V2_AUTH_BASIC + - INFLUXDB_V2_PROFILERS + - INFLUXDB_V2_TAG """ - url = os.getenv('INFLUXDB_V2_URL', "http://localhost:8086") - token = os.getenv('INFLUXDB_V2_TOKEN', "my-token") - timeout = os.getenv('INFLUXDB_V2_TIMEOUT', "10000") - org = os.getenv('INFLUXDB_V2_ORG', "my-org") - verify_ssl = os.getenv('INFLUXDB_V2_VERIFY_SSL', "True") - ssl_ca_cert = os.getenv('INFLUXDB_V2_SSL_CA_CERT', None) - connection_pool_maxsize = os.getenv('INFLUXDB_V2_CONNECTION_POOL_MAXSIZE', None) - auth_basic = os.getenv('INFLUXDB_V2_AUTH_BASIC', "False") - - prof = os.getenv("INFLUXDB_V2_PROFILERS", None) - profilers = None - if prof is not None: - profilers = [x.strip() for x in prof.split(',')] - - default_tags = dict() - - for key, value in os.environ.items(): - if key.startswith("INFLUXDB_V2_TAG_"): - default_tags[key[16:].lower()] = value - - return cls(url, token, debug=debug, timeout=_to_int(timeout), org=org, default_tags=default_tags, - enable_gzip=enable_gzip, verify_ssl=_to_bool(verify_ssl), ssl_ca_cert=ssl_ca_cert, - connection_pool_maxsize=_to_int(connection_pool_maxsize), auth_basic=_to_bool(auth_basic), - profilers=profilers) + return super(InfluxDBClient, cls)._from_env_properties(debug=debug, enable_gzip=enable_gzip) def write_api(self, write_options=WriteOptions(), point_settings=PointSettings(), **kwargs) -> WriteApi: """ @@ -440,11 +369,3 @@ def delete_api(self) -> DeleteApi: :return: delete api """ return DeleteApi(self) - - -def _to_bool(bool_value): - return str(bool_value).lower() in ("yes", "true") - - -def _to_int(int_value): - return int(int_value) if int_value is not None else None diff --git a/influxdb_client/client/influxdb_client_async.py b/influxdb_client/client/influxdb_client_async.py index 9270f7eb..77270cda 100644 --- a/influxdb_client/client/influxdb_client_async.py +++ b/influxdb_client/client/influxdb_client_async.py @@ -64,6 +64,85 @@ async def close(self): await self.api_client.close() self.api_client = None + @classmethod + def from_config_file(cls, config_file: str = "config.ini", debug=None, enable_gzip=False): + """ + Configure client via configuration file. The configuration has to be under 'influx' section. + + The supported formats: + - https://docs.python.org/3/library/configparser.html + - https://toml.io/en/ + + Configuration options: + - url + - org + - token + - timeout, + - verify_ssl + - ssl_ca_cert + - connection_pool_maxsize + - auth_basic + - profilers + - proxy + + + config.ini example:: + + [influx2] + url=http://localhost:8086 + org=my-org + token=my-token + timeout=6000 + connection_pool_maxsize=25 + auth_basic=false + profilers=query,operator + proxy=http:proxy.domain.org:8080 + + [tags] + id = 132-987-655 + customer = California Miner + data_center = ${env.data_center} + + config.toml example:: + + [influx2] + url = "http://localhost:8086" + token = "my-token" + org = "my-org" + timeout = 6000 + connection_pool_maxsize = 25 + auth_basic = false + profilers="query, operator" + proxy = "http://proxy.domain.org:8080" + + [tags] + id = "132-987-655" + customer = "California Miner" + data_center = "${env.data_center}" + + """ + return super(InfluxDBClientAsync, cls)._from_config_file(config_file=config_file, debug=debug, + enable_gzip=enable_gzip) + + @classmethod + def from_env_properties(cls, debug=None, enable_gzip=False): + """ + Configure client via environment properties. + + Supported environment properties: + - INFLUXDB_V2_URL + - INFLUXDB_V2_ORG + - INFLUXDB_V2_TOKEN + - INFLUXDB_V2_TIMEOUT + - INFLUXDB_V2_VERIFY_SSL + - INFLUXDB_V2_SSL_CA_CERT + - INFLUXDB_V2_CONNECTION_POOL_MAXSIZE + - INFLUXDB_V2_AUTH_BASIC + - INFLUXDB_V2_PROFILERS + - INFLUXDB_V2_TAG + """ + return super(InfluxDBClientAsync, cls)._from_env_properties(debug=debug, enable_gzip=enable_gzip) + async def ping(self) -> bool: """ Return the status of InfluxDB instance. diff --git a/tests/test_InfluxDBClientAsync.py b/tests/test_InfluxDBClientAsync.py index 51811967..a21a54a3 100644 --- a/tests/test_InfluxDBClientAsync.py +++ b/tests/test_InfluxDBClientAsync.py @@ -1,5 +1,6 @@ import asyncio import unittest +import os from datetime import datetime from influxdb_client import Point, WritePrecision @@ -194,7 +195,36 @@ async def test_delete_api(self): self.assertEqual("New York", tables[0].records[0]['location']) self.assertEqual(24.3, tables[0].records[0]['_value']) - async def _prepare_data(self, measurement: str): - _point1 = Point(measurement).tag("location", "Prague").field("temperature", 25.3) - _point2 = Point(measurement).tag("location", "New York").field("temperature", 24.3) - await self.client.write_api().write(bucket="my-bucket", record=[_point1, _point2]) + @async_test + async def test_init_from_ini_file(self): + client_from_config = InfluxDBClientAsync.from_config_file(f'{os.path.dirname(__file__)}/config.ini') + self.assertEqual("http://localhost:8086", client_from_config.url) + self.assertEqual("my-org", client_from_config.org) + self.assertEqual("my-token", client_from_config.token) + self.assertEqual(6000, client_from_config.api_client.configuration.timeout) + self.assertEqual(3, len(client_from_config.default_tags)) + self.assertEqual("132-987-655", client_from_config.default_tags["id"]) + self.assertEqual("California Miner", client_from_config.default_tags["customer"]) + self.assertEqual("${env.data_center}", client_from_config.default_tags["data_center"]) + + await client_from_config.close() + + @async_test + async def test_init_from_env(self): + os.environ["INFLUXDB_V2_URL"] = "http://localhost:8086" + os.environ["INFLUXDB_V2_ORG"] = "my-org" + os.environ["INFLUXDB_V2_TOKEN"] = "my-token" + os.environ["INFLUXDB_V2_TIMEOUT"] = "5500" + client_from_envs = InfluxDBClientAsync.from_env_properties() + self.assertEqual("http://localhost:8086", client_from_envs.url) + self.assertEqual("my-org", client_from_envs.org) + self.assertEqual("my-token", client_from_envs.token) + self.assertEqual(5500, client_from_envs.api_client.configuration.timeout) + + await client_from_envs.close() + + +async def _prepare_data(self, measurement: str): + _point1 = Point(measurement).tag("location", "Prague").field("temperature", 25.3) + _point2 = Point(measurement).tag("location", "New York").field("temperature", 24.3) + await self.client.write_api().write(bucket="my-bucket", record=[_point1, _point2]) From c10fb1d1b5afc669cae08b15bb85a3467981d578 Mon Sep 17 00:00:00 2001 From: Jakub Bednar Date: Thu, 10 Mar 2022 14:04:04 +0100 Subject: [PATCH 37/46] fix: tests --- tests/test_InfluxDBClientAsync.py | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/tests/test_InfluxDBClientAsync.py b/tests/test_InfluxDBClientAsync.py index a21a54a3..92cb64f0 100644 --- a/tests/test_InfluxDBClientAsync.py +++ b/tests/test_InfluxDBClientAsync.py @@ -224,7 +224,7 @@ async def test_init_from_env(self): await client_from_envs.close() -async def _prepare_data(self, measurement: str): - _point1 = Point(measurement).tag("location", "Prague").field("temperature", 25.3) - _point2 = Point(measurement).tag("location", "New York").field("temperature", 24.3) - await self.client.write_api().write(bucket="my-bucket", record=[_point1, _point2]) + async def _prepare_data(self, measurement: str): + _point1 = Point(measurement).tag("location", "Prague").field("temperature", 25.3) + _point2 = Point(measurement).tag("location", "New York").field("temperature", 24.3) + await self.client.write_api().write(bucket="my-bucket", record=[_point1, _point2]) From f5fba4fab25538fe34eac8060546b67ab7f112b9 Mon Sep 17 00:00:00 2001 From: Jakub Bednar Date: Fri, 11 Mar 2022 09:27:17 +0100 Subject: [PATCH 38/46] docs: add warning about async initialization --- README.rst | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/README.rst b/README.rst index a572f630..7fa4fb4b 100644 --- a/README.rst +++ b/README.rst @@ -1327,6 +1327,12 @@ or use the ``[async]`` extra: $ python -m pip install influxdb-client[async] +.. warning:: + + The ``InfluxDBClientAsync`` should be initialised inside ``async coroutine`` + otherwise there can be unexpected behaviour. + For more info see: `Why is creating a ClientSession outside of an event loop dangerous? `__. + Async APIs """""""""" All async APIs are available via :class:`~influxdb_client.client.influxdb_client_async.InfluxDBClientAsync`. From 7430a188291c7cb74dcd65501fce179a8cbc7360 Mon Sep 17 00:00:00 2001 From: Jakub Bednar Date: Mon, 14 Mar 2022 10:40:11 +0100 Subject: [PATCH 39/46] feat: add async method to all APIs --- .../client/influxdb_client_async.py | 4 +- influxdb_client/service/_base_service.py | 19 + .../service/authorizations_service.py | 499 ++-- influxdb_client/service/backup_service.py | 300 ++- influxdb_client/service/buckets_service.py | 1493 +++++++----- influxdb_client/service/cells_service.py | 603 +++-- influxdb_client/service/checks_service.py | 990 ++++---- influxdb_client/service/config_service.py | 102 +- influxdb_client/service/dashboards_service.py | 1995 +++++++++------- influxdb_client/service/dbr_ps_service.py | 508 ++-- influxdb_client/service/delete_service.py | 149 +- influxdb_client/service/health_service.py | 102 +- .../service/invocable_scripts_service.py | 594 +++-- influxdb_client/service/labels_service.py | 495 ++-- .../service/legacy_authorizations_service.py | 600 +++-- influxdb_client/service/metrics_service.py | 102 +- .../service/notification_endpoints_service.py | 892 ++++--- .../service/notification_rules_service.py | 894 ++++--- .../service/organizations_service.py | 1099 +++++---- influxdb_client/service/ping_service.py | 211 +- influxdb_client/service/query_service.py | 539 ++--- influxdb_client/service/ready_service.py | 102 +- .../service/remote_connections_service.py | 497 ++-- .../service/replications_service.py | 599 +++-- influxdb_client/service/resources_service.py | 102 +- influxdb_client/service/restore_service.py | 504 ++-- influxdb_client/service/routes_service.py | 102 +- influxdb_client/service/rules_service.py | 103 +- .../service/scraper_targets_service.py | 1392 ++++++----- influxdb_client/service/secrets_service.py | 400 ++-- influxdb_client/service/setup_service.py | 202 +- influxdb_client/service/signin_service.py | 104 +- influxdb_client/service/signout_service.py | 103 +- influxdb_client/service/sources_service.py | 693 +++--- influxdb_client/service/tasks_service.py | 2113 ++++++++++------- .../service/telegraf_plugins_service.py | 103 +- influxdb_client/service/telegrafs_service.py | 1389 ++++++----- influxdb_client/service/templates_service.py | 794 ++++--- influxdb_client/service/users_service.py | 893 ++++--- influxdb_client/service/variables_service.py | 892 ++++--- influxdb_client/service/views_service.py | 204 +- influxdb_client/service/write_service.py | 165 +- 42 files changed, 13127 insertions(+), 10519 deletions(-) create mode 100644 influxdb_client/service/_base_service.py diff --git a/influxdb_client/client/influxdb_client_async.py b/influxdb_client/client/influxdb_client_async.py index 77270cda..91e450fc 100644 --- a/influxdb_client/client/influxdb_client_async.py +++ b/influxdb_client/client/influxdb_client_async.py @@ -152,7 +152,7 @@ async def ping(self) -> bool: ping_service = PingService(self.api_client) try: - await ping_service.get_ping_with_http_info() + await ping_service.get_ping_async() return True except Exception as ex: logger.debug("Unexpected error during /ping: %s", ex) @@ -166,7 +166,7 @@ async def version(self) -> str: """ ping_service = PingService(self.api_client) - response = await ping_service.get_ping_with_http_info(_return_http_data_only=False) + response = await ping_service.get_ping_async(_return_http_data_only=False) return self._version(response) def query_api(self, query_options: QueryOptions = QueryOptions()) -> QueryApiAsync: diff --git a/influxdb_client/service/_base_service.py b/influxdb_client/service/_base_service.py new file mode 100644 index 00000000..39eba5a2 --- /dev/null +++ b/influxdb_client/service/_base_service.py @@ -0,0 +1,19 @@ +import six + + +# noinspection PyMethodMayBeStatic +class _BaseService(object): + def _check_operation_params(self, operation_id, supported_params, local_params): + supported_params.append('async_req') + supported_params.append('_return_http_data_only') + supported_params.append('_preload_content') + supported_params.append('_request_timeout') + supported_params.append('urlopen_kw') + for key, val in six.iteritems(local_params['kwargs']): + if key not in supported_params: + raise TypeError( + f"Got an unexpected keyword argument '{key}'" + f" to method {operation_id}" + ) + local_params[key] = val + del local_params['kwargs'] diff --git a/influxdb_client/service/authorizations_service.py b/influxdb_client/service/authorizations_service.py index 8df663c7..2bf5b9dc 100644 --- a/influxdb_client/service/authorizations_service.py +++ b/influxdb_client/service/authorizations_service.py @@ -14,11 +14,10 @@ import re # noqa: F401 -# python 2 and python 3 compatibility library -import six +from influxdb_client.service._base_service import _BaseService -class AuthorizationsService(object): +class AuthorizationsService(_BaseService): """NOTE: This class is auto generated by OpenAPI Generator. Ref: https://openapi-generator.tech @@ -69,30 +68,68 @@ def delete_authorizations_id_with_http_info(self, auth_id, **kwargs): # noqa: E If the method is called asynchronously, returns the request thread. """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._delete_authorizations_id_prepare(auth_id, **kwargs) + + return self.api_client.call_api( + '/api/v2/authorizations/{authID}', 'DELETE', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type=None, # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + async def delete_authorizations_id_async(self, auth_id, **kwargs): # noqa: E501,D401,D403 + """Delete an authorization. + + This method makes an asynchronous HTTP request. + + :param async_req bool + :param str auth_id: The ID of the authorization to delete. (required) + :param str zap_trace_span: OpenTracing span context + :return: None + If the method is called asynchronously, + returns the request thread. + """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._delete_authorizations_id_prepare(auth_id, **kwargs) + + return await self.api_client.call_api( + '/api/v2/authorizations/{authID}', 'DELETE', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type=None, # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + def _delete_authorizations_id_prepare(self, auth_id, **kwargs): # noqa: E501,D401,D403 local_var_params = locals() all_params = ['auth_id', 'zap_trace_span'] # noqa: E501 - all_params.append('async_req') - all_params.append('_return_http_data_only') - all_params.append('_preload_content') - all_params.append('_request_timeout') - all_params.append('urlopen_kw') - - for key, val in six.iteritems(local_var_params['kwargs']): - if key not in all_params: - raise TypeError( - "Got an unexpected keyword argument '%s'" - " to method delete_authorizations_id" % key - ) - local_var_params[key] = val - del local_var_params['kwargs'] + self._check_operation_params('delete_authorizations_id', all_params, local_var_params) # verify the required parameter 'auth_id' is set if ('auth_id' not in local_var_params or local_var_params['auth_id'] is None): raise ValueError("Missing the required parameter `auth_id` when calling `delete_authorizations_id`") # noqa: E501 - collection_formats = {} - path_params = {} if 'auth_id' in local_var_params: path_params['authID'] = local_var_params['auth_id'] # noqa: E501 @@ -103,38 +140,12 @@ def delete_authorizations_id_with_http_info(self, auth_id, **kwargs): # noqa: E if 'zap_trace_span' in local_var_params: header_params['Zap-Trace-Span'] = local_var_params['zap_trace_span'] # noqa: E501 - form_params = [] - local_var_files = {} - body_params = None # HTTP header `Accept` header_params['Accept'] = self.api_client.select_header_accept( ['application/json']) # noqa: E501 - # Authentication setting - auth_settings = [] # noqa: E501 - - # urlopen optional setting - urlopen_kw = None - if 'urlopen_kw' in kwargs: - urlopen_kw = kwargs['urlopen_kw'] - - return self.api_client.call_api( - '/api/v2/authorizations/{authID}', 'DELETE', - path_params, - query_params, - header_params, - body=body_params, - post_params=form_params, - files=local_var_files, - response_type=None, # noqa: E501 - auth_settings=auth_settings, - async_req=local_var_params.get('async_req'), - _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 - _preload_content=local_var_params.get('_preload_content', True), - _request_timeout=local_var_params.get('_request_timeout'), - collection_formats=collection_formats, - urlopen_kw=urlopen_kw) + return local_var_params, path_params, query_params, header_params, body_params def get_authorizations(self, **kwargs): # noqa: E501,D401,D403 """List all authorizations. @@ -179,25 +190,66 @@ def get_authorizations_with_http_info(self, **kwargs): # noqa: E501,D401,D403 If the method is called asynchronously, returns the request thread. """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._get_authorizations_prepare(**kwargs) + + return self.api_client.call_api( + '/api/v2/authorizations', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='Authorizations', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + async def get_authorizations_async(self, **kwargs): # noqa: E501,D401,D403 + """List all authorizations. + + This method makes an asynchronous HTTP request. + + :param async_req bool + :param str zap_trace_span: OpenTracing span context + :param str user_id: Only show authorizations that belong to a user ID. + :param str user: Only show authorizations that belong to a user name. + :param str org_id: Only show authorizations that belong to an organization ID. + :param str org: Only show authorizations that belong to a organization name. + :return: Authorizations + If the method is called asynchronously, + returns the request thread. + """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._get_authorizations_prepare(**kwargs) + + return await self.api_client.call_api( + '/api/v2/authorizations', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='Authorizations', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + def _get_authorizations_prepare(self, **kwargs): # noqa: E501,D401,D403 local_var_params = locals() all_params = ['zap_trace_span', 'user_id', 'user', 'org_id', 'org'] # noqa: E501 - all_params.append('async_req') - all_params.append('_return_http_data_only') - all_params.append('_preload_content') - all_params.append('_request_timeout') - all_params.append('urlopen_kw') - - for key, val in six.iteritems(local_var_params['kwargs']): - if key not in all_params: - raise TypeError( - "Got an unexpected keyword argument '%s'" - " to method get_authorizations" % key - ) - local_var_params[key] = val - del local_var_params['kwargs'] - - collection_formats = {} + self._check_operation_params('get_authorizations', all_params, local_var_params) path_params = {} @@ -215,38 +267,12 @@ def get_authorizations_with_http_info(self, **kwargs): # noqa: E501,D401,D403 if 'zap_trace_span' in local_var_params: header_params['Zap-Trace-Span'] = local_var_params['zap_trace_span'] # noqa: E501 - form_params = [] - local_var_files = {} - body_params = None # HTTP header `Accept` header_params['Accept'] = self.api_client.select_header_accept( ['application/json']) # noqa: E501 - # Authentication setting - auth_settings = [] # noqa: E501 - - # urlopen optional setting - urlopen_kw = None - if 'urlopen_kw' in kwargs: - urlopen_kw = kwargs['urlopen_kw'] - - return self.api_client.call_api( - '/api/v2/authorizations', 'GET', - path_params, - query_params, - header_params, - body=body_params, - post_params=form_params, - files=local_var_files, - response_type='Authorizations', # noqa: E501 - auth_settings=auth_settings, - async_req=local_var_params.get('async_req'), - _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 - _preload_content=local_var_params.get('_preload_content', True), - _request_timeout=local_var_params.get('_request_timeout'), - collection_formats=collection_formats, - urlopen_kw=urlopen_kw) + return local_var_params, path_params, query_params, header_params, body_params def get_authorizations_id(self, auth_id, **kwargs): # noqa: E501,D401,D403 """Retrieve an authorization. @@ -285,30 +311,68 @@ def get_authorizations_id_with_http_info(self, auth_id, **kwargs): # noqa: E501 If the method is called asynchronously, returns the request thread. """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._get_authorizations_id_prepare(auth_id, **kwargs) + + return self.api_client.call_api( + '/api/v2/authorizations/{authID}', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='Authorization', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + async def get_authorizations_id_async(self, auth_id, **kwargs): # noqa: E501,D401,D403 + """Retrieve an authorization. + + This method makes an asynchronous HTTP request. + + :param async_req bool + :param str auth_id: The ID of the authorization to get. (required) + :param str zap_trace_span: OpenTracing span context + :return: Authorization + If the method is called asynchronously, + returns the request thread. + """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._get_authorizations_id_prepare(auth_id, **kwargs) + + return await self.api_client.call_api( + '/api/v2/authorizations/{authID}', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='Authorization', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + def _get_authorizations_id_prepare(self, auth_id, **kwargs): # noqa: E501,D401,D403 local_var_params = locals() all_params = ['auth_id', 'zap_trace_span'] # noqa: E501 - all_params.append('async_req') - all_params.append('_return_http_data_only') - all_params.append('_preload_content') - all_params.append('_request_timeout') - all_params.append('urlopen_kw') - - for key, val in six.iteritems(local_var_params['kwargs']): - if key not in all_params: - raise TypeError( - "Got an unexpected keyword argument '%s'" - " to method get_authorizations_id" % key - ) - local_var_params[key] = val - del local_var_params['kwargs'] + self._check_operation_params('get_authorizations_id', all_params, local_var_params) # verify the required parameter 'auth_id' is set if ('auth_id' not in local_var_params or local_var_params['auth_id'] is None): raise ValueError("Missing the required parameter `auth_id` when calling `get_authorizations_id`") # noqa: E501 - collection_formats = {} - path_params = {} if 'auth_id' in local_var_params: path_params['authID'] = local_var_params['auth_id'] # noqa: E501 @@ -319,38 +383,12 @@ def get_authorizations_id_with_http_info(self, auth_id, **kwargs): # noqa: E501 if 'zap_trace_span' in local_var_params: header_params['Zap-Trace-Span'] = local_var_params['zap_trace_span'] # noqa: E501 - form_params = [] - local_var_files = {} - body_params = None # HTTP header `Accept` header_params['Accept'] = self.api_client.select_header_accept( ['application/json']) # noqa: E501 - # Authentication setting - auth_settings = [] # noqa: E501 - - # urlopen optional setting - urlopen_kw = None - if 'urlopen_kw' in kwargs: - urlopen_kw = kwargs['urlopen_kw'] - - return self.api_client.call_api( - '/api/v2/authorizations/{authID}', 'GET', - path_params, - query_params, - header_params, - body=body_params, - post_params=form_params, - files=local_var_files, - response_type='Authorization', # noqa: E501 - auth_settings=auth_settings, - async_req=local_var_params.get('async_req'), - _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 - _preload_content=local_var_params.get('_preload_content', True), - _request_timeout=local_var_params.get('_request_timeout'), - collection_formats=collection_formats, - urlopen_kw=urlopen_kw) + return local_var_params, path_params, query_params, header_params, body_params def patch_authorizations_id(self, auth_id, authorization_update_request, **kwargs): # noqa: E501,D401,D403 """Update an authorization to be active or inactive. @@ -391,23 +429,64 @@ def patch_authorizations_id_with_http_info(self, auth_id, authorization_update_r If the method is called asynchronously, returns the request thread. """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._patch_authorizations_id_prepare(auth_id, authorization_update_request, **kwargs) + + return self.api_client.call_api( + '/api/v2/authorizations/{authID}', 'PATCH', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='Authorization', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + async def patch_authorizations_id_async(self, auth_id, authorization_update_request, **kwargs): # noqa: E501,D401,D403 + """Update an authorization to be active or inactive. + + This method makes an asynchronous HTTP request. + + :param async_req bool + :param str auth_id: The ID of the authorization to update. (required) + :param AuthorizationUpdateRequest authorization_update_request: Authorization to update (required) + :param str zap_trace_span: OpenTracing span context + :return: Authorization + If the method is called asynchronously, + returns the request thread. + """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._patch_authorizations_id_prepare(auth_id, authorization_update_request, **kwargs) + + return await self.api_client.call_api( + '/api/v2/authorizations/{authID}', 'PATCH', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='Authorization', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + def _patch_authorizations_id_prepare(self, auth_id, authorization_update_request, **kwargs): # noqa: E501,D401,D403 local_var_params = locals() all_params = ['auth_id', 'authorization_update_request', 'zap_trace_span'] # noqa: E501 - all_params.append('async_req') - all_params.append('_return_http_data_only') - all_params.append('_preload_content') - all_params.append('_request_timeout') - all_params.append('urlopen_kw') - - for key, val in six.iteritems(local_var_params['kwargs']): - if key not in all_params: - raise TypeError( - "Got an unexpected keyword argument '%s'" - " to method patch_authorizations_id" % key - ) - local_var_params[key] = val - del local_var_params['kwargs'] + self._check_operation_params('patch_authorizations_id', all_params, local_var_params) # verify the required parameter 'auth_id' is set if ('auth_id' not in local_var_params or local_var_params['auth_id'] is None): @@ -417,8 +496,6 @@ def patch_authorizations_id_with_http_info(self, auth_id, authorization_update_r local_var_params['authorization_update_request'] is None): raise ValueError("Missing the required parameter `authorization_update_request` when calling `patch_authorizations_id`") # noqa: E501 - collection_formats = {} - path_params = {} if 'auth_id' in local_var_params: path_params['authID'] = local_var_params['auth_id'] # noqa: E501 @@ -429,9 +506,6 @@ def patch_authorizations_id_with_http_info(self, auth_id, authorization_update_r if 'zap_trace_span' in local_var_params: header_params['Zap-Trace-Span'] = local_var_params['zap_trace_span'] # noqa: E501 - form_params = [] - local_var_files = {} - body_params = None if 'authorization_update_request' in local_var_params: body_params = local_var_params['authorization_update_request'] @@ -443,30 +517,7 @@ def patch_authorizations_id_with_http_info(self, auth_id, authorization_update_r header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501 ['application/json']) # noqa: E501 - # Authentication setting - auth_settings = [] # noqa: E501 - - # urlopen optional setting - urlopen_kw = None - if 'urlopen_kw' in kwargs: - urlopen_kw = kwargs['urlopen_kw'] - - return self.api_client.call_api( - '/api/v2/authorizations/{authID}', 'PATCH', - path_params, - query_params, - header_params, - body=body_params, - post_params=form_params, - files=local_var_files, - response_type='Authorization', # noqa: E501 - auth_settings=auth_settings, - async_req=local_var_params.get('async_req'), - _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 - _preload_content=local_var_params.get('_preload_content', True), - _request_timeout=local_var_params.get('_request_timeout'), - collection_formats=collection_formats, - urlopen_kw=urlopen_kw) + return local_var_params, path_params, query_params, header_params, body_params def post_authorizations(self, authorization_post_request, **kwargs): # noqa: E501,D401,D403 """Create an authorization. @@ -505,30 +556,68 @@ def post_authorizations_with_http_info(self, authorization_post_request, **kwarg If the method is called asynchronously, returns the request thread. """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._post_authorizations_prepare(authorization_post_request, **kwargs) + + return self.api_client.call_api( + '/api/v2/authorizations', 'POST', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='Authorization', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + async def post_authorizations_async(self, authorization_post_request, **kwargs): # noqa: E501,D401,D403 + """Create an authorization. + + This method makes an asynchronous HTTP request. + + :param async_req bool + :param AuthorizationPostRequest authorization_post_request: Authorization to create (required) + :param str zap_trace_span: OpenTracing span context + :return: Authorization + If the method is called asynchronously, + returns the request thread. + """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._post_authorizations_prepare(authorization_post_request, **kwargs) + + return await self.api_client.call_api( + '/api/v2/authorizations', 'POST', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='Authorization', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + def _post_authorizations_prepare(self, authorization_post_request, **kwargs): # noqa: E501,D401,D403 local_var_params = locals() all_params = ['authorization_post_request', 'zap_trace_span'] # noqa: E501 - all_params.append('async_req') - all_params.append('_return_http_data_only') - all_params.append('_preload_content') - all_params.append('_request_timeout') - all_params.append('urlopen_kw') - - for key, val in six.iteritems(local_var_params['kwargs']): - if key not in all_params: - raise TypeError( - "Got an unexpected keyword argument '%s'" - " to method post_authorizations" % key - ) - local_var_params[key] = val - del local_var_params['kwargs'] + self._check_operation_params('post_authorizations', all_params, local_var_params) # verify the required parameter 'authorization_post_request' is set if ('authorization_post_request' not in local_var_params or local_var_params['authorization_post_request'] is None): raise ValueError("Missing the required parameter `authorization_post_request` when calling `post_authorizations`") # noqa: E501 - collection_formats = {} - path_params = {} query_params = [] @@ -537,9 +626,6 @@ def post_authorizations_with_http_info(self, authorization_post_request, **kwarg if 'zap_trace_span' in local_var_params: header_params['Zap-Trace-Span'] = local_var_params['zap_trace_span'] # noqa: E501 - form_params = [] - local_var_files = {} - body_params = None if 'authorization_post_request' in local_var_params: body_params = local_var_params['authorization_post_request'] @@ -551,27 +637,4 @@ def post_authorizations_with_http_info(self, authorization_post_request, **kwarg header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501 ['application/json']) # noqa: E501 - # Authentication setting - auth_settings = [] # noqa: E501 - - # urlopen optional setting - urlopen_kw = None - if 'urlopen_kw' in kwargs: - urlopen_kw = kwargs['urlopen_kw'] - - return self.api_client.call_api( - '/api/v2/authorizations', 'POST', - path_params, - query_params, - header_params, - body=body_params, - post_params=form_params, - files=local_var_files, - response_type='Authorization', # noqa: E501 - auth_settings=auth_settings, - async_req=local_var_params.get('async_req'), - _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 - _preload_content=local_var_params.get('_preload_content', True), - _request_timeout=local_var_params.get('_request_timeout'), - collection_formats=collection_formats, - urlopen_kw=urlopen_kw) + return local_var_params, path_params, query_params, header_params, body_params diff --git a/influxdb_client/service/backup_service.py b/influxdb_client/service/backup_service.py index 29421bd3..22ee36d0 100644 --- a/influxdb_client/service/backup_service.py +++ b/influxdb_client/service/backup_service.py @@ -14,11 +14,10 @@ import re # noqa: F401 -# python 2 and python 3 compatibility library -import six +from influxdb_client.service._base_service import _BaseService -class BackupService(object): +class BackupService(_BaseService): """NOTE: This class is auto generated by OpenAPI Generator. Ref: https://openapi-generator.tech @@ -67,25 +66,62 @@ def get_backup_kv_with_http_info(self, **kwargs): # noqa: E501,D401,D403 If the method is called asynchronously, returns the request thread. """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._get_backup_kv_prepare(**kwargs) + + return self.api_client.call_api( + '/api/v2/backup/kv', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='file', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + async def get_backup_kv_async(self, **kwargs): # noqa: E501,D401,D403 + """Download snapshot of metadata stored in the server's embedded KV store. Should not be used in versions greater than 2.1.x, as it doesn't include metadata stored in embedded SQL.. + + This method makes an asynchronous HTTP request. + + :param async_req bool + :param str zap_trace_span: OpenTracing span context + :return: file + If the method is called asynchronously, + returns the request thread. + """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._get_backup_kv_prepare(**kwargs) + + return await self.api_client.call_api( + '/api/v2/backup/kv', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='file', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + def _get_backup_kv_prepare(self, **kwargs): # noqa: E501,D401,D403 local_var_params = locals() all_params = ['zap_trace_span'] # noqa: E501 - all_params.append('async_req') - all_params.append('_return_http_data_only') - all_params.append('_preload_content') - all_params.append('_request_timeout') - all_params.append('urlopen_kw') - - for key, val in six.iteritems(local_var_params['kwargs']): - if key not in all_params: - raise TypeError( - "Got an unexpected keyword argument '%s'" - " to method get_backup_kv" % key - ) - local_var_params[key] = val - del local_var_params['kwargs'] - - collection_formats = {} + self._check_operation_params('get_backup_kv', all_params, local_var_params) path_params = {} @@ -95,38 +131,12 @@ def get_backup_kv_with_http_info(self, **kwargs): # noqa: E501,D401,D403 if 'zap_trace_span' in local_var_params: header_params['Zap-Trace-Span'] = local_var_params['zap_trace_span'] # noqa: E501 - form_params = [] - local_var_files = {} - body_params = None # HTTP header `Accept` header_params['Accept'] = self.api_client.select_header_accept( ['application/octet-stream', 'application/json']) # noqa: E501 - # Authentication setting - auth_settings = [] # noqa: E501 - - # urlopen optional setting - urlopen_kw = None - if 'urlopen_kw' in kwargs: - urlopen_kw = kwargs['urlopen_kw'] - - return self.api_client.call_api( - '/api/v2/backup/kv', 'GET', - path_params, - query_params, - header_params, - body=body_params, - post_params=form_params, - files=local_var_files, - response_type='file', # noqa: E501 - auth_settings=auth_settings, - async_req=local_var_params.get('async_req'), - _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 - _preload_content=local_var_params.get('_preload_content', True), - _request_timeout=local_var_params.get('_request_timeout'), - collection_formats=collection_formats, - urlopen_kw=urlopen_kw) + return local_var_params, path_params, query_params, header_params, body_params def get_backup_metadata(self, **kwargs): # noqa: E501,D401,D403 """Download snapshot of all metadata in the server. @@ -165,25 +175,63 @@ def get_backup_metadata_with_http_info(self, **kwargs): # noqa: E501,D401,D403 If the method is called asynchronously, returns the request thread. """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._get_backup_metadata_prepare(**kwargs) + + return self.api_client.call_api( + '/api/v2/backup/metadata', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='MetadataBackup', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + async def get_backup_metadata_async(self, **kwargs): # noqa: E501,D401,D403 + """Download snapshot of all metadata in the server. + + This method makes an asynchronous HTTP request. + + :param async_req bool + :param str zap_trace_span: OpenTracing span context + :param str accept_encoding: Indicates the content encoding (usually a compression algorithm) that the client can understand. + :return: MetadataBackup + If the method is called asynchronously, + returns the request thread. + """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._get_backup_metadata_prepare(**kwargs) + + return await self.api_client.call_api( + '/api/v2/backup/metadata', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='MetadataBackup', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + def _get_backup_metadata_prepare(self, **kwargs): # noqa: E501,D401,D403 local_var_params = locals() all_params = ['zap_trace_span', 'accept_encoding'] # noqa: E501 - all_params.append('async_req') - all_params.append('_return_http_data_only') - all_params.append('_preload_content') - all_params.append('_request_timeout') - all_params.append('urlopen_kw') - - for key, val in six.iteritems(local_var_params['kwargs']): - if key not in all_params: - raise TypeError( - "Got an unexpected keyword argument '%s'" - " to method get_backup_metadata" % key - ) - local_var_params[key] = val - del local_var_params['kwargs'] - - collection_formats = {} + self._check_operation_params('get_backup_metadata', all_params, local_var_params) path_params = {} @@ -195,38 +243,12 @@ def get_backup_metadata_with_http_info(self, **kwargs): # noqa: E501,D401,D403 if 'accept_encoding' in local_var_params: header_params['Accept-Encoding'] = local_var_params['accept_encoding'] # noqa: E501 - form_params = [] - local_var_files = {} - body_params = None # HTTP header `Accept` header_params['Accept'] = self.api_client.select_header_accept( ['multipart/mixed', 'application/json']) # noqa: E501 - # Authentication setting - auth_settings = [] # noqa: E501 - - # urlopen optional setting - urlopen_kw = None - if 'urlopen_kw' in kwargs: - urlopen_kw = kwargs['urlopen_kw'] - - return self.api_client.call_api( - '/api/v2/backup/metadata', 'GET', - path_params, - query_params, - header_params, - body=body_params, - post_params=form_params, - files=local_var_files, - response_type='MetadataBackup', # noqa: E501 - auth_settings=auth_settings, - async_req=local_var_params.get('async_req'), - _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 - _preload_content=local_var_params.get('_preload_content', True), - _request_timeout=local_var_params.get('_request_timeout'), - collection_formats=collection_formats, - urlopen_kw=urlopen_kw) + return local_var_params, path_params, query_params, header_params, body_params def get_backup_shard_id(self, shard_id, **kwargs): # noqa: E501,D401,D403 """Download snapshot of all TSM data in a shard. @@ -269,30 +291,70 @@ def get_backup_shard_id_with_http_info(self, shard_id, **kwargs): # noqa: E501, If the method is called asynchronously, returns the request thread. """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._get_backup_shard_id_prepare(shard_id, **kwargs) + + return self.api_client.call_api( + '/api/v2/backup/shards/{shardID}', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='file', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + async def get_backup_shard_id_async(self, shard_id, **kwargs): # noqa: E501,D401,D403 + """Download snapshot of all TSM data in a shard. + + This method makes an asynchronous HTTP request. + + :param async_req bool + :param int shard_id: The shard ID. (required) + :param str zap_trace_span: OpenTracing span context + :param str accept_encoding: Indicates the content encoding (usually a compression algorithm) that the client can understand. + :param datetime since: Earliest time to include in the snapshot. RFC3339 format. + :return: file + If the method is called asynchronously, + returns the request thread. + """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._get_backup_shard_id_prepare(shard_id, **kwargs) + + return await self.api_client.call_api( + '/api/v2/backup/shards/{shardID}', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='file', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + def _get_backup_shard_id_prepare(self, shard_id, **kwargs): # noqa: E501,D401,D403 local_var_params = locals() all_params = ['shard_id', 'zap_trace_span', 'accept_encoding', 'since'] # noqa: E501 - all_params.append('async_req') - all_params.append('_return_http_data_only') - all_params.append('_preload_content') - all_params.append('_request_timeout') - all_params.append('urlopen_kw') - - for key, val in six.iteritems(local_var_params['kwargs']): - if key not in all_params: - raise TypeError( - "Got an unexpected keyword argument '%s'" - " to method get_backup_shard_id" % key - ) - local_var_params[key] = val - del local_var_params['kwargs'] + self._check_operation_params('get_backup_shard_id', all_params, local_var_params) # verify the required parameter 'shard_id' is set if ('shard_id' not in local_var_params or local_var_params['shard_id'] is None): raise ValueError("Missing the required parameter `shard_id` when calling `get_backup_shard_id`") # noqa: E501 - collection_formats = {} - path_params = {} if 'shard_id' in local_var_params: path_params['shardID'] = local_var_params['shard_id'] # noqa: E501 @@ -307,35 +369,9 @@ def get_backup_shard_id_with_http_info(self, shard_id, **kwargs): # noqa: E501, if 'accept_encoding' in local_var_params: header_params['Accept-Encoding'] = local_var_params['accept_encoding'] # noqa: E501 - form_params = [] - local_var_files = {} - body_params = None # HTTP header `Accept` header_params['Accept'] = self.api_client.select_header_accept( ['application/octet-stream', 'application/json']) # noqa: E501 - # Authentication setting - auth_settings = [] # noqa: E501 - - # urlopen optional setting - urlopen_kw = None - if 'urlopen_kw' in kwargs: - urlopen_kw = kwargs['urlopen_kw'] - - return self.api_client.call_api( - '/api/v2/backup/shards/{shardID}', 'GET', - path_params, - query_params, - header_params, - body=body_params, - post_params=form_params, - files=local_var_files, - response_type='file', # noqa: E501 - auth_settings=auth_settings, - async_req=local_var_params.get('async_req'), - _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 - _preload_content=local_var_params.get('_preload_content', True), - _request_timeout=local_var_params.get('_request_timeout'), - collection_formats=collection_formats, - urlopen_kw=urlopen_kw) + return local_var_params, path_params, query_params, header_params, body_params diff --git a/influxdb_client/service/buckets_service.py b/influxdb_client/service/buckets_service.py index 64990a45..1831bbfd 100644 --- a/influxdb_client/service/buckets_service.py +++ b/influxdb_client/service/buckets_service.py @@ -14,11 +14,10 @@ import re # noqa: F401 -# python 2 and python 3 compatibility library -import six +from influxdb_client.service._base_service import _BaseService -class BucketsService(object): +class BucketsService(_BaseService): """NOTE: This class is auto generated by OpenAPI Generator. Ref: https://openapi-generator.tech @@ -69,30 +68,68 @@ def delete_buckets_id_with_http_info(self, bucket_id, **kwargs): # noqa: E501,D If the method is called asynchronously, returns the request thread. """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._delete_buckets_id_prepare(bucket_id, **kwargs) + + return self.api_client.call_api( + '/api/v2/buckets/{bucketID}', 'DELETE', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type=None, # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + async def delete_buckets_id_async(self, bucket_id, **kwargs): # noqa: E501,D401,D403 + """Delete a bucket. + + This method makes an asynchronous HTTP request. + + :param async_req bool + :param str bucket_id: The ID of the bucket to delete. (required) + :param str zap_trace_span: OpenTracing span context + :return: None + If the method is called asynchronously, + returns the request thread. + """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._delete_buckets_id_prepare(bucket_id, **kwargs) + + return await self.api_client.call_api( + '/api/v2/buckets/{bucketID}', 'DELETE', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type=None, # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + def _delete_buckets_id_prepare(self, bucket_id, **kwargs): # noqa: E501,D401,D403 local_var_params = locals() all_params = ['bucket_id', 'zap_trace_span'] # noqa: E501 - all_params.append('async_req') - all_params.append('_return_http_data_only') - all_params.append('_preload_content') - all_params.append('_request_timeout') - all_params.append('urlopen_kw') - - for key, val in six.iteritems(local_var_params['kwargs']): - if key not in all_params: - raise TypeError( - "Got an unexpected keyword argument '%s'" - " to method delete_buckets_id" % key - ) - local_var_params[key] = val - del local_var_params['kwargs'] + self._check_operation_params('delete_buckets_id', all_params, local_var_params) # verify the required parameter 'bucket_id' is set if ('bucket_id' not in local_var_params or local_var_params['bucket_id'] is None): raise ValueError("Missing the required parameter `bucket_id` when calling `delete_buckets_id`") # noqa: E501 - collection_formats = {} - path_params = {} if 'bucket_id' in local_var_params: path_params['bucketID'] = local_var_params['bucket_id'] # noqa: E501 @@ -103,38 +140,12 @@ def delete_buckets_id_with_http_info(self, bucket_id, **kwargs): # noqa: E501,D if 'zap_trace_span' in local_var_params: header_params['Zap-Trace-Span'] = local_var_params['zap_trace_span'] # noqa: E501 - form_params = [] - local_var_files = {} - body_params = None # HTTP header `Accept` header_params['Accept'] = self.api_client.select_header_accept( ['application/json']) # noqa: E501 - # Authentication setting - auth_settings = [] # noqa: E501 - - # urlopen optional setting - urlopen_kw = None - if 'urlopen_kw' in kwargs: - urlopen_kw = kwargs['urlopen_kw'] - - return self.api_client.call_api( - '/api/v2/buckets/{bucketID}', 'DELETE', - path_params, - query_params, - header_params, - body=body_params, - post_params=form_params, - files=local_var_files, - response_type=None, # noqa: E501 - auth_settings=auth_settings, - async_req=local_var_params.get('async_req'), - _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 - _preload_content=local_var_params.get('_preload_content', True), - _request_timeout=local_var_params.get('_request_timeout'), - collection_formats=collection_formats, - urlopen_kw=urlopen_kw) + return local_var_params, path_params, query_params, header_params, body_params def delete_buckets_id_labels_id(self, bucket_id, label_id, **kwargs): # noqa: E501,D401,D403 """Delete a label from a bucket. @@ -175,23 +186,64 @@ def delete_buckets_id_labels_id_with_http_info(self, bucket_id, label_id, **kwar If the method is called asynchronously, returns the request thread. """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._delete_buckets_id_labels_id_prepare(bucket_id, label_id, **kwargs) + + return self.api_client.call_api( + '/api/v2/buckets/{bucketID}/labels/{labelID}', 'DELETE', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type=None, # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + async def delete_buckets_id_labels_id_async(self, bucket_id, label_id, **kwargs): # noqa: E501,D401,D403 + """Delete a label from a bucket. + + This method makes an asynchronous HTTP request. + + :param async_req bool + :param str bucket_id: The bucket ID. (required) + :param str label_id: The ID of the label to delete. (required) + :param str zap_trace_span: OpenTracing span context + :return: None + If the method is called asynchronously, + returns the request thread. + """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._delete_buckets_id_labels_id_prepare(bucket_id, label_id, **kwargs) + + return await self.api_client.call_api( + '/api/v2/buckets/{bucketID}/labels/{labelID}', 'DELETE', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type=None, # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + def _delete_buckets_id_labels_id_prepare(self, bucket_id, label_id, **kwargs): # noqa: E501,D401,D403 local_var_params = locals() all_params = ['bucket_id', 'label_id', 'zap_trace_span'] # noqa: E501 - all_params.append('async_req') - all_params.append('_return_http_data_only') - all_params.append('_preload_content') - all_params.append('_request_timeout') - all_params.append('urlopen_kw') - - for key, val in six.iteritems(local_var_params['kwargs']): - if key not in all_params: - raise TypeError( - "Got an unexpected keyword argument '%s'" - " to method delete_buckets_id_labels_id" % key - ) - local_var_params[key] = val - del local_var_params['kwargs'] + self._check_operation_params('delete_buckets_id_labels_id', all_params, local_var_params) # verify the required parameter 'bucket_id' is set if ('bucket_id' not in local_var_params or local_var_params['bucket_id'] is None): @@ -201,8 +253,6 @@ def delete_buckets_id_labels_id_with_http_info(self, bucket_id, label_id, **kwar local_var_params['label_id'] is None): raise ValueError("Missing the required parameter `label_id` when calling `delete_buckets_id_labels_id`") # noqa: E501 - collection_formats = {} - path_params = {} if 'bucket_id' in local_var_params: path_params['bucketID'] = local_var_params['bucket_id'] # noqa: E501 @@ -215,38 +265,12 @@ def delete_buckets_id_labels_id_with_http_info(self, bucket_id, label_id, **kwar if 'zap_trace_span' in local_var_params: header_params['Zap-Trace-Span'] = local_var_params['zap_trace_span'] # noqa: E501 - form_params = [] - local_var_files = {} - body_params = None # HTTP header `Accept` header_params['Accept'] = self.api_client.select_header_accept( ['application/json']) # noqa: E501 - # Authentication setting - auth_settings = [] # noqa: E501 - - # urlopen optional setting - urlopen_kw = None - if 'urlopen_kw' in kwargs: - urlopen_kw = kwargs['urlopen_kw'] - - return self.api_client.call_api( - '/api/v2/buckets/{bucketID}/labels/{labelID}', 'DELETE', - path_params, - query_params, - header_params, - body=body_params, - post_params=form_params, - files=local_var_files, - response_type=None, # noqa: E501 - auth_settings=auth_settings, - async_req=local_var_params.get('async_req'), - _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 - _preload_content=local_var_params.get('_preload_content', True), - _request_timeout=local_var_params.get('_request_timeout'), - collection_formats=collection_formats, - urlopen_kw=urlopen_kw) + return local_var_params, path_params, query_params, header_params, body_params def delete_buckets_id_members_id(self, user_id, bucket_id, **kwargs): # noqa: E501,D401,D403 """Remove a member from a bucket. @@ -287,23 +311,64 @@ def delete_buckets_id_members_id_with_http_info(self, user_id, bucket_id, **kwar If the method is called asynchronously, returns the request thread. """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._delete_buckets_id_members_id_prepare(user_id, bucket_id, **kwargs) + + return self.api_client.call_api( + '/api/v2/buckets/{bucketID}/members/{userID}', 'DELETE', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type=None, # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + async def delete_buckets_id_members_id_async(self, user_id, bucket_id, **kwargs): # noqa: E501,D401,D403 + """Remove a member from a bucket. + + This method makes an asynchronous HTTP request. + + :param async_req bool + :param str user_id: The ID of the member to remove. (required) + :param str bucket_id: The bucket ID. (required) + :param str zap_trace_span: OpenTracing span context + :return: None + If the method is called asynchronously, + returns the request thread. + """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._delete_buckets_id_members_id_prepare(user_id, bucket_id, **kwargs) + + return await self.api_client.call_api( + '/api/v2/buckets/{bucketID}/members/{userID}', 'DELETE', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type=None, # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + def _delete_buckets_id_members_id_prepare(self, user_id, bucket_id, **kwargs): # noqa: E501,D401,D403 local_var_params = locals() all_params = ['user_id', 'bucket_id', 'zap_trace_span'] # noqa: E501 - all_params.append('async_req') - all_params.append('_return_http_data_only') - all_params.append('_preload_content') - all_params.append('_request_timeout') - all_params.append('urlopen_kw') - - for key, val in six.iteritems(local_var_params['kwargs']): - if key not in all_params: - raise TypeError( - "Got an unexpected keyword argument '%s'" - " to method delete_buckets_id_members_id" % key - ) - local_var_params[key] = val - del local_var_params['kwargs'] + self._check_operation_params('delete_buckets_id_members_id', all_params, local_var_params) # verify the required parameter 'user_id' is set if ('user_id' not in local_var_params or local_var_params['user_id'] is None): @@ -313,8 +378,6 @@ def delete_buckets_id_members_id_with_http_info(self, user_id, bucket_id, **kwar local_var_params['bucket_id'] is None): raise ValueError("Missing the required parameter `bucket_id` when calling `delete_buckets_id_members_id`") # noqa: E501 - collection_formats = {} - path_params = {} if 'user_id' in local_var_params: path_params['userID'] = local_var_params['user_id'] # noqa: E501 @@ -327,38 +390,12 @@ def delete_buckets_id_members_id_with_http_info(self, user_id, bucket_id, **kwar if 'zap_trace_span' in local_var_params: header_params['Zap-Trace-Span'] = local_var_params['zap_trace_span'] # noqa: E501 - form_params = [] - local_var_files = {} - body_params = None # HTTP header `Accept` header_params['Accept'] = self.api_client.select_header_accept( ['application/json']) # noqa: E501 - # Authentication setting - auth_settings = [] # noqa: E501 - - # urlopen optional setting - urlopen_kw = None - if 'urlopen_kw' in kwargs: - urlopen_kw = kwargs['urlopen_kw'] - - return self.api_client.call_api( - '/api/v2/buckets/{bucketID}/members/{userID}', 'DELETE', - path_params, - query_params, - header_params, - body=body_params, - post_params=form_params, - files=local_var_files, - response_type=None, # noqa: E501 - auth_settings=auth_settings, - async_req=local_var_params.get('async_req'), - _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 - _preload_content=local_var_params.get('_preload_content', True), - _request_timeout=local_var_params.get('_request_timeout'), - collection_formats=collection_formats, - urlopen_kw=urlopen_kw) + return local_var_params, path_params, query_params, header_params, body_params def delete_buckets_id_owners_id(self, user_id, bucket_id, **kwargs): # noqa: E501,D401,D403 """Remove an owner from a bucket. @@ -399,23 +436,64 @@ def delete_buckets_id_owners_id_with_http_info(self, user_id, bucket_id, **kwarg If the method is called asynchronously, returns the request thread. """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._delete_buckets_id_owners_id_prepare(user_id, bucket_id, **kwargs) + + return self.api_client.call_api( + '/api/v2/buckets/{bucketID}/owners/{userID}', 'DELETE', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type=None, # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + async def delete_buckets_id_owners_id_async(self, user_id, bucket_id, **kwargs): # noqa: E501,D401,D403 + """Remove an owner from a bucket. + + This method makes an asynchronous HTTP request. + + :param async_req bool + :param str user_id: The ID of the owner to remove. (required) + :param str bucket_id: The bucket ID. (required) + :param str zap_trace_span: OpenTracing span context + :return: None + If the method is called asynchronously, + returns the request thread. + """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._delete_buckets_id_owners_id_prepare(user_id, bucket_id, **kwargs) + + return await self.api_client.call_api( + '/api/v2/buckets/{bucketID}/owners/{userID}', 'DELETE', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type=None, # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + def _delete_buckets_id_owners_id_prepare(self, user_id, bucket_id, **kwargs): # noqa: E501,D401,D403 local_var_params = locals() all_params = ['user_id', 'bucket_id', 'zap_trace_span'] # noqa: E501 - all_params.append('async_req') - all_params.append('_return_http_data_only') - all_params.append('_preload_content') - all_params.append('_request_timeout') - all_params.append('urlopen_kw') - - for key, val in six.iteritems(local_var_params['kwargs']): - if key not in all_params: - raise TypeError( - "Got an unexpected keyword argument '%s'" - " to method delete_buckets_id_owners_id" % key - ) - local_var_params[key] = val - del local_var_params['kwargs'] + self._check_operation_params('delete_buckets_id_owners_id', all_params, local_var_params) # verify the required parameter 'user_id' is set if ('user_id' not in local_var_params or local_var_params['user_id'] is None): @@ -425,8 +503,6 @@ def delete_buckets_id_owners_id_with_http_info(self, user_id, bucket_id, **kwarg local_var_params['bucket_id'] is None): raise ValueError("Missing the required parameter `bucket_id` when calling `delete_buckets_id_owners_id`") # noqa: E501 - collection_formats = {} - path_params = {} if 'user_id' in local_var_params: path_params['userID'] = local_var_params['user_id'] # noqa: E501 @@ -439,38 +515,12 @@ def delete_buckets_id_owners_id_with_http_info(self, user_id, bucket_id, **kwarg if 'zap_trace_span' in local_var_params: header_params['Zap-Trace-Span'] = local_var_params['zap_trace_span'] # noqa: E501 - form_params = [] - local_var_files = {} - body_params = None # HTTP header `Accept` header_params['Accept'] = self.api_client.select_header_accept( ['application/json']) # noqa: E501 - # Authentication setting - auth_settings = [] # noqa: E501 - - # urlopen optional setting - urlopen_kw = None - if 'urlopen_kw' in kwargs: - urlopen_kw = kwargs['urlopen_kw'] - - return self.api_client.call_api( - '/api/v2/buckets/{bucketID}/owners/{userID}', 'DELETE', - path_params, - query_params, - header_params, - body=body_params, - post_params=form_params, - files=local_var_files, - response_type=None, # noqa: E501 - auth_settings=auth_settings, - async_req=local_var_params.get('async_req'), - _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 - _preload_content=local_var_params.get('_preload_content', True), - _request_timeout=local_var_params.get('_request_timeout'), - collection_formats=collection_formats, - urlopen_kw=urlopen_kw) + return local_var_params, path_params, query_params, header_params, body_params def get_buckets(self, **kwargs): # noqa: E501,D401,D403 """List all buckets. @@ -521,23 +571,69 @@ def get_buckets_with_http_info(self, **kwargs): # noqa: E501,D401,D403 If the method is called asynchronously, returns the request thread. """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._get_buckets_prepare(**kwargs) + + return self.api_client.call_api( + '/api/v2/buckets', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='Buckets', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + async def get_buckets_async(self, **kwargs): # noqa: E501,D401,D403 + """List all buckets. + + This method makes an asynchronous HTTP request. + + :param async_req bool + :param str zap_trace_span: OpenTracing span context + :param int offset: + :param int limit: + :param str after: Resource ID to seek from. Results are not inclusive of this ID. Use `after` instead of `offset`. + :param str org: The name of the organization. + :param str org_id: The organization ID. + :param str name: Only returns buckets with a specific name. + :param str id: Only returns buckets with a specific ID. + :return: Buckets + If the method is called asynchronously, + returns the request thread. + """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._get_buckets_prepare(**kwargs) + + return await self.api_client.call_api( + '/api/v2/buckets', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='Buckets', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + def _get_buckets_prepare(self, **kwargs): # noqa: E501,D401,D403 local_var_params = locals() all_params = ['zap_trace_span', 'offset', 'limit', 'after', 'org', 'org_id', 'name', 'id'] # noqa: E501 - all_params.append('async_req') - all_params.append('_return_http_data_only') - all_params.append('_preload_content') - all_params.append('_request_timeout') - all_params.append('urlopen_kw') - - for key, val in six.iteritems(local_var_params['kwargs']): - if key not in all_params: - raise TypeError( - "Got an unexpected keyword argument '%s'" - " to method get_buckets" % key - ) - local_var_params[key] = val - del local_var_params['kwargs'] + self._check_operation_params('get_buckets', all_params, local_var_params) if 'offset' in local_var_params and local_var_params['offset'] < 0: # noqa: E501 raise ValueError("Invalid value for parameter `offset` when calling `get_buckets`, must be a value greater than or equal to `0`") # noqa: E501 @@ -545,8 +641,6 @@ def get_buckets_with_http_info(self, **kwargs): # noqa: E501,D401,D403 raise ValueError("Invalid value for parameter `limit` when calling `get_buckets`, must be a value less than or equal to `100`") # noqa: E501 if 'limit' in local_var_params and local_var_params['limit'] < 1: # noqa: E501 raise ValueError("Invalid value for parameter `limit` when calling `get_buckets`, must be a value greater than or equal to `1`") # noqa: E501 - collection_formats = {} - path_params = {} query_params = [] @@ -569,38 +663,12 @@ def get_buckets_with_http_info(self, **kwargs): # noqa: E501,D401,D403 if 'zap_trace_span' in local_var_params: header_params['Zap-Trace-Span'] = local_var_params['zap_trace_span'] # noqa: E501 - form_params = [] - local_var_files = {} - body_params = None # HTTP header `Accept` header_params['Accept'] = self.api_client.select_header_accept( ['application/json']) # noqa: E501 - # Authentication setting - auth_settings = [] # noqa: E501 - - # urlopen optional setting - urlopen_kw = None - if 'urlopen_kw' in kwargs: - urlopen_kw = kwargs['urlopen_kw'] - - return self.api_client.call_api( - '/api/v2/buckets', 'GET', - path_params, - query_params, - header_params, - body=body_params, - post_params=form_params, - files=local_var_files, - response_type='Buckets', # noqa: E501 - auth_settings=auth_settings, - async_req=local_var_params.get('async_req'), - _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 - _preload_content=local_var_params.get('_preload_content', True), - _request_timeout=local_var_params.get('_request_timeout'), - collection_formats=collection_formats, - urlopen_kw=urlopen_kw) + return local_var_params, path_params, query_params, header_params, body_params def get_buckets_id(self, bucket_id, **kwargs): # noqa: E501,D401,D403 """Retrieve a bucket. @@ -639,30 +707,68 @@ def get_buckets_id_with_http_info(self, bucket_id, **kwargs): # noqa: E501,D401 If the method is called asynchronously, returns the request thread. """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._get_buckets_id_prepare(bucket_id, **kwargs) + + return self.api_client.call_api( + '/api/v2/buckets/{bucketID}', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='Bucket', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + async def get_buckets_id_async(self, bucket_id, **kwargs): # noqa: E501,D401,D403 + """Retrieve a bucket. + + This method makes an asynchronous HTTP request. + + :param async_req bool + :param str bucket_id: The bucket ID. (required) + :param str zap_trace_span: OpenTracing span context + :return: Bucket + If the method is called asynchronously, + returns the request thread. + """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._get_buckets_id_prepare(bucket_id, **kwargs) + + return await self.api_client.call_api( + '/api/v2/buckets/{bucketID}', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='Bucket', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + def _get_buckets_id_prepare(self, bucket_id, **kwargs): # noqa: E501,D401,D403 local_var_params = locals() all_params = ['bucket_id', 'zap_trace_span'] # noqa: E501 - all_params.append('async_req') - all_params.append('_return_http_data_only') - all_params.append('_preload_content') - all_params.append('_request_timeout') - all_params.append('urlopen_kw') - - for key, val in six.iteritems(local_var_params['kwargs']): - if key not in all_params: - raise TypeError( - "Got an unexpected keyword argument '%s'" - " to method get_buckets_id" % key - ) - local_var_params[key] = val - del local_var_params['kwargs'] + self._check_operation_params('get_buckets_id', all_params, local_var_params) # verify the required parameter 'bucket_id' is set if ('bucket_id' not in local_var_params or local_var_params['bucket_id'] is None): raise ValueError("Missing the required parameter `bucket_id` when calling `get_buckets_id`") # noqa: E501 - collection_formats = {} - path_params = {} if 'bucket_id' in local_var_params: path_params['bucketID'] = local_var_params['bucket_id'] # noqa: E501 @@ -673,38 +779,12 @@ def get_buckets_id_with_http_info(self, bucket_id, **kwargs): # noqa: E501,D401 if 'zap_trace_span' in local_var_params: header_params['Zap-Trace-Span'] = local_var_params['zap_trace_span'] # noqa: E501 - form_params = [] - local_var_files = {} - body_params = None # HTTP header `Accept` header_params['Accept'] = self.api_client.select_header_accept( ['application/json']) # noqa: E501 - # Authentication setting - auth_settings = [] # noqa: E501 - - # urlopen optional setting - urlopen_kw = None - if 'urlopen_kw' in kwargs: - urlopen_kw = kwargs['urlopen_kw'] - - return self.api_client.call_api( - '/api/v2/buckets/{bucketID}', 'GET', - path_params, - query_params, - header_params, - body=body_params, - post_params=form_params, - files=local_var_files, - response_type='Bucket', # noqa: E501 - auth_settings=auth_settings, - async_req=local_var_params.get('async_req'), - _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 - _preload_content=local_var_params.get('_preload_content', True), - _request_timeout=local_var_params.get('_request_timeout'), - collection_formats=collection_formats, - urlopen_kw=urlopen_kw) + return local_var_params, path_params, query_params, header_params, body_params def get_buckets_id_labels(self, bucket_id, **kwargs): # noqa: E501,D401,D403 """List all labels for a bucket. @@ -743,30 +823,68 @@ def get_buckets_id_labels_with_http_info(self, bucket_id, **kwargs): # noqa: E5 If the method is called asynchronously, returns the request thread. """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._get_buckets_id_labels_prepare(bucket_id, **kwargs) + + return self.api_client.call_api( + '/api/v2/buckets/{bucketID}/labels', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='LabelsResponse', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + async def get_buckets_id_labels_async(self, bucket_id, **kwargs): # noqa: E501,D401,D403 + """List all labels for a bucket. + + This method makes an asynchronous HTTP request. + + :param async_req bool + :param str bucket_id: The bucket ID. (required) + :param str zap_trace_span: OpenTracing span context + :return: LabelsResponse + If the method is called asynchronously, + returns the request thread. + """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._get_buckets_id_labels_prepare(bucket_id, **kwargs) + + return await self.api_client.call_api( + '/api/v2/buckets/{bucketID}/labels', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='LabelsResponse', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + def _get_buckets_id_labels_prepare(self, bucket_id, **kwargs): # noqa: E501,D401,D403 local_var_params = locals() all_params = ['bucket_id', 'zap_trace_span'] # noqa: E501 - all_params.append('async_req') - all_params.append('_return_http_data_only') - all_params.append('_preload_content') - all_params.append('_request_timeout') - all_params.append('urlopen_kw') - - for key, val in six.iteritems(local_var_params['kwargs']): - if key not in all_params: - raise TypeError( - "Got an unexpected keyword argument '%s'" - " to method get_buckets_id_labels" % key - ) - local_var_params[key] = val - del local_var_params['kwargs'] + self._check_operation_params('get_buckets_id_labels', all_params, local_var_params) # verify the required parameter 'bucket_id' is set if ('bucket_id' not in local_var_params or local_var_params['bucket_id'] is None): raise ValueError("Missing the required parameter `bucket_id` when calling `get_buckets_id_labels`") # noqa: E501 - collection_formats = {} - path_params = {} if 'bucket_id' in local_var_params: path_params['bucketID'] = local_var_params['bucket_id'] # noqa: E501 @@ -777,38 +895,12 @@ def get_buckets_id_labels_with_http_info(self, bucket_id, **kwargs): # noqa: E5 if 'zap_trace_span' in local_var_params: header_params['Zap-Trace-Span'] = local_var_params['zap_trace_span'] # noqa: E501 - form_params = [] - local_var_files = {} - body_params = None # HTTP header `Accept` header_params['Accept'] = self.api_client.select_header_accept( ['application/json']) # noqa: E501 - # Authentication setting - auth_settings = [] # noqa: E501 - - # urlopen optional setting - urlopen_kw = None - if 'urlopen_kw' in kwargs: - urlopen_kw = kwargs['urlopen_kw'] - - return self.api_client.call_api( - '/api/v2/buckets/{bucketID}/labels', 'GET', - path_params, - query_params, - header_params, - body=body_params, - post_params=form_params, - files=local_var_files, - response_type='LabelsResponse', # noqa: E501 - auth_settings=auth_settings, - async_req=local_var_params.get('async_req'), - _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 - _preload_content=local_var_params.get('_preload_content', True), - _request_timeout=local_var_params.get('_request_timeout'), - collection_formats=collection_formats, - urlopen_kw=urlopen_kw) + return local_var_params, path_params, query_params, header_params, body_params def get_buckets_id_members(self, bucket_id, **kwargs): # noqa: E501,D401,D403 """List all users with member privileges for a bucket. @@ -847,30 +939,68 @@ def get_buckets_id_members_with_http_info(self, bucket_id, **kwargs): # noqa: E If the method is called asynchronously, returns the request thread. """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._get_buckets_id_members_prepare(bucket_id, **kwargs) + + return self.api_client.call_api( + '/api/v2/buckets/{bucketID}/members', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='ResourceMembers', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + async def get_buckets_id_members_async(self, bucket_id, **kwargs): # noqa: E501,D401,D403 + """List all users with member privileges for a bucket. + + This method makes an asynchronous HTTP request. + + :param async_req bool + :param str bucket_id: The bucket ID. (required) + :param str zap_trace_span: OpenTracing span context + :return: ResourceMembers + If the method is called asynchronously, + returns the request thread. + """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._get_buckets_id_members_prepare(bucket_id, **kwargs) + + return await self.api_client.call_api( + '/api/v2/buckets/{bucketID}/members', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='ResourceMembers', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + def _get_buckets_id_members_prepare(self, bucket_id, **kwargs): # noqa: E501,D401,D403 local_var_params = locals() all_params = ['bucket_id', 'zap_trace_span'] # noqa: E501 - all_params.append('async_req') - all_params.append('_return_http_data_only') - all_params.append('_preload_content') - all_params.append('_request_timeout') - all_params.append('urlopen_kw') - - for key, val in six.iteritems(local_var_params['kwargs']): - if key not in all_params: - raise TypeError( - "Got an unexpected keyword argument '%s'" - " to method get_buckets_id_members" % key - ) - local_var_params[key] = val - del local_var_params['kwargs'] + self._check_operation_params('get_buckets_id_members', all_params, local_var_params) # verify the required parameter 'bucket_id' is set if ('bucket_id' not in local_var_params or local_var_params['bucket_id'] is None): raise ValueError("Missing the required parameter `bucket_id` when calling `get_buckets_id_members`") # noqa: E501 - collection_formats = {} - path_params = {} if 'bucket_id' in local_var_params: path_params['bucketID'] = local_var_params['bucket_id'] # noqa: E501 @@ -881,38 +1011,12 @@ def get_buckets_id_members_with_http_info(self, bucket_id, **kwargs): # noqa: E if 'zap_trace_span' in local_var_params: header_params['Zap-Trace-Span'] = local_var_params['zap_trace_span'] # noqa: E501 - form_params = [] - local_var_files = {} - body_params = None # HTTP header `Accept` header_params['Accept'] = self.api_client.select_header_accept( ['application/json']) # noqa: E501 - # Authentication setting - auth_settings = [] # noqa: E501 - - # urlopen optional setting - urlopen_kw = None - if 'urlopen_kw' in kwargs: - urlopen_kw = kwargs['urlopen_kw'] - - return self.api_client.call_api( - '/api/v2/buckets/{bucketID}/members', 'GET', - path_params, - query_params, - header_params, - body=body_params, - post_params=form_params, - files=local_var_files, - response_type='ResourceMembers', # noqa: E501 - auth_settings=auth_settings, - async_req=local_var_params.get('async_req'), - _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 - _preload_content=local_var_params.get('_preload_content', True), - _request_timeout=local_var_params.get('_request_timeout'), - collection_formats=collection_formats, - urlopen_kw=urlopen_kw) + return local_var_params, path_params, query_params, header_params, body_params def get_buckets_id_owners(self, bucket_id, **kwargs): # noqa: E501,D401,D403 """List all owners of a bucket. @@ -951,30 +1055,68 @@ def get_buckets_id_owners_with_http_info(self, bucket_id, **kwargs): # noqa: E5 If the method is called asynchronously, returns the request thread. """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._get_buckets_id_owners_prepare(bucket_id, **kwargs) + + return self.api_client.call_api( + '/api/v2/buckets/{bucketID}/owners', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='ResourceOwners', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + async def get_buckets_id_owners_async(self, bucket_id, **kwargs): # noqa: E501,D401,D403 + """List all owners of a bucket. + + This method makes an asynchronous HTTP request. + + :param async_req bool + :param str bucket_id: The bucket ID. (required) + :param str zap_trace_span: OpenTracing span context + :return: ResourceOwners + If the method is called asynchronously, + returns the request thread. + """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._get_buckets_id_owners_prepare(bucket_id, **kwargs) + + return await self.api_client.call_api( + '/api/v2/buckets/{bucketID}/owners', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='ResourceOwners', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + def _get_buckets_id_owners_prepare(self, bucket_id, **kwargs): # noqa: E501,D401,D403 local_var_params = locals() all_params = ['bucket_id', 'zap_trace_span'] # noqa: E501 - all_params.append('async_req') - all_params.append('_return_http_data_only') - all_params.append('_preload_content') - all_params.append('_request_timeout') - all_params.append('urlopen_kw') - - for key, val in six.iteritems(local_var_params['kwargs']): - if key not in all_params: - raise TypeError( - "Got an unexpected keyword argument '%s'" - " to method get_buckets_id_owners" % key - ) - local_var_params[key] = val - del local_var_params['kwargs'] + self._check_operation_params('get_buckets_id_owners', all_params, local_var_params) # verify the required parameter 'bucket_id' is set if ('bucket_id' not in local_var_params or local_var_params['bucket_id'] is None): raise ValueError("Missing the required parameter `bucket_id` when calling `get_buckets_id_owners`") # noqa: E501 - collection_formats = {} - path_params = {} if 'bucket_id' in local_var_params: path_params['bucketID'] = local_var_params['bucket_id'] # noqa: E501 @@ -985,38 +1127,12 @@ def get_buckets_id_owners_with_http_info(self, bucket_id, **kwargs): # noqa: E5 if 'zap_trace_span' in local_var_params: header_params['Zap-Trace-Span'] = local_var_params['zap_trace_span'] # noqa: E501 - form_params = [] - local_var_files = {} - body_params = None # HTTP header `Accept` header_params['Accept'] = self.api_client.select_header_accept( ['application/json']) # noqa: E501 - # Authentication setting - auth_settings = [] # noqa: E501 - - # urlopen optional setting - urlopen_kw = None - if 'urlopen_kw' in kwargs: - urlopen_kw = kwargs['urlopen_kw'] - - return self.api_client.call_api( - '/api/v2/buckets/{bucketID}/owners', 'GET', - path_params, - query_params, - header_params, - body=body_params, - post_params=form_params, - files=local_var_files, - response_type='ResourceOwners', # noqa: E501 - auth_settings=auth_settings, - async_req=local_var_params.get('async_req'), - _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 - _preload_content=local_var_params.get('_preload_content', True), - _request_timeout=local_var_params.get('_request_timeout'), - collection_formats=collection_formats, - urlopen_kw=urlopen_kw) + return local_var_params, path_params, query_params, header_params, body_params def get_sources_id_buckets(self, source_id, **kwargs): # noqa: E501,D401,D403 """Get buckets in a source. @@ -1057,30 +1173,69 @@ def get_sources_id_buckets_with_http_info(self, source_id, **kwargs): # noqa: E If the method is called asynchronously, returns the request thread. """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._get_sources_id_buckets_prepare(source_id, **kwargs) + + return self.api_client.call_api( + '/api/v2/sources/{sourceID}/buckets', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='Buckets', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + async def get_sources_id_buckets_async(self, source_id, **kwargs): # noqa: E501,D401,D403 + """Get buckets in a source. + + This method makes an asynchronous HTTP request. + + :param async_req bool + :param str source_id: The source ID. (required) + :param str zap_trace_span: OpenTracing span context + :param str org: The name of the organization. + :return: Buckets + If the method is called asynchronously, + returns the request thread. + """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._get_sources_id_buckets_prepare(source_id, **kwargs) + + return await self.api_client.call_api( + '/api/v2/sources/{sourceID}/buckets', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='Buckets', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + def _get_sources_id_buckets_prepare(self, source_id, **kwargs): # noqa: E501,D401,D403 local_var_params = locals() all_params = ['source_id', 'zap_trace_span', 'org'] # noqa: E501 - all_params.append('async_req') - all_params.append('_return_http_data_only') - all_params.append('_preload_content') - all_params.append('_request_timeout') - all_params.append('urlopen_kw') - - for key, val in six.iteritems(local_var_params['kwargs']): - if key not in all_params: - raise TypeError( - "Got an unexpected keyword argument '%s'" - " to method get_sources_id_buckets" % key - ) - local_var_params[key] = val - del local_var_params['kwargs'] + self._check_operation_params('get_sources_id_buckets', all_params, local_var_params) # verify the required parameter 'source_id' is set if ('source_id' not in local_var_params or local_var_params['source_id'] is None): raise ValueError("Missing the required parameter `source_id` when calling `get_sources_id_buckets`") # noqa: E501 - collection_formats = {} - path_params = {} if 'source_id' in local_var_params: path_params['sourceID'] = local_var_params['source_id'] # noqa: E501 @@ -1093,38 +1248,12 @@ def get_sources_id_buckets_with_http_info(self, source_id, **kwargs): # noqa: E if 'zap_trace_span' in local_var_params: header_params['Zap-Trace-Span'] = local_var_params['zap_trace_span'] # noqa: E501 - form_params = [] - local_var_files = {} - body_params = None # HTTP header `Accept` header_params['Accept'] = self.api_client.select_header_accept( - ['application/json']) # noqa: E501 - - # Authentication setting - auth_settings = [] # noqa: E501 - - # urlopen optional setting - urlopen_kw = None - if 'urlopen_kw' in kwargs: - urlopen_kw = kwargs['urlopen_kw'] - - return self.api_client.call_api( - '/api/v2/sources/{sourceID}/buckets', 'GET', - path_params, - query_params, - header_params, - body=body_params, - post_params=form_params, - files=local_var_files, - response_type='Buckets', # noqa: E501 - auth_settings=auth_settings, - async_req=local_var_params.get('async_req'), - _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 - _preload_content=local_var_params.get('_preload_content', True), - _request_timeout=local_var_params.get('_request_timeout'), - collection_formats=collection_formats, - urlopen_kw=urlopen_kw) + ['application/json']) # noqa: E501 + + return local_var_params, path_params, query_params, header_params, body_params def patch_buckets_id(self, bucket_id, patch_bucket_request, **kwargs): # noqa: E501,D401,D403 """Update a bucket. @@ -1165,23 +1294,64 @@ def patch_buckets_id_with_http_info(self, bucket_id, patch_bucket_request, **kwa If the method is called asynchronously, returns the request thread. """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._patch_buckets_id_prepare(bucket_id, patch_bucket_request, **kwargs) + + return self.api_client.call_api( + '/api/v2/buckets/{bucketID}', 'PATCH', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='Bucket', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + async def patch_buckets_id_async(self, bucket_id, patch_bucket_request, **kwargs): # noqa: E501,D401,D403 + """Update a bucket. + + This method makes an asynchronous HTTP request. + + :param async_req bool + :param str bucket_id: The bucket ID. (required) + :param PatchBucketRequest patch_bucket_request: Bucket update to apply (required) + :param str zap_trace_span: OpenTracing span context + :return: Bucket + If the method is called asynchronously, + returns the request thread. + """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._patch_buckets_id_prepare(bucket_id, patch_bucket_request, **kwargs) + + return await self.api_client.call_api( + '/api/v2/buckets/{bucketID}', 'PATCH', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='Bucket', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + def _patch_buckets_id_prepare(self, bucket_id, patch_bucket_request, **kwargs): # noqa: E501,D401,D403 local_var_params = locals() all_params = ['bucket_id', 'patch_bucket_request', 'zap_trace_span'] # noqa: E501 - all_params.append('async_req') - all_params.append('_return_http_data_only') - all_params.append('_preload_content') - all_params.append('_request_timeout') - all_params.append('urlopen_kw') - - for key, val in six.iteritems(local_var_params['kwargs']): - if key not in all_params: - raise TypeError( - "Got an unexpected keyword argument '%s'" - " to method patch_buckets_id" % key - ) - local_var_params[key] = val - del local_var_params['kwargs'] + self._check_operation_params('patch_buckets_id', all_params, local_var_params) # verify the required parameter 'bucket_id' is set if ('bucket_id' not in local_var_params or local_var_params['bucket_id'] is None): @@ -1191,8 +1361,6 @@ def patch_buckets_id_with_http_info(self, bucket_id, patch_bucket_request, **kwa local_var_params['patch_bucket_request'] is None): raise ValueError("Missing the required parameter `patch_bucket_request` when calling `patch_buckets_id`") # noqa: E501 - collection_formats = {} - path_params = {} if 'bucket_id' in local_var_params: path_params['bucketID'] = local_var_params['bucket_id'] # noqa: E501 @@ -1203,9 +1371,6 @@ def patch_buckets_id_with_http_info(self, bucket_id, patch_bucket_request, **kwa if 'zap_trace_span' in local_var_params: header_params['Zap-Trace-Span'] = local_var_params['zap_trace_span'] # noqa: E501 - form_params = [] - local_var_files = {} - body_params = None if 'patch_bucket_request' in local_var_params: body_params = local_var_params['patch_bucket_request'] @@ -1217,30 +1382,7 @@ def patch_buckets_id_with_http_info(self, bucket_id, patch_bucket_request, **kwa header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501 ['application/json']) # noqa: E501 - # Authentication setting - auth_settings = [] # noqa: E501 - - # urlopen optional setting - urlopen_kw = None - if 'urlopen_kw' in kwargs: - urlopen_kw = kwargs['urlopen_kw'] - - return self.api_client.call_api( - '/api/v2/buckets/{bucketID}', 'PATCH', - path_params, - query_params, - header_params, - body=body_params, - post_params=form_params, - files=local_var_files, - response_type='Bucket', # noqa: E501 - auth_settings=auth_settings, - async_req=local_var_params.get('async_req'), - _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 - _preload_content=local_var_params.get('_preload_content', True), - _request_timeout=local_var_params.get('_request_timeout'), - collection_formats=collection_formats, - urlopen_kw=urlopen_kw) + return local_var_params, path_params, query_params, header_params, body_params def post_buckets(self, post_bucket_request, **kwargs): # noqa: E501,D401,D403 """Create a bucket. @@ -1279,30 +1421,68 @@ def post_buckets_with_http_info(self, post_bucket_request, **kwargs): # noqa: E If the method is called asynchronously, returns the request thread. """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._post_buckets_prepare(post_bucket_request, **kwargs) + + return self.api_client.call_api( + '/api/v2/buckets', 'POST', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='Bucket', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + async def post_buckets_async(self, post_bucket_request, **kwargs): # noqa: E501,D401,D403 + """Create a bucket. + + This method makes an asynchronous HTTP request. + + :param async_req bool + :param PostBucketRequest post_bucket_request: Bucket to create (required) + :param str zap_trace_span: OpenTracing span context + :return: Bucket + If the method is called asynchronously, + returns the request thread. + """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._post_buckets_prepare(post_bucket_request, **kwargs) + + return await self.api_client.call_api( + '/api/v2/buckets', 'POST', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='Bucket', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + def _post_buckets_prepare(self, post_bucket_request, **kwargs): # noqa: E501,D401,D403 local_var_params = locals() all_params = ['post_bucket_request', 'zap_trace_span'] # noqa: E501 - all_params.append('async_req') - all_params.append('_return_http_data_only') - all_params.append('_preload_content') - all_params.append('_request_timeout') - all_params.append('urlopen_kw') - - for key, val in six.iteritems(local_var_params['kwargs']): - if key not in all_params: - raise TypeError( - "Got an unexpected keyword argument '%s'" - " to method post_buckets" % key - ) - local_var_params[key] = val - del local_var_params['kwargs'] + self._check_operation_params('post_buckets', all_params, local_var_params) # verify the required parameter 'post_bucket_request' is set if ('post_bucket_request' not in local_var_params or local_var_params['post_bucket_request'] is None): raise ValueError("Missing the required parameter `post_bucket_request` when calling `post_buckets`") # noqa: E501 - collection_formats = {} - path_params = {} query_params = [] @@ -1311,9 +1491,6 @@ def post_buckets_with_http_info(self, post_bucket_request, **kwargs): # noqa: E if 'zap_trace_span' in local_var_params: header_params['Zap-Trace-Span'] = local_var_params['zap_trace_span'] # noqa: E501 - form_params = [] - local_var_files = {} - body_params = None if 'post_bucket_request' in local_var_params: body_params = local_var_params['post_bucket_request'] @@ -1325,30 +1502,7 @@ def post_buckets_with_http_info(self, post_bucket_request, **kwargs): # noqa: E header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501 ['application/json']) # noqa: E501 - # Authentication setting - auth_settings = [] # noqa: E501 - - # urlopen optional setting - urlopen_kw = None - if 'urlopen_kw' in kwargs: - urlopen_kw = kwargs['urlopen_kw'] - - return self.api_client.call_api( - '/api/v2/buckets', 'POST', - path_params, - query_params, - header_params, - body=body_params, - post_params=form_params, - files=local_var_files, - response_type='Bucket', # noqa: E501 - auth_settings=auth_settings, - async_req=local_var_params.get('async_req'), - _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 - _preload_content=local_var_params.get('_preload_content', True), - _request_timeout=local_var_params.get('_request_timeout'), - collection_formats=collection_formats, - urlopen_kw=urlopen_kw) + return local_var_params, path_params, query_params, header_params, body_params def post_buckets_id_labels(self, bucket_id, label_mapping, **kwargs): # noqa: E501,D401,D403 """Add a label to a bucket. @@ -1389,23 +1543,64 @@ def post_buckets_id_labels_with_http_info(self, bucket_id, label_mapping, **kwar If the method is called asynchronously, returns the request thread. """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._post_buckets_id_labels_prepare(bucket_id, label_mapping, **kwargs) + + return self.api_client.call_api( + '/api/v2/buckets/{bucketID}/labels', 'POST', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='LabelResponse', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + async def post_buckets_id_labels_async(self, bucket_id, label_mapping, **kwargs): # noqa: E501,D401,D403 + """Add a label to a bucket. + + This method makes an asynchronous HTTP request. + + :param async_req bool + :param str bucket_id: The bucket ID. (required) + :param LabelMapping label_mapping: Label to add (required) + :param str zap_trace_span: OpenTracing span context + :return: LabelResponse + If the method is called asynchronously, + returns the request thread. + """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._post_buckets_id_labels_prepare(bucket_id, label_mapping, **kwargs) + + return await self.api_client.call_api( + '/api/v2/buckets/{bucketID}/labels', 'POST', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='LabelResponse', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + def _post_buckets_id_labels_prepare(self, bucket_id, label_mapping, **kwargs): # noqa: E501,D401,D403 local_var_params = locals() all_params = ['bucket_id', 'label_mapping', 'zap_trace_span'] # noqa: E501 - all_params.append('async_req') - all_params.append('_return_http_data_only') - all_params.append('_preload_content') - all_params.append('_request_timeout') - all_params.append('urlopen_kw') - - for key, val in six.iteritems(local_var_params['kwargs']): - if key not in all_params: - raise TypeError( - "Got an unexpected keyword argument '%s'" - " to method post_buckets_id_labels" % key - ) - local_var_params[key] = val - del local_var_params['kwargs'] + self._check_operation_params('post_buckets_id_labels', all_params, local_var_params) # verify the required parameter 'bucket_id' is set if ('bucket_id' not in local_var_params or local_var_params['bucket_id'] is None): @@ -1415,8 +1610,6 @@ def post_buckets_id_labels_with_http_info(self, bucket_id, label_mapping, **kwar local_var_params['label_mapping'] is None): raise ValueError("Missing the required parameter `label_mapping` when calling `post_buckets_id_labels`") # noqa: E501 - collection_formats = {} - path_params = {} if 'bucket_id' in local_var_params: path_params['bucketID'] = local_var_params['bucket_id'] # noqa: E501 @@ -1427,9 +1620,6 @@ def post_buckets_id_labels_with_http_info(self, bucket_id, label_mapping, **kwar if 'zap_trace_span' in local_var_params: header_params['Zap-Trace-Span'] = local_var_params['zap_trace_span'] # noqa: E501 - form_params = [] - local_var_files = {} - body_params = None if 'label_mapping' in local_var_params: body_params = local_var_params['label_mapping'] @@ -1441,30 +1631,7 @@ def post_buckets_id_labels_with_http_info(self, bucket_id, label_mapping, **kwar header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501 ['application/json']) # noqa: E501 - # Authentication setting - auth_settings = [] # noqa: E501 - - # urlopen optional setting - urlopen_kw = None - if 'urlopen_kw' in kwargs: - urlopen_kw = kwargs['urlopen_kw'] - - return self.api_client.call_api( - '/api/v2/buckets/{bucketID}/labels', 'POST', - path_params, - query_params, - header_params, - body=body_params, - post_params=form_params, - files=local_var_files, - response_type='LabelResponse', # noqa: E501 - auth_settings=auth_settings, - async_req=local_var_params.get('async_req'), - _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 - _preload_content=local_var_params.get('_preload_content', True), - _request_timeout=local_var_params.get('_request_timeout'), - collection_formats=collection_formats, - urlopen_kw=urlopen_kw) + return local_var_params, path_params, query_params, header_params, body_params def post_buckets_id_members(self, bucket_id, add_resource_member_request_body, **kwargs): # noqa: E501,D401,D403 """Add a member to a bucket. @@ -1505,23 +1672,64 @@ def post_buckets_id_members_with_http_info(self, bucket_id, add_resource_member_ If the method is called asynchronously, returns the request thread. """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._post_buckets_id_members_prepare(bucket_id, add_resource_member_request_body, **kwargs) + + return self.api_client.call_api( + '/api/v2/buckets/{bucketID}/members', 'POST', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='ResourceMember', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + async def post_buckets_id_members_async(self, bucket_id, add_resource_member_request_body, **kwargs): # noqa: E501,D401,D403 + """Add a member to a bucket. + + This method makes an asynchronous HTTP request. + + :param async_req bool + :param str bucket_id: The bucket ID. (required) + :param AddResourceMemberRequestBody add_resource_member_request_body: User to add as member (required) + :param str zap_trace_span: OpenTracing span context + :return: ResourceMember + If the method is called asynchronously, + returns the request thread. + """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._post_buckets_id_members_prepare(bucket_id, add_resource_member_request_body, **kwargs) + + return await self.api_client.call_api( + '/api/v2/buckets/{bucketID}/members', 'POST', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='ResourceMember', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + def _post_buckets_id_members_prepare(self, bucket_id, add_resource_member_request_body, **kwargs): # noqa: E501,D401,D403 local_var_params = locals() all_params = ['bucket_id', 'add_resource_member_request_body', 'zap_trace_span'] # noqa: E501 - all_params.append('async_req') - all_params.append('_return_http_data_only') - all_params.append('_preload_content') - all_params.append('_request_timeout') - all_params.append('urlopen_kw') - - for key, val in six.iteritems(local_var_params['kwargs']): - if key not in all_params: - raise TypeError( - "Got an unexpected keyword argument '%s'" - " to method post_buckets_id_members" % key - ) - local_var_params[key] = val - del local_var_params['kwargs'] + self._check_operation_params('post_buckets_id_members', all_params, local_var_params) # verify the required parameter 'bucket_id' is set if ('bucket_id' not in local_var_params or local_var_params['bucket_id'] is None): @@ -1531,8 +1739,6 @@ def post_buckets_id_members_with_http_info(self, bucket_id, add_resource_member_ local_var_params['add_resource_member_request_body'] is None): raise ValueError("Missing the required parameter `add_resource_member_request_body` when calling `post_buckets_id_members`") # noqa: E501 - collection_formats = {} - path_params = {} if 'bucket_id' in local_var_params: path_params['bucketID'] = local_var_params['bucket_id'] # noqa: E501 @@ -1543,9 +1749,6 @@ def post_buckets_id_members_with_http_info(self, bucket_id, add_resource_member_ if 'zap_trace_span' in local_var_params: header_params['Zap-Trace-Span'] = local_var_params['zap_trace_span'] # noqa: E501 - form_params = [] - local_var_files = {} - body_params = None if 'add_resource_member_request_body' in local_var_params: body_params = local_var_params['add_resource_member_request_body'] @@ -1557,30 +1760,7 @@ def post_buckets_id_members_with_http_info(self, bucket_id, add_resource_member_ header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501 ['application/json']) # noqa: E501 - # Authentication setting - auth_settings = [] # noqa: E501 - - # urlopen optional setting - urlopen_kw = None - if 'urlopen_kw' in kwargs: - urlopen_kw = kwargs['urlopen_kw'] - - return self.api_client.call_api( - '/api/v2/buckets/{bucketID}/members', 'POST', - path_params, - query_params, - header_params, - body=body_params, - post_params=form_params, - files=local_var_files, - response_type='ResourceMember', # noqa: E501 - auth_settings=auth_settings, - async_req=local_var_params.get('async_req'), - _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 - _preload_content=local_var_params.get('_preload_content', True), - _request_timeout=local_var_params.get('_request_timeout'), - collection_formats=collection_formats, - urlopen_kw=urlopen_kw) + return local_var_params, path_params, query_params, header_params, body_params def post_buckets_id_owners(self, bucket_id, add_resource_member_request_body, **kwargs): # noqa: E501,D401,D403 """Add an owner to a bucket. @@ -1621,23 +1801,64 @@ def post_buckets_id_owners_with_http_info(self, bucket_id, add_resource_member_r If the method is called asynchronously, returns the request thread. """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._post_buckets_id_owners_prepare(bucket_id, add_resource_member_request_body, **kwargs) + + return self.api_client.call_api( + '/api/v2/buckets/{bucketID}/owners', 'POST', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='ResourceOwner', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + async def post_buckets_id_owners_async(self, bucket_id, add_resource_member_request_body, **kwargs): # noqa: E501,D401,D403 + """Add an owner to a bucket. + + This method makes an asynchronous HTTP request. + + :param async_req bool + :param str bucket_id: The bucket ID. (required) + :param AddResourceMemberRequestBody add_resource_member_request_body: User to add as owner (required) + :param str zap_trace_span: OpenTracing span context + :return: ResourceOwner + If the method is called asynchronously, + returns the request thread. + """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._post_buckets_id_owners_prepare(bucket_id, add_resource_member_request_body, **kwargs) + + return await self.api_client.call_api( + '/api/v2/buckets/{bucketID}/owners', 'POST', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='ResourceOwner', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + def _post_buckets_id_owners_prepare(self, bucket_id, add_resource_member_request_body, **kwargs): # noqa: E501,D401,D403 local_var_params = locals() all_params = ['bucket_id', 'add_resource_member_request_body', 'zap_trace_span'] # noqa: E501 - all_params.append('async_req') - all_params.append('_return_http_data_only') - all_params.append('_preload_content') - all_params.append('_request_timeout') - all_params.append('urlopen_kw') - - for key, val in six.iteritems(local_var_params['kwargs']): - if key not in all_params: - raise TypeError( - "Got an unexpected keyword argument '%s'" - " to method post_buckets_id_owners" % key - ) - local_var_params[key] = val - del local_var_params['kwargs'] + self._check_operation_params('post_buckets_id_owners', all_params, local_var_params) # verify the required parameter 'bucket_id' is set if ('bucket_id' not in local_var_params or local_var_params['bucket_id'] is None): @@ -1647,8 +1868,6 @@ def post_buckets_id_owners_with_http_info(self, bucket_id, add_resource_member_r local_var_params['add_resource_member_request_body'] is None): raise ValueError("Missing the required parameter `add_resource_member_request_body` when calling `post_buckets_id_owners`") # noqa: E501 - collection_formats = {} - path_params = {} if 'bucket_id' in local_var_params: path_params['bucketID'] = local_var_params['bucket_id'] # noqa: E501 @@ -1659,9 +1878,6 @@ def post_buckets_id_owners_with_http_info(self, bucket_id, add_resource_member_r if 'zap_trace_span' in local_var_params: header_params['Zap-Trace-Span'] = local_var_params['zap_trace_span'] # noqa: E501 - form_params = [] - local_var_files = {} - body_params = None if 'add_resource_member_request_body' in local_var_params: body_params = local_var_params['add_resource_member_request_body'] @@ -1673,27 +1889,4 @@ def post_buckets_id_owners_with_http_info(self, bucket_id, add_resource_member_r header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501 ['application/json']) # noqa: E501 - # Authentication setting - auth_settings = [] # noqa: E501 - - # urlopen optional setting - urlopen_kw = None - if 'urlopen_kw' in kwargs: - urlopen_kw = kwargs['urlopen_kw'] - - return self.api_client.call_api( - '/api/v2/buckets/{bucketID}/owners', 'POST', - path_params, - query_params, - header_params, - body=body_params, - post_params=form_params, - files=local_var_files, - response_type='ResourceOwner', # noqa: E501 - auth_settings=auth_settings, - async_req=local_var_params.get('async_req'), - _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 - _preload_content=local_var_params.get('_preload_content', True), - _request_timeout=local_var_params.get('_request_timeout'), - collection_formats=collection_formats, - urlopen_kw=urlopen_kw) + return local_var_params, path_params, query_params, header_params, body_params diff --git a/influxdb_client/service/cells_service.py b/influxdb_client/service/cells_service.py index b3d65734..b65ecd69 100644 --- a/influxdb_client/service/cells_service.py +++ b/influxdb_client/service/cells_service.py @@ -14,11 +14,10 @@ import re # noqa: F401 -# python 2 and python 3 compatibility library -import six +from influxdb_client.service._base_service import _BaseService -class CellsService(object): +class CellsService(_BaseService): """NOTE: This class is auto generated by OpenAPI Generator. Ref: https://openapi-generator.tech @@ -71,23 +70,64 @@ def delete_dashboards_id_cells_id_with_http_info(self, dashboard_id, cell_id, ** If the method is called asynchronously, returns the request thread. """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._delete_dashboards_id_cells_id_prepare(dashboard_id, cell_id, **kwargs) + + return self.api_client.call_api( + '/api/v2/dashboards/{dashboardID}/cells/{cellID}', 'DELETE', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type=None, # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + async def delete_dashboards_id_cells_id_async(self, dashboard_id, cell_id, **kwargs): # noqa: E501,D401,D403 + """Delete a dashboard cell. + + This method makes an asynchronous HTTP request. + + :param async_req bool + :param str dashboard_id: The ID of the dashboard to delete. (required) + :param str cell_id: The ID of the cell to delete. (required) + :param str zap_trace_span: OpenTracing span context + :return: None + If the method is called asynchronously, + returns the request thread. + """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._delete_dashboards_id_cells_id_prepare(dashboard_id, cell_id, **kwargs) + + return await self.api_client.call_api( + '/api/v2/dashboards/{dashboardID}/cells/{cellID}', 'DELETE', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type=None, # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + def _delete_dashboards_id_cells_id_prepare(self, dashboard_id, cell_id, **kwargs): # noqa: E501,D401,D403 local_var_params = locals() all_params = ['dashboard_id', 'cell_id', 'zap_trace_span'] # noqa: E501 - all_params.append('async_req') - all_params.append('_return_http_data_only') - all_params.append('_preload_content') - all_params.append('_request_timeout') - all_params.append('urlopen_kw') - - for key, val in six.iteritems(local_var_params['kwargs']): - if key not in all_params: - raise TypeError( - "Got an unexpected keyword argument '%s'" - " to method delete_dashboards_id_cells_id" % key - ) - local_var_params[key] = val - del local_var_params['kwargs'] + self._check_operation_params('delete_dashboards_id_cells_id', all_params, local_var_params) # verify the required parameter 'dashboard_id' is set if ('dashboard_id' not in local_var_params or local_var_params['dashboard_id'] is None): @@ -97,8 +137,6 @@ def delete_dashboards_id_cells_id_with_http_info(self, dashboard_id, cell_id, ** local_var_params['cell_id'] is None): raise ValueError("Missing the required parameter `cell_id` when calling `delete_dashboards_id_cells_id`") # noqa: E501 - collection_formats = {} - path_params = {} if 'dashboard_id' in local_var_params: path_params['dashboardID'] = local_var_params['dashboard_id'] # noqa: E501 @@ -111,38 +149,12 @@ def delete_dashboards_id_cells_id_with_http_info(self, dashboard_id, cell_id, ** if 'zap_trace_span' in local_var_params: header_params['Zap-Trace-Span'] = local_var_params['zap_trace_span'] # noqa: E501 - form_params = [] - local_var_files = {} - body_params = None # HTTP header `Accept` header_params['Accept'] = self.api_client.select_header_accept( ['application/json']) # noqa: E501 - # Authentication setting - auth_settings = [] # noqa: E501 - - # urlopen optional setting - urlopen_kw = None - if 'urlopen_kw' in kwargs: - urlopen_kw = kwargs['urlopen_kw'] - - return self.api_client.call_api( - '/api/v2/dashboards/{dashboardID}/cells/{cellID}', 'DELETE', - path_params, - query_params, - header_params, - body=body_params, - post_params=form_params, - files=local_var_files, - response_type=None, # noqa: E501 - auth_settings=auth_settings, - async_req=local_var_params.get('async_req'), - _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 - _preload_content=local_var_params.get('_preload_content', True), - _request_timeout=local_var_params.get('_request_timeout'), - collection_formats=collection_formats, - urlopen_kw=urlopen_kw) + return local_var_params, path_params, query_params, header_params, body_params def get_dashboards_id_cells_id_view(self, dashboard_id, cell_id, **kwargs): # noqa: E501,D401,D403 """Retrieve the view for a cell. @@ -183,23 +195,64 @@ def get_dashboards_id_cells_id_view_with_http_info(self, dashboard_id, cell_id, If the method is called asynchronously, returns the request thread. """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._get_dashboards_id_cells_id_view_prepare(dashboard_id, cell_id, **kwargs) + + return self.api_client.call_api( + '/api/v2/dashboards/{dashboardID}/cells/{cellID}/view', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='View', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + async def get_dashboards_id_cells_id_view_async(self, dashboard_id, cell_id, **kwargs): # noqa: E501,D401,D403 + """Retrieve the view for a cell. + + This method makes an asynchronous HTTP request. + + :param async_req bool + :param str dashboard_id: The dashboard ID. (required) + :param str cell_id: The cell ID. (required) + :param str zap_trace_span: OpenTracing span context + :return: View + If the method is called asynchronously, + returns the request thread. + """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._get_dashboards_id_cells_id_view_prepare(dashboard_id, cell_id, **kwargs) + + return await self.api_client.call_api( + '/api/v2/dashboards/{dashboardID}/cells/{cellID}/view', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='View', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + def _get_dashboards_id_cells_id_view_prepare(self, dashboard_id, cell_id, **kwargs): # noqa: E501,D401,D403 local_var_params = locals() all_params = ['dashboard_id', 'cell_id', 'zap_trace_span'] # noqa: E501 - all_params.append('async_req') - all_params.append('_return_http_data_only') - all_params.append('_preload_content') - all_params.append('_request_timeout') - all_params.append('urlopen_kw') - - for key, val in six.iteritems(local_var_params['kwargs']): - if key not in all_params: - raise TypeError( - "Got an unexpected keyword argument '%s'" - " to method get_dashboards_id_cells_id_view" % key - ) - local_var_params[key] = val - del local_var_params['kwargs'] + self._check_operation_params('get_dashboards_id_cells_id_view', all_params, local_var_params) # verify the required parameter 'dashboard_id' is set if ('dashboard_id' not in local_var_params or local_var_params['dashboard_id'] is None): @@ -209,8 +262,6 @@ def get_dashboards_id_cells_id_view_with_http_info(self, dashboard_id, cell_id, local_var_params['cell_id'] is None): raise ValueError("Missing the required parameter `cell_id` when calling `get_dashboards_id_cells_id_view`") # noqa: E501 - collection_formats = {} - path_params = {} if 'dashboard_id' in local_var_params: path_params['dashboardID'] = local_var_params['dashboard_id'] # noqa: E501 @@ -223,38 +274,12 @@ def get_dashboards_id_cells_id_view_with_http_info(self, dashboard_id, cell_id, if 'zap_trace_span' in local_var_params: header_params['Zap-Trace-Span'] = local_var_params['zap_trace_span'] # noqa: E501 - form_params = [] - local_var_files = {} - body_params = None # HTTP header `Accept` header_params['Accept'] = self.api_client.select_header_accept( ['application/json']) # noqa: E501 - # Authentication setting - auth_settings = [] # noqa: E501 - - # urlopen optional setting - urlopen_kw = None - if 'urlopen_kw' in kwargs: - urlopen_kw = kwargs['urlopen_kw'] - - return self.api_client.call_api( - '/api/v2/dashboards/{dashboardID}/cells/{cellID}/view', 'GET', - path_params, - query_params, - header_params, - body=body_params, - post_params=form_params, - files=local_var_files, - response_type='View', # noqa: E501 - auth_settings=auth_settings, - async_req=local_var_params.get('async_req'), - _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 - _preload_content=local_var_params.get('_preload_content', True), - _request_timeout=local_var_params.get('_request_timeout'), - collection_formats=collection_formats, - urlopen_kw=urlopen_kw) + return local_var_params, path_params, query_params, header_params, body_params def patch_dashboards_id_cells_id(self, dashboard_id, cell_id, cell_update, **kwargs): # noqa: E501,D401,D403 """Update the non-positional information related to a cell. @@ -299,23 +324,66 @@ def patch_dashboards_id_cells_id_with_http_info(self, dashboard_id, cell_id, cel If the method is called asynchronously, returns the request thread. """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._patch_dashboards_id_cells_id_prepare(dashboard_id, cell_id, cell_update, **kwargs) + + return self.api_client.call_api( + '/api/v2/dashboards/{dashboardID}/cells/{cellID}', 'PATCH', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='Cell', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + async def patch_dashboards_id_cells_id_async(self, dashboard_id, cell_id, cell_update, **kwargs): # noqa: E501,D401,D403 + """Update the non-positional information related to a cell. + + Updates the non positional information related to a cell. Updates to a single cell's positional data could cause grid conflicts. + This method makes an asynchronous HTTP request. + + :param async_req bool + :param str dashboard_id: The ID of the dashboard to update. (required) + :param str cell_id: The ID of the cell to update. (required) + :param CellUpdate cell_update: (required) + :param str zap_trace_span: OpenTracing span context + :return: Cell + If the method is called asynchronously, + returns the request thread. + """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._patch_dashboards_id_cells_id_prepare(dashboard_id, cell_id, cell_update, **kwargs) + + return await self.api_client.call_api( + '/api/v2/dashboards/{dashboardID}/cells/{cellID}', 'PATCH', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='Cell', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + def _patch_dashboards_id_cells_id_prepare(self, dashboard_id, cell_id, cell_update, **kwargs): # noqa: E501,D401,D403 local_var_params = locals() all_params = ['dashboard_id', 'cell_id', 'cell_update', 'zap_trace_span'] # noqa: E501 - all_params.append('async_req') - all_params.append('_return_http_data_only') - all_params.append('_preload_content') - all_params.append('_request_timeout') - all_params.append('urlopen_kw') - - for key, val in six.iteritems(local_var_params['kwargs']): - if key not in all_params: - raise TypeError( - "Got an unexpected keyword argument '%s'" - " to method patch_dashboards_id_cells_id" % key - ) - local_var_params[key] = val - del local_var_params['kwargs'] + self._check_operation_params('patch_dashboards_id_cells_id', all_params, local_var_params) # verify the required parameter 'dashboard_id' is set if ('dashboard_id' not in local_var_params or local_var_params['dashboard_id'] is None): @@ -329,8 +397,6 @@ def patch_dashboards_id_cells_id_with_http_info(self, dashboard_id, cell_id, cel local_var_params['cell_update'] is None): raise ValueError("Missing the required parameter `cell_update` when calling `patch_dashboards_id_cells_id`") # noqa: E501 - collection_formats = {} - path_params = {} if 'dashboard_id' in local_var_params: path_params['dashboardID'] = local_var_params['dashboard_id'] # noqa: E501 @@ -343,9 +409,6 @@ def patch_dashboards_id_cells_id_with_http_info(self, dashboard_id, cell_id, cel if 'zap_trace_span' in local_var_params: header_params['Zap-Trace-Span'] = local_var_params['zap_trace_span'] # noqa: E501 - form_params = [] - local_var_files = {} - body_params = None if 'cell_update' in local_var_params: body_params = local_var_params['cell_update'] @@ -357,30 +420,7 @@ def patch_dashboards_id_cells_id_with_http_info(self, dashboard_id, cell_id, cel header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501 ['application/json']) # noqa: E501 - # Authentication setting - auth_settings = [] # noqa: E501 - - # urlopen optional setting - urlopen_kw = None - if 'urlopen_kw' in kwargs: - urlopen_kw = kwargs['urlopen_kw'] - - return self.api_client.call_api( - '/api/v2/dashboards/{dashboardID}/cells/{cellID}', 'PATCH', - path_params, - query_params, - header_params, - body=body_params, - post_params=form_params, - files=local_var_files, - response_type='Cell', # noqa: E501 - auth_settings=auth_settings, - async_req=local_var_params.get('async_req'), - _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 - _preload_content=local_var_params.get('_preload_content', True), - _request_timeout=local_var_params.get('_request_timeout'), - collection_formats=collection_formats, - urlopen_kw=urlopen_kw) + return local_var_params, path_params, query_params, header_params, body_params def patch_dashboards_id_cells_id_view(self, dashboard_id, cell_id, view, **kwargs): # noqa: E501,D401,D403 """Update the view for a cell. @@ -423,23 +463,65 @@ def patch_dashboards_id_cells_id_view_with_http_info(self, dashboard_id, cell_id If the method is called asynchronously, returns the request thread. """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._patch_dashboards_id_cells_id_view_prepare(dashboard_id, cell_id, view, **kwargs) + + return self.api_client.call_api( + '/api/v2/dashboards/{dashboardID}/cells/{cellID}/view', 'PATCH', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='View', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + async def patch_dashboards_id_cells_id_view_async(self, dashboard_id, cell_id, view, **kwargs): # noqa: E501,D401,D403 + """Update the view for a cell. + + This method makes an asynchronous HTTP request. + + :param async_req bool + :param str dashboard_id: The ID of the dashboard to update. (required) + :param str cell_id: The ID of the cell to update. (required) + :param View view: (required) + :param str zap_trace_span: OpenTracing span context + :return: View + If the method is called asynchronously, + returns the request thread. + """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._patch_dashboards_id_cells_id_view_prepare(dashboard_id, cell_id, view, **kwargs) + + return await self.api_client.call_api( + '/api/v2/dashboards/{dashboardID}/cells/{cellID}/view', 'PATCH', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='View', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + def _patch_dashboards_id_cells_id_view_prepare(self, dashboard_id, cell_id, view, **kwargs): # noqa: E501,D401,D403 local_var_params = locals() all_params = ['dashboard_id', 'cell_id', 'view', 'zap_trace_span'] # noqa: E501 - all_params.append('async_req') - all_params.append('_return_http_data_only') - all_params.append('_preload_content') - all_params.append('_request_timeout') - all_params.append('urlopen_kw') - - for key, val in six.iteritems(local_var_params['kwargs']): - if key not in all_params: - raise TypeError( - "Got an unexpected keyword argument '%s'" - " to method patch_dashboards_id_cells_id_view" % key - ) - local_var_params[key] = val - del local_var_params['kwargs'] + self._check_operation_params('patch_dashboards_id_cells_id_view', all_params, local_var_params) # verify the required parameter 'dashboard_id' is set if ('dashboard_id' not in local_var_params or local_var_params['dashboard_id'] is None): @@ -453,8 +535,6 @@ def patch_dashboards_id_cells_id_view_with_http_info(self, dashboard_id, cell_id local_var_params['view'] is None): raise ValueError("Missing the required parameter `view` when calling `patch_dashboards_id_cells_id_view`") # noqa: E501 - collection_formats = {} - path_params = {} if 'dashboard_id' in local_var_params: path_params['dashboardID'] = local_var_params['dashboard_id'] # noqa: E501 @@ -467,9 +547,6 @@ def patch_dashboards_id_cells_id_view_with_http_info(self, dashboard_id, cell_id if 'zap_trace_span' in local_var_params: header_params['Zap-Trace-Span'] = local_var_params['zap_trace_span'] # noqa: E501 - form_params = [] - local_var_files = {} - body_params = None if 'view' in local_var_params: body_params = local_var_params['view'] @@ -481,30 +558,7 @@ def patch_dashboards_id_cells_id_view_with_http_info(self, dashboard_id, cell_id header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501 ['application/json']) # noqa: E501 - # Authentication setting - auth_settings = [] # noqa: E501 - - # urlopen optional setting - urlopen_kw = None - if 'urlopen_kw' in kwargs: - urlopen_kw = kwargs['urlopen_kw'] - - return self.api_client.call_api( - '/api/v2/dashboards/{dashboardID}/cells/{cellID}/view', 'PATCH', - path_params, - query_params, - header_params, - body=body_params, - post_params=form_params, - files=local_var_files, - response_type='View', # noqa: E501 - auth_settings=auth_settings, - async_req=local_var_params.get('async_req'), - _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 - _preload_content=local_var_params.get('_preload_content', True), - _request_timeout=local_var_params.get('_request_timeout'), - collection_formats=collection_formats, - urlopen_kw=urlopen_kw) + return local_var_params, path_params, query_params, header_params, body_params def post_dashboards_id_cells(self, dashboard_id, create_cell, **kwargs): # noqa: E501,D401,D403 """Create a dashboard cell. @@ -545,23 +599,64 @@ def post_dashboards_id_cells_with_http_info(self, dashboard_id, create_cell, **k If the method is called asynchronously, returns the request thread. """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._post_dashboards_id_cells_prepare(dashboard_id, create_cell, **kwargs) + + return self.api_client.call_api( + '/api/v2/dashboards/{dashboardID}/cells', 'POST', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='Cell', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + async def post_dashboards_id_cells_async(self, dashboard_id, create_cell, **kwargs): # noqa: E501,D401,D403 + """Create a dashboard cell. + + This method makes an asynchronous HTTP request. + + :param async_req bool + :param str dashboard_id: The ID of the dashboard to update. (required) + :param CreateCell create_cell: Cell that will be added (required) + :param str zap_trace_span: OpenTracing span context + :return: Cell + If the method is called asynchronously, + returns the request thread. + """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._post_dashboards_id_cells_prepare(dashboard_id, create_cell, **kwargs) + + return await self.api_client.call_api( + '/api/v2/dashboards/{dashboardID}/cells', 'POST', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='Cell', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + def _post_dashboards_id_cells_prepare(self, dashboard_id, create_cell, **kwargs): # noqa: E501,D401,D403 local_var_params = locals() all_params = ['dashboard_id', 'create_cell', 'zap_trace_span'] # noqa: E501 - all_params.append('async_req') - all_params.append('_return_http_data_only') - all_params.append('_preload_content') - all_params.append('_request_timeout') - all_params.append('urlopen_kw') - - for key, val in six.iteritems(local_var_params['kwargs']): - if key not in all_params: - raise TypeError( - "Got an unexpected keyword argument '%s'" - " to method post_dashboards_id_cells" % key - ) - local_var_params[key] = val - del local_var_params['kwargs'] + self._check_operation_params('post_dashboards_id_cells', all_params, local_var_params) # verify the required parameter 'dashboard_id' is set if ('dashboard_id' not in local_var_params or local_var_params['dashboard_id'] is None): @@ -571,8 +666,6 @@ def post_dashboards_id_cells_with_http_info(self, dashboard_id, create_cell, **k local_var_params['create_cell'] is None): raise ValueError("Missing the required parameter `create_cell` when calling `post_dashboards_id_cells`") # noqa: E501 - collection_formats = {} - path_params = {} if 'dashboard_id' in local_var_params: path_params['dashboardID'] = local_var_params['dashboard_id'] # noqa: E501 @@ -583,9 +676,6 @@ def post_dashboards_id_cells_with_http_info(self, dashboard_id, create_cell, **k if 'zap_trace_span' in local_var_params: header_params['Zap-Trace-Span'] = local_var_params['zap_trace_span'] # noqa: E501 - form_params = [] - local_var_files = {} - body_params = None if 'create_cell' in local_var_params: body_params = local_var_params['create_cell'] @@ -597,30 +687,7 @@ def post_dashboards_id_cells_with_http_info(self, dashboard_id, create_cell, **k header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501 ['application/json']) # noqa: E501 - # Authentication setting - auth_settings = [] # noqa: E501 - - # urlopen optional setting - urlopen_kw = None - if 'urlopen_kw' in kwargs: - urlopen_kw = kwargs['urlopen_kw'] - - return self.api_client.call_api( - '/api/v2/dashboards/{dashboardID}/cells', 'POST', - path_params, - query_params, - header_params, - body=body_params, - post_params=form_params, - files=local_var_files, - response_type='Cell', # noqa: E501 - auth_settings=auth_settings, - async_req=local_var_params.get('async_req'), - _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 - _preload_content=local_var_params.get('_preload_content', True), - _request_timeout=local_var_params.get('_request_timeout'), - collection_formats=collection_formats, - urlopen_kw=urlopen_kw) + return local_var_params, path_params, query_params, header_params, body_params def put_dashboards_id_cells(self, dashboard_id, cell, **kwargs): # noqa: E501,D401,D403 """Replace cells in a dashboard. @@ -663,23 +730,65 @@ def put_dashboards_id_cells_with_http_info(self, dashboard_id, cell, **kwargs): If the method is called asynchronously, returns the request thread. """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._put_dashboards_id_cells_prepare(dashboard_id, cell, **kwargs) + + return self.api_client.call_api( + '/api/v2/dashboards/{dashboardID}/cells', 'PUT', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='Dashboard', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + async def put_dashboards_id_cells_async(self, dashboard_id, cell, **kwargs): # noqa: E501,D401,D403 + """Replace cells in a dashboard. + + Replaces all cells in a dashboard. This is used primarily to update the positional information of all cells. + This method makes an asynchronous HTTP request. + + :param async_req bool + :param str dashboard_id: The ID of the dashboard to update. (required) + :param list[Cell] cell: (required) + :param str zap_trace_span: OpenTracing span context + :return: Dashboard + If the method is called asynchronously, + returns the request thread. + """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._put_dashboards_id_cells_prepare(dashboard_id, cell, **kwargs) + + return await self.api_client.call_api( + '/api/v2/dashboards/{dashboardID}/cells', 'PUT', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='Dashboard', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + def _put_dashboards_id_cells_prepare(self, dashboard_id, cell, **kwargs): # noqa: E501,D401,D403 local_var_params = locals() all_params = ['dashboard_id', 'cell', 'zap_trace_span'] # noqa: E501 - all_params.append('async_req') - all_params.append('_return_http_data_only') - all_params.append('_preload_content') - all_params.append('_request_timeout') - all_params.append('urlopen_kw') - - for key, val in six.iteritems(local_var_params['kwargs']): - if key not in all_params: - raise TypeError( - "Got an unexpected keyword argument '%s'" - " to method put_dashboards_id_cells" % key - ) - local_var_params[key] = val - del local_var_params['kwargs'] + self._check_operation_params('put_dashboards_id_cells', all_params, local_var_params) # verify the required parameter 'dashboard_id' is set if ('dashboard_id' not in local_var_params or local_var_params['dashboard_id'] is None): @@ -689,8 +798,6 @@ def put_dashboards_id_cells_with_http_info(self, dashboard_id, cell, **kwargs): local_var_params['cell'] is None): raise ValueError("Missing the required parameter `cell` when calling `put_dashboards_id_cells`") # noqa: E501 - collection_formats = {} - path_params = {} if 'dashboard_id' in local_var_params: path_params['dashboardID'] = local_var_params['dashboard_id'] # noqa: E501 @@ -701,9 +808,6 @@ def put_dashboards_id_cells_with_http_info(self, dashboard_id, cell, **kwargs): if 'zap_trace_span' in local_var_params: header_params['Zap-Trace-Span'] = local_var_params['zap_trace_span'] # noqa: E501 - form_params = [] - local_var_files = {} - body_params = None if 'cell' in local_var_params: body_params = local_var_params['cell'] @@ -715,27 +819,4 @@ def put_dashboards_id_cells_with_http_info(self, dashboard_id, cell, **kwargs): header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501 ['application/json']) # noqa: E501 - # Authentication setting - auth_settings = [] # noqa: E501 - - # urlopen optional setting - urlopen_kw = None - if 'urlopen_kw' in kwargs: - urlopen_kw = kwargs['urlopen_kw'] - - return self.api_client.call_api( - '/api/v2/dashboards/{dashboardID}/cells', 'PUT', - path_params, - query_params, - header_params, - body=body_params, - post_params=form_params, - files=local_var_files, - response_type='Dashboard', # noqa: E501 - auth_settings=auth_settings, - async_req=local_var_params.get('async_req'), - _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 - _preload_content=local_var_params.get('_preload_content', True), - _request_timeout=local_var_params.get('_request_timeout'), - collection_formats=collection_formats, - urlopen_kw=urlopen_kw) + return local_var_params, path_params, query_params, header_params, body_params diff --git a/influxdb_client/service/checks_service.py b/influxdb_client/service/checks_service.py index 60643ce2..0f20dee6 100644 --- a/influxdb_client/service/checks_service.py +++ b/influxdb_client/service/checks_service.py @@ -14,11 +14,10 @@ import re # noqa: F401 -# python 2 and python 3 compatibility library -import six +from influxdb_client.service._base_service import _BaseService -class ChecksService(object): +class ChecksService(_BaseService): """NOTE: This class is auto generated by OpenAPI Generator. Ref: https://openapi-generator.tech @@ -67,39 +66,73 @@ def create_check_with_http_info(self, post_check, **kwargs): # noqa: E501,D401, If the method is called asynchronously, returns the request thread. """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._create_check_prepare(post_check, **kwargs) + + return self.api_client.call_api( + '/api/v2/checks', 'POST', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='Check', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + async def create_check_async(self, post_check, **kwargs): # noqa: E501,D401,D403 + """Add new check. + + This method makes an asynchronous HTTP request. + + :param async_req bool + :param PostCheck post_check: Check to create (required) + :return: Check + If the method is called asynchronously, + returns the request thread. + """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._create_check_prepare(post_check, **kwargs) + + return await self.api_client.call_api( + '/api/v2/checks', 'POST', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='Check', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + def _create_check_prepare(self, post_check, **kwargs): # noqa: E501,D401,D403 local_var_params = locals() all_params = ['post_check'] # noqa: E501 - all_params.append('async_req') - all_params.append('_return_http_data_only') - all_params.append('_preload_content') - all_params.append('_request_timeout') - all_params.append('urlopen_kw') - - for key, val in six.iteritems(local_var_params['kwargs']): - if key not in all_params: - raise TypeError( - "Got an unexpected keyword argument '%s'" - " to method create_check" % key - ) - local_var_params[key] = val - del local_var_params['kwargs'] + self._check_operation_params('create_check', all_params, local_var_params) # verify the required parameter 'post_check' is set if ('post_check' not in local_var_params or local_var_params['post_check'] is None): raise ValueError("Missing the required parameter `post_check` when calling `create_check`") # noqa: E501 - collection_formats = {} - path_params = {} query_params = [] header_params = {} - form_params = [] - local_var_files = {} - body_params = None if 'post_check' in local_var_params: body_params = local_var_params['post_check'] @@ -111,30 +144,7 @@ def create_check_with_http_info(self, post_check, **kwargs): # noqa: E501,D401, header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501 ['application/json']) # noqa: E501 - # Authentication setting - auth_settings = [] # noqa: E501 - - # urlopen optional setting - urlopen_kw = None - if 'urlopen_kw' in kwargs: - urlopen_kw = kwargs['urlopen_kw'] - - return self.api_client.call_api( - '/api/v2/checks', 'POST', - path_params, - query_params, - header_params, - body=body_params, - post_params=form_params, - files=local_var_files, - response_type='Check', # noqa: E501 - auth_settings=auth_settings, - async_req=local_var_params.get('async_req'), - _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 - _preload_content=local_var_params.get('_preload_content', True), - _request_timeout=local_var_params.get('_request_timeout'), - collection_formats=collection_formats, - urlopen_kw=urlopen_kw) + return local_var_params, path_params, query_params, header_params, body_params def delete_checks_id(self, check_id, **kwargs): # noqa: E501,D401,D403 """Delete a check. @@ -173,30 +183,68 @@ def delete_checks_id_with_http_info(self, check_id, **kwargs): # noqa: E501,D40 If the method is called asynchronously, returns the request thread. """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._delete_checks_id_prepare(check_id, **kwargs) + + return self.api_client.call_api( + '/api/v2/checks/{checkID}', 'DELETE', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type=None, # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + async def delete_checks_id_async(self, check_id, **kwargs): # noqa: E501,D401,D403 + """Delete a check. + + This method makes an asynchronous HTTP request. + + :param async_req bool + :param str check_id: The check ID. (required) + :param str zap_trace_span: OpenTracing span context + :return: None + If the method is called asynchronously, + returns the request thread. + """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._delete_checks_id_prepare(check_id, **kwargs) + + return await self.api_client.call_api( + '/api/v2/checks/{checkID}', 'DELETE', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type=None, # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + def _delete_checks_id_prepare(self, check_id, **kwargs): # noqa: E501,D401,D403 local_var_params = locals() all_params = ['check_id', 'zap_trace_span'] # noqa: E501 - all_params.append('async_req') - all_params.append('_return_http_data_only') - all_params.append('_preload_content') - all_params.append('_request_timeout') - all_params.append('urlopen_kw') - - for key, val in six.iteritems(local_var_params['kwargs']): - if key not in all_params: - raise TypeError( - "Got an unexpected keyword argument '%s'" - " to method delete_checks_id" % key - ) - local_var_params[key] = val - del local_var_params['kwargs'] + self._check_operation_params('delete_checks_id', all_params, local_var_params) # verify the required parameter 'check_id' is set if ('check_id' not in local_var_params or local_var_params['check_id'] is None): raise ValueError("Missing the required parameter `check_id` when calling `delete_checks_id`") # noqa: E501 - collection_formats = {} - path_params = {} if 'check_id' in local_var_params: path_params['checkID'] = local_var_params['check_id'] # noqa: E501 @@ -207,38 +255,12 @@ def delete_checks_id_with_http_info(self, check_id, **kwargs): # noqa: E501,D40 if 'zap_trace_span' in local_var_params: header_params['Zap-Trace-Span'] = local_var_params['zap_trace_span'] # noqa: E501 - form_params = [] - local_var_files = {} - body_params = None # HTTP header `Accept` header_params['Accept'] = self.api_client.select_header_accept( ['application/json']) # noqa: E501 - # Authentication setting - auth_settings = [] # noqa: E501 - - # urlopen optional setting - urlopen_kw = None - if 'urlopen_kw' in kwargs: - urlopen_kw = kwargs['urlopen_kw'] - - return self.api_client.call_api( - '/api/v2/checks/{checkID}', 'DELETE', - path_params, - query_params, - header_params, - body=body_params, - post_params=form_params, - files=local_var_files, - response_type=None, # noqa: E501 - auth_settings=auth_settings, - async_req=local_var_params.get('async_req'), - _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 - _preload_content=local_var_params.get('_preload_content', True), - _request_timeout=local_var_params.get('_request_timeout'), - collection_formats=collection_formats, - urlopen_kw=urlopen_kw) + return local_var_params, path_params, query_params, header_params, body_params def delete_checks_id_labels_id(self, check_id, label_id, **kwargs): # noqa: E501,D401,D403 """Delete label from a check. @@ -279,23 +301,64 @@ def delete_checks_id_labels_id_with_http_info(self, check_id, label_id, **kwargs If the method is called asynchronously, returns the request thread. """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._delete_checks_id_labels_id_prepare(check_id, label_id, **kwargs) + + return self.api_client.call_api( + '/api/v2/checks/{checkID}/labels/{labelID}', 'DELETE', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type=None, # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + async def delete_checks_id_labels_id_async(self, check_id, label_id, **kwargs): # noqa: E501,D401,D403 + """Delete label from a check. + + This method makes an asynchronous HTTP request. + + :param async_req bool + :param str check_id: The check ID. (required) + :param str label_id: The ID of the label to delete. (required) + :param str zap_trace_span: OpenTracing span context + :return: None + If the method is called asynchronously, + returns the request thread. + """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._delete_checks_id_labels_id_prepare(check_id, label_id, **kwargs) + + return await self.api_client.call_api( + '/api/v2/checks/{checkID}/labels/{labelID}', 'DELETE', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type=None, # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + def _delete_checks_id_labels_id_prepare(self, check_id, label_id, **kwargs): # noqa: E501,D401,D403 local_var_params = locals() all_params = ['check_id', 'label_id', 'zap_trace_span'] # noqa: E501 - all_params.append('async_req') - all_params.append('_return_http_data_only') - all_params.append('_preload_content') - all_params.append('_request_timeout') - all_params.append('urlopen_kw') - - for key, val in six.iteritems(local_var_params['kwargs']): - if key not in all_params: - raise TypeError( - "Got an unexpected keyword argument '%s'" - " to method delete_checks_id_labels_id" % key - ) - local_var_params[key] = val - del local_var_params['kwargs'] + self._check_operation_params('delete_checks_id_labels_id', all_params, local_var_params) # verify the required parameter 'check_id' is set if ('check_id' not in local_var_params or local_var_params['check_id'] is None): @@ -305,8 +368,6 @@ def delete_checks_id_labels_id_with_http_info(self, check_id, label_id, **kwargs local_var_params['label_id'] is None): raise ValueError("Missing the required parameter `label_id` when calling `delete_checks_id_labels_id`") # noqa: E501 - collection_formats = {} - path_params = {} if 'check_id' in local_var_params: path_params['checkID'] = local_var_params['check_id'] # noqa: E501 @@ -319,38 +380,12 @@ def delete_checks_id_labels_id_with_http_info(self, check_id, label_id, **kwargs if 'zap_trace_span' in local_var_params: header_params['Zap-Trace-Span'] = local_var_params['zap_trace_span'] # noqa: E501 - form_params = [] - local_var_files = {} - body_params = None # HTTP header `Accept` header_params['Accept'] = self.api_client.select_header_accept( ['application/json']) # noqa: E501 - # Authentication setting - auth_settings = [] # noqa: E501 - - # urlopen optional setting - urlopen_kw = None - if 'urlopen_kw' in kwargs: - urlopen_kw = kwargs['urlopen_kw'] - - return self.api_client.call_api( - '/api/v2/checks/{checkID}/labels/{labelID}', 'DELETE', - path_params, - query_params, - header_params, - body=body_params, - post_params=form_params, - files=local_var_files, - response_type=None, # noqa: E501 - auth_settings=auth_settings, - async_req=local_var_params.get('async_req'), - _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 - _preload_content=local_var_params.get('_preload_content', True), - _request_timeout=local_var_params.get('_request_timeout'), - collection_formats=collection_formats, - urlopen_kw=urlopen_kw) + return local_var_params, path_params, query_params, header_params, body_params def get_checks(self, org_id, **kwargs): # noqa: E501,D401,D403 """List all checks. @@ -393,23 +428,65 @@ def get_checks_with_http_info(self, org_id, **kwargs): # noqa: E501,D401,D403 If the method is called asynchronously, returns the request thread. """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._get_checks_prepare(org_id, **kwargs) + + return self.api_client.call_api( + '/api/v2/checks', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='Checks', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + async def get_checks_async(self, org_id, **kwargs): # noqa: E501,D401,D403 + """List all checks. + + This method makes an asynchronous HTTP request. + + :param async_req bool + :param str org_id: Only show checks that belong to a specific organization ID. (required) + :param str zap_trace_span: OpenTracing span context + :param int offset: + :param int limit: + :return: Checks + If the method is called asynchronously, + returns the request thread. + """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._get_checks_prepare(org_id, **kwargs) + + return await self.api_client.call_api( + '/api/v2/checks', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='Checks', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + def _get_checks_prepare(self, org_id, **kwargs): # noqa: E501,D401,D403 local_var_params = locals() all_params = ['org_id', 'zap_trace_span', 'offset', 'limit'] # noqa: E501 - all_params.append('async_req') - all_params.append('_return_http_data_only') - all_params.append('_preload_content') - all_params.append('_request_timeout') - all_params.append('urlopen_kw') - - for key, val in six.iteritems(local_var_params['kwargs']): - if key not in all_params: - raise TypeError( - "Got an unexpected keyword argument '%s'" - " to method get_checks" % key - ) - local_var_params[key] = val - del local_var_params['kwargs'] + self._check_operation_params('get_checks', all_params, local_var_params) # verify the required parameter 'org_id' is set if ('org_id' not in local_var_params or local_var_params['org_id'] is None): @@ -421,8 +498,6 @@ def get_checks_with_http_info(self, org_id, **kwargs): # noqa: E501,D401,D403 raise ValueError("Invalid value for parameter `limit` when calling `get_checks`, must be a value less than or equal to `100`") # noqa: E501 if 'limit' in local_var_params and local_var_params['limit'] < 1: # noqa: E501 raise ValueError("Invalid value for parameter `limit` when calling `get_checks`, must be a value greater than or equal to `1`") # noqa: E501 - collection_formats = {} - path_params = {} query_params = [] @@ -437,38 +512,12 @@ def get_checks_with_http_info(self, org_id, **kwargs): # noqa: E501,D401,D403 if 'zap_trace_span' in local_var_params: header_params['Zap-Trace-Span'] = local_var_params['zap_trace_span'] # noqa: E501 - form_params = [] - local_var_files = {} - body_params = None # HTTP header `Accept` header_params['Accept'] = self.api_client.select_header_accept( ['application/json']) # noqa: E501 - # Authentication setting - auth_settings = [] # noqa: E501 - - # urlopen optional setting - urlopen_kw = None - if 'urlopen_kw' in kwargs: - urlopen_kw = kwargs['urlopen_kw'] - - return self.api_client.call_api( - '/api/v2/checks', 'GET', - path_params, - query_params, - header_params, - body=body_params, - post_params=form_params, - files=local_var_files, - response_type='Checks', # noqa: E501 - auth_settings=auth_settings, - async_req=local_var_params.get('async_req'), - _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 - _preload_content=local_var_params.get('_preload_content', True), - _request_timeout=local_var_params.get('_request_timeout'), - collection_formats=collection_formats, - urlopen_kw=urlopen_kw) + return local_var_params, path_params, query_params, header_params, body_params def get_checks_id(self, check_id, **kwargs): # noqa: E501,D401,D403 """Retrieve a check. @@ -507,30 +556,68 @@ def get_checks_id_with_http_info(self, check_id, **kwargs): # noqa: E501,D401,D If the method is called asynchronously, returns the request thread. """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._get_checks_id_prepare(check_id, **kwargs) + + return self.api_client.call_api( + '/api/v2/checks/{checkID}', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='Check', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + async def get_checks_id_async(self, check_id, **kwargs): # noqa: E501,D401,D403 + """Retrieve a check. + + This method makes an asynchronous HTTP request. + + :param async_req bool + :param str check_id: The check ID. (required) + :param str zap_trace_span: OpenTracing span context + :return: Check + If the method is called asynchronously, + returns the request thread. + """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._get_checks_id_prepare(check_id, **kwargs) + + return await self.api_client.call_api( + '/api/v2/checks/{checkID}', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='Check', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + def _get_checks_id_prepare(self, check_id, **kwargs): # noqa: E501,D401,D403 local_var_params = locals() all_params = ['check_id', 'zap_trace_span'] # noqa: E501 - all_params.append('async_req') - all_params.append('_return_http_data_only') - all_params.append('_preload_content') - all_params.append('_request_timeout') - all_params.append('urlopen_kw') - - for key, val in six.iteritems(local_var_params['kwargs']): - if key not in all_params: - raise TypeError( - "Got an unexpected keyword argument '%s'" - " to method get_checks_id" % key - ) - local_var_params[key] = val - del local_var_params['kwargs'] + self._check_operation_params('get_checks_id', all_params, local_var_params) # verify the required parameter 'check_id' is set if ('check_id' not in local_var_params or local_var_params['check_id'] is None): raise ValueError("Missing the required parameter `check_id` when calling `get_checks_id`") # noqa: E501 - collection_formats = {} - path_params = {} if 'check_id' in local_var_params: path_params['checkID'] = local_var_params['check_id'] # noqa: E501 @@ -541,38 +628,12 @@ def get_checks_id_with_http_info(self, check_id, **kwargs): # noqa: E501,D401,D if 'zap_trace_span' in local_var_params: header_params['Zap-Trace-Span'] = local_var_params['zap_trace_span'] # noqa: E501 - form_params = [] - local_var_files = {} - body_params = None # HTTP header `Accept` header_params['Accept'] = self.api_client.select_header_accept( ['application/json']) # noqa: E501 - # Authentication setting - auth_settings = [] # noqa: E501 - - # urlopen optional setting - urlopen_kw = None - if 'urlopen_kw' in kwargs: - urlopen_kw = kwargs['urlopen_kw'] - - return self.api_client.call_api( - '/api/v2/checks/{checkID}', 'GET', - path_params, - query_params, - header_params, - body=body_params, - post_params=form_params, - files=local_var_files, - response_type='Check', # noqa: E501 - auth_settings=auth_settings, - async_req=local_var_params.get('async_req'), - _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 - _preload_content=local_var_params.get('_preload_content', True), - _request_timeout=local_var_params.get('_request_timeout'), - collection_formats=collection_formats, - urlopen_kw=urlopen_kw) + return local_var_params, path_params, query_params, header_params, body_params def get_checks_id_labels(self, check_id, **kwargs): # noqa: E501,D401,D403 """List all labels for a check. @@ -611,30 +672,68 @@ def get_checks_id_labels_with_http_info(self, check_id, **kwargs): # noqa: E501 If the method is called asynchronously, returns the request thread. """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._get_checks_id_labels_prepare(check_id, **kwargs) + + return self.api_client.call_api( + '/api/v2/checks/{checkID}/labels', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='LabelsResponse', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + async def get_checks_id_labels_async(self, check_id, **kwargs): # noqa: E501,D401,D403 + """List all labels for a check. + + This method makes an asynchronous HTTP request. + + :param async_req bool + :param str check_id: The check ID. (required) + :param str zap_trace_span: OpenTracing span context + :return: LabelsResponse + If the method is called asynchronously, + returns the request thread. + """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._get_checks_id_labels_prepare(check_id, **kwargs) + + return await self.api_client.call_api( + '/api/v2/checks/{checkID}/labels', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='LabelsResponse', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + def _get_checks_id_labels_prepare(self, check_id, **kwargs): # noqa: E501,D401,D403 local_var_params = locals() all_params = ['check_id', 'zap_trace_span'] # noqa: E501 - all_params.append('async_req') - all_params.append('_return_http_data_only') - all_params.append('_preload_content') - all_params.append('_request_timeout') - all_params.append('urlopen_kw') - - for key, val in six.iteritems(local_var_params['kwargs']): - if key not in all_params: - raise TypeError( - "Got an unexpected keyword argument '%s'" - " to method get_checks_id_labels" % key - ) - local_var_params[key] = val - del local_var_params['kwargs'] + self._check_operation_params('get_checks_id_labels', all_params, local_var_params) # verify the required parameter 'check_id' is set if ('check_id' not in local_var_params or local_var_params['check_id'] is None): raise ValueError("Missing the required parameter `check_id` when calling `get_checks_id_labels`") # noqa: E501 - collection_formats = {} - path_params = {} if 'check_id' in local_var_params: path_params['checkID'] = local_var_params['check_id'] # noqa: E501 @@ -645,38 +744,12 @@ def get_checks_id_labels_with_http_info(self, check_id, **kwargs): # noqa: E501 if 'zap_trace_span' in local_var_params: header_params['Zap-Trace-Span'] = local_var_params['zap_trace_span'] # noqa: E501 - form_params = [] - local_var_files = {} - body_params = None # HTTP header `Accept` header_params['Accept'] = self.api_client.select_header_accept( ['application/json']) # noqa: E501 - # Authentication setting - auth_settings = [] # noqa: E501 - - # urlopen optional setting - urlopen_kw = None - if 'urlopen_kw' in kwargs: - urlopen_kw = kwargs['urlopen_kw'] - - return self.api_client.call_api( - '/api/v2/checks/{checkID}/labels', 'GET', - path_params, - query_params, - header_params, - body=body_params, - post_params=form_params, - files=local_var_files, - response_type='LabelsResponse', # noqa: E501 - auth_settings=auth_settings, - async_req=local_var_params.get('async_req'), - _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 - _preload_content=local_var_params.get('_preload_content', True), - _request_timeout=local_var_params.get('_request_timeout'), - collection_formats=collection_formats, - urlopen_kw=urlopen_kw) + return local_var_params, path_params, query_params, header_params, body_params def get_checks_id_query(self, check_id, **kwargs): # noqa: E501,D401,D403 """Retrieve a check query. @@ -715,30 +788,68 @@ def get_checks_id_query_with_http_info(self, check_id, **kwargs): # noqa: E501, If the method is called asynchronously, returns the request thread. """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._get_checks_id_query_prepare(check_id, **kwargs) + + return self.api_client.call_api( + '/api/v2/checks/{checkID}/query', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='FluxResponse', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + async def get_checks_id_query_async(self, check_id, **kwargs): # noqa: E501,D401,D403 + """Retrieve a check query. + + This method makes an asynchronous HTTP request. + + :param async_req bool + :param str check_id: The check ID. (required) + :param str zap_trace_span: OpenTracing span context + :return: FluxResponse + If the method is called asynchronously, + returns the request thread. + """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._get_checks_id_query_prepare(check_id, **kwargs) + + return await self.api_client.call_api( + '/api/v2/checks/{checkID}/query', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='FluxResponse', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + def _get_checks_id_query_prepare(self, check_id, **kwargs): # noqa: E501,D401,D403 local_var_params = locals() all_params = ['check_id', 'zap_trace_span'] # noqa: E501 - all_params.append('async_req') - all_params.append('_return_http_data_only') - all_params.append('_preload_content') - all_params.append('_request_timeout') - all_params.append('urlopen_kw') - - for key, val in six.iteritems(local_var_params['kwargs']): - if key not in all_params: - raise TypeError( - "Got an unexpected keyword argument '%s'" - " to method get_checks_id_query" % key - ) - local_var_params[key] = val - del local_var_params['kwargs'] + self._check_operation_params('get_checks_id_query', all_params, local_var_params) # verify the required parameter 'check_id' is set if ('check_id' not in local_var_params or local_var_params['check_id'] is None): raise ValueError("Missing the required parameter `check_id` when calling `get_checks_id_query`") # noqa: E501 - collection_formats = {} - path_params = {} if 'check_id' in local_var_params: path_params['checkID'] = local_var_params['check_id'] # noqa: E501 @@ -749,38 +860,12 @@ def get_checks_id_query_with_http_info(self, check_id, **kwargs): # noqa: E501, if 'zap_trace_span' in local_var_params: header_params['Zap-Trace-Span'] = local_var_params['zap_trace_span'] # noqa: E501 - form_params = [] - local_var_files = {} - body_params = None # HTTP header `Accept` header_params['Accept'] = self.api_client.select_header_accept( ['application/json']) # noqa: E501 - # Authentication setting - auth_settings = [] # noqa: E501 - - # urlopen optional setting - urlopen_kw = None - if 'urlopen_kw' in kwargs: - urlopen_kw = kwargs['urlopen_kw'] - - return self.api_client.call_api( - '/api/v2/checks/{checkID}/query', 'GET', - path_params, - query_params, - header_params, - body=body_params, - post_params=form_params, - files=local_var_files, - response_type='FluxResponse', # noqa: E501 - auth_settings=auth_settings, - async_req=local_var_params.get('async_req'), - _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 - _preload_content=local_var_params.get('_preload_content', True), - _request_timeout=local_var_params.get('_request_timeout'), - collection_formats=collection_formats, - urlopen_kw=urlopen_kw) + return local_var_params, path_params, query_params, header_params, body_params def patch_checks_id(self, check_id, check_patch, **kwargs): # noqa: E501,D401,D403 """Update a check. @@ -821,23 +906,64 @@ def patch_checks_id_with_http_info(self, check_id, check_patch, **kwargs): # no If the method is called asynchronously, returns the request thread. """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._patch_checks_id_prepare(check_id, check_patch, **kwargs) + + return self.api_client.call_api( + '/api/v2/checks/{checkID}', 'PATCH', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='Check', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + async def patch_checks_id_async(self, check_id, check_patch, **kwargs): # noqa: E501,D401,D403 + """Update a check. + + This method makes an asynchronous HTTP request. + + :param async_req bool + :param str check_id: The check ID. (required) + :param CheckPatch check_patch: Check update to apply (required) + :param str zap_trace_span: OpenTracing span context + :return: Check + If the method is called asynchronously, + returns the request thread. + """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._patch_checks_id_prepare(check_id, check_patch, **kwargs) + + return await self.api_client.call_api( + '/api/v2/checks/{checkID}', 'PATCH', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='Check', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + def _patch_checks_id_prepare(self, check_id, check_patch, **kwargs): # noqa: E501,D401,D403 local_var_params = locals() all_params = ['check_id', 'check_patch', 'zap_trace_span'] # noqa: E501 - all_params.append('async_req') - all_params.append('_return_http_data_only') - all_params.append('_preload_content') - all_params.append('_request_timeout') - all_params.append('urlopen_kw') - - for key, val in six.iteritems(local_var_params['kwargs']): - if key not in all_params: - raise TypeError( - "Got an unexpected keyword argument '%s'" - " to method patch_checks_id" % key - ) - local_var_params[key] = val - del local_var_params['kwargs'] + self._check_operation_params('patch_checks_id', all_params, local_var_params) # verify the required parameter 'check_id' is set if ('check_id' not in local_var_params or local_var_params['check_id'] is None): @@ -847,8 +973,6 @@ def patch_checks_id_with_http_info(self, check_id, check_patch, **kwargs): # no local_var_params['check_patch'] is None): raise ValueError("Missing the required parameter `check_patch` when calling `patch_checks_id`") # noqa: E501 - collection_formats = {} - path_params = {} if 'check_id' in local_var_params: path_params['checkID'] = local_var_params['check_id'] # noqa: E501 @@ -859,9 +983,6 @@ def patch_checks_id_with_http_info(self, check_id, check_patch, **kwargs): # no if 'zap_trace_span' in local_var_params: header_params['Zap-Trace-Span'] = local_var_params['zap_trace_span'] # noqa: E501 - form_params = [] - local_var_files = {} - body_params = None if 'check_patch' in local_var_params: body_params = local_var_params['check_patch'] @@ -873,30 +994,7 @@ def patch_checks_id_with_http_info(self, check_id, check_patch, **kwargs): # no header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501 ['application/json']) # noqa: E501 - # Authentication setting - auth_settings = [] # noqa: E501 - - # urlopen optional setting - urlopen_kw = None - if 'urlopen_kw' in kwargs: - urlopen_kw = kwargs['urlopen_kw'] - - return self.api_client.call_api( - '/api/v2/checks/{checkID}', 'PATCH', - path_params, - query_params, - header_params, - body=body_params, - post_params=form_params, - files=local_var_files, - response_type='Check', # noqa: E501 - auth_settings=auth_settings, - async_req=local_var_params.get('async_req'), - _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 - _preload_content=local_var_params.get('_preload_content', True), - _request_timeout=local_var_params.get('_request_timeout'), - collection_formats=collection_formats, - urlopen_kw=urlopen_kw) + return local_var_params, path_params, query_params, header_params, body_params def post_checks_id_labels(self, check_id, label_mapping, **kwargs): # noqa: E501,D401,D403 """Add a label to a check. @@ -937,23 +1035,64 @@ def post_checks_id_labels_with_http_info(self, check_id, label_mapping, **kwargs If the method is called asynchronously, returns the request thread. """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._post_checks_id_labels_prepare(check_id, label_mapping, **kwargs) + + return self.api_client.call_api( + '/api/v2/checks/{checkID}/labels', 'POST', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='LabelResponse', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + async def post_checks_id_labels_async(self, check_id, label_mapping, **kwargs): # noqa: E501,D401,D403 + """Add a label to a check. + + This method makes an asynchronous HTTP request. + + :param async_req bool + :param str check_id: The check ID. (required) + :param LabelMapping label_mapping: Label to add (required) + :param str zap_trace_span: OpenTracing span context + :return: LabelResponse + If the method is called asynchronously, + returns the request thread. + """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._post_checks_id_labels_prepare(check_id, label_mapping, **kwargs) + + return await self.api_client.call_api( + '/api/v2/checks/{checkID}/labels', 'POST', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='LabelResponse', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + def _post_checks_id_labels_prepare(self, check_id, label_mapping, **kwargs): # noqa: E501,D401,D403 local_var_params = locals() all_params = ['check_id', 'label_mapping', 'zap_trace_span'] # noqa: E501 - all_params.append('async_req') - all_params.append('_return_http_data_only') - all_params.append('_preload_content') - all_params.append('_request_timeout') - all_params.append('urlopen_kw') - - for key, val in six.iteritems(local_var_params['kwargs']): - if key not in all_params: - raise TypeError( - "Got an unexpected keyword argument '%s'" - " to method post_checks_id_labels" % key - ) - local_var_params[key] = val - del local_var_params['kwargs'] + self._check_operation_params('post_checks_id_labels', all_params, local_var_params) # verify the required parameter 'check_id' is set if ('check_id' not in local_var_params or local_var_params['check_id'] is None): @@ -963,8 +1102,6 @@ def post_checks_id_labels_with_http_info(self, check_id, label_mapping, **kwargs local_var_params['label_mapping'] is None): raise ValueError("Missing the required parameter `label_mapping` when calling `post_checks_id_labels`") # noqa: E501 - collection_formats = {} - path_params = {} if 'check_id' in local_var_params: path_params['checkID'] = local_var_params['check_id'] # noqa: E501 @@ -975,9 +1112,6 @@ def post_checks_id_labels_with_http_info(self, check_id, label_mapping, **kwargs if 'zap_trace_span' in local_var_params: header_params['Zap-Trace-Span'] = local_var_params['zap_trace_span'] # noqa: E501 - form_params = [] - local_var_files = {} - body_params = None if 'label_mapping' in local_var_params: body_params = local_var_params['label_mapping'] @@ -989,30 +1123,7 @@ def post_checks_id_labels_with_http_info(self, check_id, label_mapping, **kwargs header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501 ['application/json']) # noqa: E501 - # Authentication setting - auth_settings = [] # noqa: E501 - - # urlopen optional setting - urlopen_kw = None - if 'urlopen_kw' in kwargs: - urlopen_kw = kwargs['urlopen_kw'] - - return self.api_client.call_api( - '/api/v2/checks/{checkID}/labels', 'POST', - path_params, - query_params, - header_params, - body=body_params, - post_params=form_params, - files=local_var_files, - response_type='LabelResponse', # noqa: E501 - auth_settings=auth_settings, - async_req=local_var_params.get('async_req'), - _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 - _preload_content=local_var_params.get('_preload_content', True), - _request_timeout=local_var_params.get('_request_timeout'), - collection_formats=collection_formats, - urlopen_kw=urlopen_kw) + return local_var_params, path_params, query_params, header_params, body_params def put_checks_id(self, check_id, check, **kwargs): # noqa: E501,D401,D403 """Update a check. @@ -1053,23 +1164,64 @@ def put_checks_id_with_http_info(self, check_id, check, **kwargs): # noqa: E501 If the method is called asynchronously, returns the request thread. """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._put_checks_id_prepare(check_id, check, **kwargs) + + return self.api_client.call_api( + '/api/v2/checks/{checkID}', 'PUT', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='Check', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + async def put_checks_id_async(self, check_id, check, **kwargs): # noqa: E501,D401,D403 + """Update a check. + + This method makes an asynchronous HTTP request. + + :param async_req bool + :param str check_id: The check ID. (required) + :param Check check: Check update to apply (required) + :param str zap_trace_span: OpenTracing span context + :return: Check + If the method is called asynchronously, + returns the request thread. + """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._put_checks_id_prepare(check_id, check, **kwargs) + + return await self.api_client.call_api( + '/api/v2/checks/{checkID}', 'PUT', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='Check', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + def _put_checks_id_prepare(self, check_id, check, **kwargs): # noqa: E501,D401,D403 local_var_params = locals() all_params = ['check_id', 'check', 'zap_trace_span'] # noqa: E501 - all_params.append('async_req') - all_params.append('_return_http_data_only') - all_params.append('_preload_content') - all_params.append('_request_timeout') - all_params.append('urlopen_kw') - - for key, val in six.iteritems(local_var_params['kwargs']): - if key not in all_params: - raise TypeError( - "Got an unexpected keyword argument '%s'" - " to method put_checks_id" % key - ) - local_var_params[key] = val - del local_var_params['kwargs'] + self._check_operation_params('put_checks_id', all_params, local_var_params) # verify the required parameter 'check_id' is set if ('check_id' not in local_var_params or local_var_params['check_id'] is None): @@ -1079,8 +1231,6 @@ def put_checks_id_with_http_info(self, check_id, check, **kwargs): # noqa: E501 local_var_params['check'] is None): raise ValueError("Missing the required parameter `check` when calling `put_checks_id`") # noqa: E501 - collection_formats = {} - path_params = {} if 'check_id' in local_var_params: path_params['checkID'] = local_var_params['check_id'] # noqa: E501 @@ -1091,9 +1241,6 @@ def put_checks_id_with_http_info(self, check_id, check, **kwargs): # noqa: E501 if 'zap_trace_span' in local_var_params: header_params['Zap-Trace-Span'] = local_var_params['zap_trace_span'] # noqa: E501 - form_params = [] - local_var_files = {} - body_params = None if 'check' in local_var_params: body_params = local_var_params['check'] @@ -1105,27 +1252,4 @@ def put_checks_id_with_http_info(self, check_id, check, **kwargs): # noqa: E501 header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501 ['application/json']) # noqa: E501 - # Authentication setting - auth_settings = [] # noqa: E501 - - # urlopen optional setting - urlopen_kw = None - if 'urlopen_kw' in kwargs: - urlopen_kw = kwargs['urlopen_kw'] - - return self.api_client.call_api( - '/api/v2/checks/{checkID}', 'PUT', - path_params, - query_params, - header_params, - body=body_params, - post_params=form_params, - files=local_var_files, - response_type='Check', # noqa: E501 - auth_settings=auth_settings, - async_req=local_var_params.get('async_req'), - _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 - _preload_content=local_var_params.get('_preload_content', True), - _request_timeout=local_var_params.get('_request_timeout'), - collection_formats=collection_formats, - urlopen_kw=urlopen_kw) + return local_var_params, path_params, query_params, header_params, body_params diff --git a/influxdb_client/service/config_service.py b/influxdb_client/service/config_service.py index 0f178e56..93cad9fa 100644 --- a/influxdb_client/service/config_service.py +++ b/influxdb_client/service/config_service.py @@ -14,11 +14,10 @@ import re # noqa: F401 -# python 2 and python 3 compatibility library -import six +from influxdb_client.service._base_service import _BaseService -class ConfigService(object): +class ConfigService(_BaseService): """NOTE: This class is auto generated by OpenAPI Generator. Ref: https://openapi-generator.tech @@ -67,25 +66,62 @@ def get_config_with_http_info(self, **kwargs): # noqa: E501,D401,D403 If the method is called asynchronously, returns the request thread. """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._get_config_prepare(**kwargs) + + return self.api_client.call_api( + '/api/v2/config', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='Config', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + async def get_config_async(self, **kwargs): # noqa: E501,D401,D403 + """Get the run-time configuration of the instance. + + This method makes an asynchronous HTTP request. + + :param async_req bool + :param str zap_trace_span: OpenTracing span context + :return: Config + If the method is called asynchronously, + returns the request thread. + """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._get_config_prepare(**kwargs) + + return await self.api_client.call_api( + '/api/v2/config', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='Config', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + def _get_config_prepare(self, **kwargs): # noqa: E501,D401,D403 local_var_params = locals() all_params = ['zap_trace_span'] # noqa: E501 - all_params.append('async_req') - all_params.append('_return_http_data_only') - all_params.append('_preload_content') - all_params.append('_request_timeout') - all_params.append('urlopen_kw') - - for key, val in six.iteritems(local_var_params['kwargs']): - if key not in all_params: - raise TypeError( - "Got an unexpected keyword argument '%s'" - " to method get_config" % key - ) - local_var_params[key] = val - del local_var_params['kwargs'] - - collection_formats = {} + self._check_operation_params('get_config', all_params, local_var_params) path_params = {} @@ -95,35 +131,9 @@ def get_config_with_http_info(self, **kwargs): # noqa: E501,D401,D403 if 'zap_trace_span' in local_var_params: header_params['Zap-Trace-Span'] = local_var_params['zap_trace_span'] # noqa: E501 - form_params = [] - local_var_files = {} - body_params = None # HTTP header `Accept` header_params['Accept'] = self.api_client.select_header_accept( ['application/json']) # noqa: E501 - # Authentication setting - auth_settings = [] # noqa: E501 - - # urlopen optional setting - urlopen_kw = None - if 'urlopen_kw' in kwargs: - urlopen_kw = kwargs['urlopen_kw'] - - return self.api_client.call_api( - '/api/v2/config', 'GET', - path_params, - query_params, - header_params, - body=body_params, - post_params=form_params, - files=local_var_files, - response_type='Config', # noqa: E501 - auth_settings=auth_settings, - async_req=local_var_params.get('async_req'), - _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 - _preload_content=local_var_params.get('_preload_content', True), - _request_timeout=local_var_params.get('_request_timeout'), - collection_formats=collection_formats, - urlopen_kw=urlopen_kw) + return local_var_params, path_params, query_params, header_params, body_params diff --git a/influxdb_client/service/dashboards_service.py b/influxdb_client/service/dashboards_service.py index 0074bfe9..1867b155 100644 --- a/influxdb_client/service/dashboards_service.py +++ b/influxdb_client/service/dashboards_service.py @@ -14,11 +14,10 @@ import re # noqa: F401 -# python 2 and python 3 compatibility library -import six +from influxdb_client.service._base_service import _BaseService -class DashboardsService(object): +class DashboardsService(_BaseService): """NOTE: This class is auto generated by OpenAPI Generator. Ref: https://openapi-generator.tech @@ -69,30 +68,68 @@ def delete_dashboards_id_with_http_info(self, dashboard_id, **kwargs): # noqa: If the method is called asynchronously, returns the request thread. """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._delete_dashboards_id_prepare(dashboard_id, **kwargs) + + return self.api_client.call_api( + '/api/v2/dashboards/{dashboardID}', 'DELETE', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type=None, # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + async def delete_dashboards_id_async(self, dashboard_id, **kwargs): # noqa: E501,D401,D403 + """Delete a dashboard. + + This method makes an asynchronous HTTP request. + + :param async_req bool + :param str dashboard_id: The ID of the dashboard to update. (required) + :param str zap_trace_span: OpenTracing span context + :return: None + If the method is called asynchronously, + returns the request thread. + """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._delete_dashboards_id_prepare(dashboard_id, **kwargs) + + return await self.api_client.call_api( + '/api/v2/dashboards/{dashboardID}', 'DELETE', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type=None, # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + def _delete_dashboards_id_prepare(self, dashboard_id, **kwargs): # noqa: E501,D401,D403 local_var_params = locals() all_params = ['dashboard_id', 'zap_trace_span'] # noqa: E501 - all_params.append('async_req') - all_params.append('_return_http_data_only') - all_params.append('_preload_content') - all_params.append('_request_timeout') - all_params.append('urlopen_kw') - - for key, val in six.iteritems(local_var_params['kwargs']): - if key not in all_params: - raise TypeError( - "Got an unexpected keyword argument '%s'" - " to method delete_dashboards_id" % key - ) - local_var_params[key] = val - del local_var_params['kwargs'] + self._check_operation_params('delete_dashboards_id', all_params, local_var_params) # verify the required parameter 'dashboard_id' is set if ('dashboard_id' not in local_var_params or local_var_params['dashboard_id'] is None): raise ValueError("Missing the required parameter `dashboard_id` when calling `delete_dashboards_id`") # noqa: E501 - collection_formats = {} - path_params = {} if 'dashboard_id' in local_var_params: path_params['dashboardID'] = local_var_params['dashboard_id'] # noqa: E501 @@ -103,38 +140,12 @@ def delete_dashboards_id_with_http_info(self, dashboard_id, **kwargs): # noqa: if 'zap_trace_span' in local_var_params: header_params['Zap-Trace-Span'] = local_var_params['zap_trace_span'] # noqa: E501 - form_params = [] - local_var_files = {} - body_params = None # HTTP header `Accept` header_params['Accept'] = self.api_client.select_header_accept( ['application/json']) # noqa: E501 - # Authentication setting - auth_settings = [] # noqa: E501 - - # urlopen optional setting - urlopen_kw = None - if 'urlopen_kw' in kwargs: - urlopen_kw = kwargs['urlopen_kw'] - - return self.api_client.call_api( - '/api/v2/dashboards/{dashboardID}', 'DELETE', - path_params, - query_params, - header_params, - body=body_params, - post_params=form_params, - files=local_var_files, - response_type=None, # noqa: E501 - auth_settings=auth_settings, - async_req=local_var_params.get('async_req'), - _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 - _preload_content=local_var_params.get('_preload_content', True), - _request_timeout=local_var_params.get('_request_timeout'), - collection_formats=collection_formats, - urlopen_kw=urlopen_kw) + return local_var_params, path_params, query_params, header_params, body_params def delete_dashboards_id_cells_id(self, dashboard_id, cell_id, **kwargs): # noqa: E501,D401,D403 """Delete a dashboard cell. @@ -175,23 +186,64 @@ def delete_dashboards_id_cells_id_with_http_info(self, dashboard_id, cell_id, ** If the method is called asynchronously, returns the request thread. """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._delete_dashboards_id_cells_id_prepare(dashboard_id, cell_id, **kwargs) + + return self.api_client.call_api( + '/api/v2/dashboards/{dashboardID}/cells/{cellID}', 'DELETE', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type=None, # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + async def delete_dashboards_id_cells_id_async(self, dashboard_id, cell_id, **kwargs): # noqa: E501,D401,D403 + """Delete a dashboard cell. + + This method makes an asynchronous HTTP request. + + :param async_req bool + :param str dashboard_id: The ID of the dashboard to delete. (required) + :param str cell_id: The ID of the cell to delete. (required) + :param str zap_trace_span: OpenTracing span context + :return: None + If the method is called asynchronously, + returns the request thread. + """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._delete_dashboards_id_cells_id_prepare(dashboard_id, cell_id, **kwargs) + + return await self.api_client.call_api( + '/api/v2/dashboards/{dashboardID}/cells/{cellID}', 'DELETE', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type=None, # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + def _delete_dashboards_id_cells_id_prepare(self, dashboard_id, cell_id, **kwargs): # noqa: E501,D401,D403 local_var_params = locals() all_params = ['dashboard_id', 'cell_id', 'zap_trace_span'] # noqa: E501 - all_params.append('async_req') - all_params.append('_return_http_data_only') - all_params.append('_preload_content') - all_params.append('_request_timeout') - all_params.append('urlopen_kw') - - for key, val in six.iteritems(local_var_params['kwargs']): - if key not in all_params: - raise TypeError( - "Got an unexpected keyword argument '%s'" - " to method delete_dashboards_id_cells_id" % key - ) - local_var_params[key] = val - del local_var_params['kwargs'] + self._check_operation_params('delete_dashboards_id_cells_id', all_params, local_var_params) # verify the required parameter 'dashboard_id' is set if ('dashboard_id' not in local_var_params or local_var_params['dashboard_id'] is None): @@ -201,8 +253,6 @@ def delete_dashboards_id_cells_id_with_http_info(self, dashboard_id, cell_id, ** local_var_params['cell_id'] is None): raise ValueError("Missing the required parameter `cell_id` when calling `delete_dashboards_id_cells_id`") # noqa: E501 - collection_formats = {} - path_params = {} if 'dashboard_id' in local_var_params: path_params['dashboardID'] = local_var_params['dashboard_id'] # noqa: E501 @@ -215,38 +265,12 @@ def delete_dashboards_id_cells_id_with_http_info(self, dashboard_id, cell_id, ** if 'zap_trace_span' in local_var_params: header_params['Zap-Trace-Span'] = local_var_params['zap_trace_span'] # noqa: E501 - form_params = [] - local_var_files = {} - body_params = None # HTTP header `Accept` header_params['Accept'] = self.api_client.select_header_accept( ['application/json']) # noqa: E501 - # Authentication setting - auth_settings = [] # noqa: E501 - - # urlopen optional setting - urlopen_kw = None - if 'urlopen_kw' in kwargs: - urlopen_kw = kwargs['urlopen_kw'] - - return self.api_client.call_api( - '/api/v2/dashboards/{dashboardID}/cells/{cellID}', 'DELETE', - path_params, - query_params, - header_params, - body=body_params, - post_params=form_params, - files=local_var_files, - response_type=None, # noqa: E501 - auth_settings=auth_settings, - async_req=local_var_params.get('async_req'), - _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 - _preload_content=local_var_params.get('_preload_content', True), - _request_timeout=local_var_params.get('_request_timeout'), - collection_formats=collection_formats, - urlopen_kw=urlopen_kw) + return local_var_params, path_params, query_params, header_params, body_params def delete_dashboards_id_labels_id(self, dashboard_id, label_id, **kwargs): # noqa: E501,D401,D403 """Delete a label from a dashboard. @@ -287,23 +311,64 @@ def delete_dashboards_id_labels_id_with_http_info(self, dashboard_id, label_id, If the method is called asynchronously, returns the request thread. """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._delete_dashboards_id_labels_id_prepare(dashboard_id, label_id, **kwargs) + + return self.api_client.call_api( + '/api/v2/dashboards/{dashboardID}/labels/{labelID}', 'DELETE', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type=None, # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + async def delete_dashboards_id_labels_id_async(self, dashboard_id, label_id, **kwargs): # noqa: E501,D401,D403 + """Delete a label from a dashboard. + + This method makes an asynchronous HTTP request. + + :param async_req bool + :param str dashboard_id: The dashboard ID. (required) + :param str label_id: The ID of the label to delete. (required) + :param str zap_trace_span: OpenTracing span context + :return: None + If the method is called asynchronously, + returns the request thread. + """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._delete_dashboards_id_labels_id_prepare(dashboard_id, label_id, **kwargs) + + return await self.api_client.call_api( + '/api/v2/dashboards/{dashboardID}/labels/{labelID}', 'DELETE', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type=None, # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + def _delete_dashboards_id_labels_id_prepare(self, dashboard_id, label_id, **kwargs): # noqa: E501,D401,D403 local_var_params = locals() all_params = ['dashboard_id', 'label_id', 'zap_trace_span'] # noqa: E501 - all_params.append('async_req') - all_params.append('_return_http_data_only') - all_params.append('_preload_content') - all_params.append('_request_timeout') - all_params.append('urlopen_kw') - - for key, val in six.iteritems(local_var_params['kwargs']): - if key not in all_params: - raise TypeError( - "Got an unexpected keyword argument '%s'" - " to method delete_dashboards_id_labels_id" % key - ) - local_var_params[key] = val - del local_var_params['kwargs'] + self._check_operation_params('delete_dashboards_id_labels_id', all_params, local_var_params) # verify the required parameter 'dashboard_id' is set if ('dashboard_id' not in local_var_params or local_var_params['dashboard_id'] is None): @@ -313,8 +378,6 @@ def delete_dashboards_id_labels_id_with_http_info(self, dashboard_id, label_id, local_var_params['label_id'] is None): raise ValueError("Missing the required parameter `label_id` when calling `delete_dashboards_id_labels_id`") # noqa: E501 - collection_formats = {} - path_params = {} if 'dashboard_id' in local_var_params: path_params['dashboardID'] = local_var_params['dashboard_id'] # noqa: E501 @@ -327,38 +390,12 @@ def delete_dashboards_id_labels_id_with_http_info(self, dashboard_id, label_id, if 'zap_trace_span' in local_var_params: header_params['Zap-Trace-Span'] = local_var_params['zap_trace_span'] # noqa: E501 - form_params = [] - local_var_files = {} - body_params = None # HTTP header `Accept` header_params['Accept'] = self.api_client.select_header_accept( ['application/json']) # noqa: E501 - # Authentication setting - auth_settings = [] # noqa: E501 - - # urlopen optional setting - urlopen_kw = None - if 'urlopen_kw' in kwargs: - urlopen_kw = kwargs['urlopen_kw'] - - return self.api_client.call_api( - '/api/v2/dashboards/{dashboardID}/labels/{labelID}', 'DELETE', - path_params, - query_params, - header_params, - body=body_params, - post_params=form_params, - files=local_var_files, - response_type=None, # noqa: E501 - auth_settings=auth_settings, - async_req=local_var_params.get('async_req'), - _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 - _preload_content=local_var_params.get('_preload_content', True), - _request_timeout=local_var_params.get('_request_timeout'), - collection_formats=collection_formats, - urlopen_kw=urlopen_kw) + return local_var_params, path_params, query_params, header_params, body_params def delete_dashboards_id_members_id(self, user_id, dashboard_id, **kwargs): # noqa: E501,D401,D403 """Remove a member from a dashboard. @@ -399,23 +436,64 @@ def delete_dashboards_id_members_id_with_http_info(self, user_id, dashboard_id, If the method is called asynchronously, returns the request thread. """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._delete_dashboards_id_members_id_prepare(user_id, dashboard_id, **kwargs) + + return self.api_client.call_api( + '/api/v2/dashboards/{dashboardID}/members/{userID}', 'DELETE', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type=None, # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + async def delete_dashboards_id_members_id_async(self, user_id, dashboard_id, **kwargs): # noqa: E501,D401,D403 + """Remove a member from a dashboard. + + This method makes an asynchronous HTTP request. + + :param async_req bool + :param str user_id: The ID of the member to remove. (required) + :param str dashboard_id: The dashboard ID. (required) + :param str zap_trace_span: OpenTracing span context + :return: None + If the method is called asynchronously, + returns the request thread. + """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._delete_dashboards_id_members_id_prepare(user_id, dashboard_id, **kwargs) + + return await self.api_client.call_api( + '/api/v2/dashboards/{dashboardID}/members/{userID}', 'DELETE', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type=None, # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + def _delete_dashboards_id_members_id_prepare(self, user_id, dashboard_id, **kwargs): # noqa: E501,D401,D403 local_var_params = locals() all_params = ['user_id', 'dashboard_id', 'zap_trace_span'] # noqa: E501 - all_params.append('async_req') - all_params.append('_return_http_data_only') - all_params.append('_preload_content') - all_params.append('_request_timeout') - all_params.append('urlopen_kw') - - for key, val in six.iteritems(local_var_params['kwargs']): - if key not in all_params: - raise TypeError( - "Got an unexpected keyword argument '%s'" - " to method delete_dashboards_id_members_id" % key - ) - local_var_params[key] = val - del local_var_params['kwargs'] + self._check_operation_params('delete_dashboards_id_members_id', all_params, local_var_params) # verify the required parameter 'user_id' is set if ('user_id' not in local_var_params or local_var_params['user_id'] is None): @@ -425,8 +503,6 @@ def delete_dashboards_id_members_id_with_http_info(self, user_id, dashboard_id, local_var_params['dashboard_id'] is None): raise ValueError("Missing the required parameter `dashboard_id` when calling `delete_dashboards_id_members_id`") # noqa: E501 - collection_formats = {} - path_params = {} if 'user_id' in local_var_params: path_params['userID'] = local_var_params['user_id'] # noqa: E501 @@ -439,38 +515,12 @@ def delete_dashboards_id_members_id_with_http_info(self, user_id, dashboard_id, if 'zap_trace_span' in local_var_params: header_params['Zap-Trace-Span'] = local_var_params['zap_trace_span'] # noqa: E501 - form_params = [] - local_var_files = {} - body_params = None # HTTP header `Accept` header_params['Accept'] = self.api_client.select_header_accept( ['application/json']) # noqa: E501 - # Authentication setting - auth_settings = [] # noqa: E501 - - # urlopen optional setting - urlopen_kw = None - if 'urlopen_kw' in kwargs: - urlopen_kw = kwargs['urlopen_kw'] - - return self.api_client.call_api( - '/api/v2/dashboards/{dashboardID}/members/{userID}', 'DELETE', - path_params, - query_params, - header_params, - body=body_params, - post_params=form_params, - files=local_var_files, - response_type=None, # noqa: E501 - auth_settings=auth_settings, - async_req=local_var_params.get('async_req'), - _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 - _preload_content=local_var_params.get('_preload_content', True), - _request_timeout=local_var_params.get('_request_timeout'), - collection_formats=collection_formats, - urlopen_kw=urlopen_kw) + return local_var_params, path_params, query_params, header_params, body_params def delete_dashboards_id_owners_id(self, user_id, dashboard_id, **kwargs): # noqa: E501,D401,D403 """Remove an owner from a dashboard. @@ -511,23 +561,64 @@ def delete_dashboards_id_owners_id_with_http_info(self, user_id, dashboard_id, * If the method is called asynchronously, returns the request thread. """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._delete_dashboards_id_owners_id_prepare(user_id, dashboard_id, **kwargs) + + return self.api_client.call_api( + '/api/v2/dashboards/{dashboardID}/owners/{userID}', 'DELETE', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type=None, # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + async def delete_dashboards_id_owners_id_async(self, user_id, dashboard_id, **kwargs): # noqa: E501,D401,D403 + """Remove an owner from a dashboard. + + This method makes an asynchronous HTTP request. + + :param async_req bool + :param str user_id: The ID of the owner to remove. (required) + :param str dashboard_id: The dashboard ID. (required) + :param str zap_trace_span: OpenTracing span context + :return: None + If the method is called asynchronously, + returns the request thread. + """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._delete_dashboards_id_owners_id_prepare(user_id, dashboard_id, **kwargs) + + return await self.api_client.call_api( + '/api/v2/dashboards/{dashboardID}/owners/{userID}', 'DELETE', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type=None, # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + def _delete_dashboards_id_owners_id_prepare(self, user_id, dashboard_id, **kwargs): # noqa: E501,D401,D403 local_var_params = locals() all_params = ['user_id', 'dashboard_id', 'zap_trace_span'] # noqa: E501 - all_params.append('async_req') - all_params.append('_return_http_data_only') - all_params.append('_preload_content') - all_params.append('_request_timeout') - all_params.append('urlopen_kw') - - for key, val in six.iteritems(local_var_params['kwargs']): - if key not in all_params: - raise TypeError( - "Got an unexpected keyword argument '%s'" - " to method delete_dashboards_id_owners_id" % key - ) - local_var_params[key] = val - del local_var_params['kwargs'] + self._check_operation_params('delete_dashboards_id_owners_id', all_params, local_var_params) # verify the required parameter 'user_id' is set if ('user_id' not in local_var_params or local_var_params['user_id'] is None): @@ -537,8 +628,6 @@ def delete_dashboards_id_owners_id_with_http_info(self, user_id, dashboard_id, * local_var_params['dashboard_id'] is None): raise ValueError("Missing the required parameter `dashboard_id` when calling `delete_dashboards_id_owners_id`") # noqa: E501 - collection_formats = {} - path_params = {} if 'user_id' in local_var_params: path_params['userID'] = local_var_params['user_id'] # noqa: E501 @@ -551,38 +640,12 @@ def delete_dashboards_id_owners_id_with_http_info(self, user_id, dashboard_id, * if 'zap_trace_span' in local_var_params: header_params['Zap-Trace-Span'] = local_var_params['zap_trace_span'] # noqa: E501 - form_params = [] - local_var_files = {} - body_params = None # HTTP header `Accept` header_params['Accept'] = self.api_client.select_header_accept( ['application/json']) # noqa: E501 - # Authentication setting - auth_settings = [] # noqa: E501 - - # urlopen optional setting - urlopen_kw = None - if 'urlopen_kw' in kwargs: - urlopen_kw = kwargs['urlopen_kw'] - - return self.api_client.call_api( - '/api/v2/dashboards/{dashboardID}/owners/{userID}', 'DELETE', - path_params, - query_params, - header_params, - body=body_params, - post_params=form_params, - files=local_var_files, - response_type=None, # noqa: E501 - auth_settings=auth_settings, - async_req=local_var_params.get('async_req'), - _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 - _preload_content=local_var_params.get('_preload_content', True), - _request_timeout=local_var_params.get('_request_timeout'), - collection_formats=collection_formats, - urlopen_kw=urlopen_kw) + return local_var_params, path_params, query_params, header_params, body_params def get_dashboards(self, **kwargs): # noqa: E501,D401,D403 """List all dashboards. @@ -635,23 +698,70 @@ def get_dashboards_with_http_info(self, **kwargs): # noqa: E501,D401,D403 If the method is called asynchronously, returns the request thread. """ # noqa: E501 - local_var_params = locals() + local_var_params, path_params, query_params, header_params, body_params = \ + self._get_dashboards_prepare(**kwargs) - all_params = ['zap_trace_span', 'offset', 'limit', 'descending', 'owner', 'sort_by', 'id', 'org_id', 'org'] # noqa: E501 - all_params.append('async_req') - all_params.append('_return_http_data_only') - all_params.append('_preload_content') - all_params.append('_request_timeout') - all_params.append('urlopen_kw') - - for key, val in six.iteritems(local_var_params['kwargs']): - if key not in all_params: - raise TypeError( - "Got an unexpected keyword argument '%s'" - " to method get_dashboards" % key - ) - local_var_params[key] = val - del local_var_params['kwargs'] + return self.api_client.call_api( + '/api/v2/dashboards', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='Dashboards', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + async def get_dashboards_async(self, **kwargs): # noqa: E501,D401,D403 + """List all dashboards. + + This method makes an asynchronous HTTP request. + + :param async_req bool + :param str zap_trace_span: OpenTracing span context + :param int offset: + :param int limit: + :param bool descending: + :param str owner: A user identifier. Returns only dashboards where this user has the `owner` role. + :param str sort_by: The column to sort by. + :param list[str] id: A list of dashboard identifiers. Returns only the listed dashboards. If both `id` and `owner` are specified, only `id` is used. + :param str org_id: The identifier of the organization. + :param str org: The name of the organization. + :return: Dashboards + If the method is called asynchronously, + returns the request thread. + """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._get_dashboards_prepare(**kwargs) + + return await self.api_client.call_api( + '/api/v2/dashboards', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='Dashboards', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + def _get_dashboards_prepare(self, **kwargs): # noqa: E501,D401,D403 + local_var_params = locals() + + all_params = ['zap_trace_span', 'offset', 'limit', 'descending', 'owner', 'sort_by', 'id', 'org_id', 'org'] # noqa: E501 + self._check_operation_params('get_dashboards', all_params, local_var_params) if 'offset' in local_var_params and local_var_params['offset'] < 0: # noqa: E501 raise ValueError("Invalid value for parameter `offset` when calling `get_dashboards`, must be a value greater than or equal to `0`") # noqa: E501 @@ -659,8 +769,6 @@ def get_dashboards_with_http_info(self, **kwargs): # noqa: E501,D401,D403 raise ValueError("Invalid value for parameter `limit` when calling `get_dashboards`, must be a value less than or equal to `100`") # noqa: E501 if 'limit' in local_var_params and local_var_params['limit'] < 1: # noqa: E501 raise ValueError("Invalid value for parameter `limit` when calling `get_dashboards`, must be a value greater than or equal to `1`") # noqa: E501 - collection_formats = {} - path_params = {} query_params = [] @@ -676,7 +784,6 @@ def get_dashboards_with_http_info(self, **kwargs): # noqa: E501,D401,D403 query_params.append(('sortBy', local_var_params['sort_by'])) # noqa: E501 if 'id' in local_var_params: query_params.append(('id', local_var_params['id'])) # noqa: E501 - collection_formats['id'] = 'multi' # noqa: E501 if 'org_id' in local_var_params: query_params.append(('orgID', local_var_params['org_id'])) # noqa: E501 if 'org' in local_var_params: @@ -686,38 +793,12 @@ def get_dashboards_with_http_info(self, **kwargs): # noqa: E501,D401,D403 if 'zap_trace_span' in local_var_params: header_params['Zap-Trace-Span'] = local_var_params['zap_trace_span'] # noqa: E501 - form_params = [] - local_var_files = {} - body_params = None # HTTP header `Accept` header_params['Accept'] = self.api_client.select_header_accept( ['application/json']) # noqa: E501 - # Authentication setting - auth_settings = [] # noqa: E501 - - # urlopen optional setting - urlopen_kw = None - if 'urlopen_kw' in kwargs: - urlopen_kw = kwargs['urlopen_kw'] - - return self.api_client.call_api( - '/api/v2/dashboards', 'GET', - path_params, - query_params, - header_params, - body=body_params, - post_params=form_params, - files=local_var_files, - response_type='Dashboards', # noqa: E501 - auth_settings=auth_settings, - async_req=local_var_params.get('async_req'), - _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 - _preload_content=local_var_params.get('_preload_content', True), - _request_timeout=local_var_params.get('_request_timeout'), - collection_formats=collection_formats, - urlopen_kw=urlopen_kw) + return local_var_params, path_params, query_params, header_params, body_params def get_dashboards_id(self, dashboard_id, **kwargs): # noqa: E501,D401,D403 """Retrieve a Dashboard. @@ -758,30 +839,69 @@ def get_dashboards_id_with_http_info(self, dashboard_id, **kwargs): # noqa: E50 If the method is called asynchronously, returns the request thread. """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._get_dashboards_id_prepare(dashboard_id, **kwargs) + + return self.api_client.call_api( + '/api/v2/dashboards/{dashboardID}', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='DashboardWithViewProperties', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + async def get_dashboards_id_async(self, dashboard_id, **kwargs): # noqa: E501,D401,D403 + """Retrieve a Dashboard. + + This method makes an asynchronous HTTP request. + + :param async_req bool + :param str dashboard_id: The ID of the dashboard to update. (required) + :param str zap_trace_span: OpenTracing span context + :param str include: Includes the cell view properties in the response if set to `properties` + :return: DashboardWithViewProperties + If the method is called asynchronously, + returns the request thread. + """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._get_dashboards_id_prepare(dashboard_id, **kwargs) + + return await self.api_client.call_api( + '/api/v2/dashboards/{dashboardID}', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='DashboardWithViewProperties', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + def _get_dashboards_id_prepare(self, dashboard_id, **kwargs): # noqa: E501,D401,D403 local_var_params = locals() all_params = ['dashboard_id', 'zap_trace_span', 'include'] # noqa: E501 - all_params.append('async_req') - all_params.append('_return_http_data_only') - all_params.append('_preload_content') - all_params.append('_request_timeout') - all_params.append('urlopen_kw') - - for key, val in six.iteritems(local_var_params['kwargs']): - if key not in all_params: - raise TypeError( - "Got an unexpected keyword argument '%s'" - " to method get_dashboards_id" % key - ) - local_var_params[key] = val - del local_var_params['kwargs'] + self._check_operation_params('get_dashboards_id', all_params, local_var_params) # verify the required parameter 'dashboard_id' is set if ('dashboard_id' not in local_var_params or local_var_params['dashboard_id'] is None): raise ValueError("Missing the required parameter `dashboard_id` when calling `get_dashboards_id`") # noqa: E501 - collection_formats = {} - path_params = {} if 'dashboard_id' in local_var_params: path_params['dashboardID'] = local_var_params['dashboard_id'] # noqa: E501 @@ -794,38 +914,12 @@ def get_dashboards_id_with_http_info(self, dashboard_id, **kwargs): # noqa: E50 if 'zap_trace_span' in local_var_params: header_params['Zap-Trace-Span'] = local_var_params['zap_trace_span'] # noqa: E501 - form_params = [] - local_var_files = {} - body_params = None # HTTP header `Accept` header_params['Accept'] = self.api_client.select_header_accept( ['application/json']) # noqa: E501 - # Authentication setting - auth_settings = [] # noqa: E501 - - # urlopen optional setting - urlopen_kw = None - if 'urlopen_kw' in kwargs: - urlopen_kw = kwargs['urlopen_kw'] - - return self.api_client.call_api( - '/api/v2/dashboards/{dashboardID}', 'GET', - path_params, - query_params, - header_params, - body=body_params, - post_params=form_params, - files=local_var_files, - response_type='DashboardWithViewProperties', # noqa: E501 - auth_settings=auth_settings, - async_req=local_var_params.get('async_req'), - _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 - _preload_content=local_var_params.get('_preload_content', True), - _request_timeout=local_var_params.get('_request_timeout'), - collection_formats=collection_formats, - urlopen_kw=urlopen_kw) + return local_var_params, path_params, query_params, header_params, body_params def get_dashboards_id_cells_id_view(self, dashboard_id, cell_id, **kwargs): # noqa: E501,D401,D403 """Retrieve the view for a cell. @@ -866,23 +960,64 @@ def get_dashboards_id_cells_id_view_with_http_info(self, dashboard_id, cell_id, If the method is called asynchronously, returns the request thread. """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._get_dashboards_id_cells_id_view_prepare(dashboard_id, cell_id, **kwargs) + + return self.api_client.call_api( + '/api/v2/dashboards/{dashboardID}/cells/{cellID}/view', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='View', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + async def get_dashboards_id_cells_id_view_async(self, dashboard_id, cell_id, **kwargs): # noqa: E501,D401,D403 + """Retrieve the view for a cell. + + This method makes an asynchronous HTTP request. + + :param async_req bool + :param str dashboard_id: The dashboard ID. (required) + :param str cell_id: The cell ID. (required) + :param str zap_trace_span: OpenTracing span context + :return: View + If the method is called asynchronously, + returns the request thread. + """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._get_dashboards_id_cells_id_view_prepare(dashboard_id, cell_id, **kwargs) + + return await self.api_client.call_api( + '/api/v2/dashboards/{dashboardID}/cells/{cellID}/view', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='View', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + def _get_dashboards_id_cells_id_view_prepare(self, dashboard_id, cell_id, **kwargs): # noqa: E501,D401,D403 local_var_params = locals() all_params = ['dashboard_id', 'cell_id', 'zap_trace_span'] # noqa: E501 - all_params.append('async_req') - all_params.append('_return_http_data_only') - all_params.append('_preload_content') - all_params.append('_request_timeout') - all_params.append('urlopen_kw') - - for key, val in six.iteritems(local_var_params['kwargs']): - if key not in all_params: - raise TypeError( - "Got an unexpected keyword argument '%s'" - " to method get_dashboards_id_cells_id_view" % key - ) - local_var_params[key] = val - del local_var_params['kwargs'] + self._check_operation_params('get_dashboards_id_cells_id_view', all_params, local_var_params) # verify the required parameter 'dashboard_id' is set if ('dashboard_id' not in local_var_params or local_var_params['dashboard_id'] is None): @@ -892,8 +1027,6 @@ def get_dashboards_id_cells_id_view_with_http_info(self, dashboard_id, cell_id, local_var_params['cell_id'] is None): raise ValueError("Missing the required parameter `cell_id` when calling `get_dashboards_id_cells_id_view`") # noqa: E501 - collection_formats = {} - path_params = {} if 'dashboard_id' in local_var_params: path_params['dashboardID'] = local_var_params['dashboard_id'] # noqa: E501 @@ -906,38 +1039,12 @@ def get_dashboards_id_cells_id_view_with_http_info(self, dashboard_id, cell_id, if 'zap_trace_span' in local_var_params: header_params['Zap-Trace-Span'] = local_var_params['zap_trace_span'] # noqa: E501 - form_params = [] - local_var_files = {} - body_params = None # HTTP header `Accept` header_params['Accept'] = self.api_client.select_header_accept( ['application/json']) # noqa: E501 - # Authentication setting - auth_settings = [] # noqa: E501 - - # urlopen optional setting - urlopen_kw = None - if 'urlopen_kw' in kwargs: - urlopen_kw = kwargs['urlopen_kw'] - - return self.api_client.call_api( - '/api/v2/dashboards/{dashboardID}/cells/{cellID}/view', 'GET', - path_params, - query_params, - header_params, - body=body_params, - post_params=form_params, - files=local_var_files, - response_type='View', # noqa: E501 - auth_settings=auth_settings, - async_req=local_var_params.get('async_req'), - _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 - _preload_content=local_var_params.get('_preload_content', True), - _request_timeout=local_var_params.get('_request_timeout'), - collection_formats=collection_formats, - urlopen_kw=urlopen_kw) + return local_var_params, path_params, query_params, header_params, body_params def get_dashboards_id_labels(self, dashboard_id, **kwargs): # noqa: E501,D401,D403 """List all labels for a dashboard. @@ -976,30 +1083,68 @@ def get_dashboards_id_labels_with_http_info(self, dashboard_id, **kwargs): # no If the method is called asynchronously, returns the request thread. """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._get_dashboards_id_labels_prepare(dashboard_id, **kwargs) + + return self.api_client.call_api( + '/api/v2/dashboards/{dashboardID}/labels', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='LabelsResponse', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + async def get_dashboards_id_labels_async(self, dashboard_id, **kwargs): # noqa: E501,D401,D403 + """List all labels for a dashboard. + + This method makes an asynchronous HTTP request. + + :param async_req bool + :param str dashboard_id: The dashboard ID. (required) + :param str zap_trace_span: OpenTracing span context + :return: LabelsResponse + If the method is called asynchronously, + returns the request thread. + """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._get_dashboards_id_labels_prepare(dashboard_id, **kwargs) + + return await self.api_client.call_api( + '/api/v2/dashboards/{dashboardID}/labels', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='LabelsResponse', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + def _get_dashboards_id_labels_prepare(self, dashboard_id, **kwargs): # noqa: E501,D401,D403 local_var_params = locals() all_params = ['dashboard_id', 'zap_trace_span'] # noqa: E501 - all_params.append('async_req') - all_params.append('_return_http_data_only') - all_params.append('_preload_content') - all_params.append('_request_timeout') - all_params.append('urlopen_kw') - - for key, val in six.iteritems(local_var_params['kwargs']): - if key not in all_params: - raise TypeError( - "Got an unexpected keyword argument '%s'" - " to method get_dashboards_id_labels" % key - ) - local_var_params[key] = val - del local_var_params['kwargs'] + self._check_operation_params('get_dashboards_id_labels', all_params, local_var_params) # verify the required parameter 'dashboard_id' is set if ('dashboard_id' not in local_var_params or local_var_params['dashboard_id'] is None): raise ValueError("Missing the required parameter `dashboard_id` when calling `get_dashboards_id_labels`") # noqa: E501 - collection_formats = {} - path_params = {} if 'dashboard_id' in local_var_params: path_params['dashboardID'] = local_var_params['dashboard_id'] # noqa: E501 @@ -1010,38 +1155,12 @@ def get_dashboards_id_labels_with_http_info(self, dashboard_id, **kwargs): # no if 'zap_trace_span' in local_var_params: header_params['Zap-Trace-Span'] = local_var_params['zap_trace_span'] # noqa: E501 - form_params = [] - local_var_files = {} - body_params = None # HTTP header `Accept` header_params['Accept'] = self.api_client.select_header_accept( ['application/json']) # noqa: E501 - # Authentication setting - auth_settings = [] # noqa: E501 - - # urlopen optional setting - urlopen_kw = None - if 'urlopen_kw' in kwargs: - urlopen_kw = kwargs['urlopen_kw'] - - return self.api_client.call_api( - '/api/v2/dashboards/{dashboardID}/labels', 'GET', - path_params, - query_params, - header_params, - body=body_params, - post_params=form_params, - files=local_var_files, - response_type='LabelsResponse', # noqa: E501 - auth_settings=auth_settings, - async_req=local_var_params.get('async_req'), - _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 - _preload_content=local_var_params.get('_preload_content', True), - _request_timeout=local_var_params.get('_request_timeout'), - collection_formats=collection_formats, - urlopen_kw=urlopen_kw) + return local_var_params, path_params, query_params, header_params, body_params def get_dashboards_id_members(self, dashboard_id, **kwargs): # noqa: E501,D401,D403 """List all dashboard members. @@ -1080,30 +1199,68 @@ def get_dashboards_id_members_with_http_info(self, dashboard_id, **kwargs): # n If the method is called asynchronously, returns the request thread. """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._get_dashboards_id_members_prepare(dashboard_id, **kwargs) + + return self.api_client.call_api( + '/api/v2/dashboards/{dashboardID}/members', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='ResourceMembers', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + async def get_dashboards_id_members_async(self, dashboard_id, **kwargs): # noqa: E501,D401,D403 + """List all dashboard members. + + This method makes an asynchronous HTTP request. + + :param async_req bool + :param str dashboard_id: The dashboard ID. (required) + :param str zap_trace_span: OpenTracing span context + :return: ResourceMembers + If the method is called asynchronously, + returns the request thread. + """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._get_dashboards_id_members_prepare(dashboard_id, **kwargs) + + return await self.api_client.call_api( + '/api/v2/dashboards/{dashboardID}/members', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='ResourceMembers', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + def _get_dashboards_id_members_prepare(self, dashboard_id, **kwargs): # noqa: E501,D401,D403 local_var_params = locals() all_params = ['dashboard_id', 'zap_trace_span'] # noqa: E501 - all_params.append('async_req') - all_params.append('_return_http_data_only') - all_params.append('_preload_content') - all_params.append('_request_timeout') - all_params.append('urlopen_kw') - - for key, val in six.iteritems(local_var_params['kwargs']): - if key not in all_params: - raise TypeError( - "Got an unexpected keyword argument '%s'" - " to method get_dashboards_id_members" % key - ) - local_var_params[key] = val - del local_var_params['kwargs'] + self._check_operation_params('get_dashboards_id_members', all_params, local_var_params) # verify the required parameter 'dashboard_id' is set if ('dashboard_id' not in local_var_params or local_var_params['dashboard_id'] is None): raise ValueError("Missing the required parameter `dashboard_id` when calling `get_dashboards_id_members`") # noqa: E501 - collection_formats = {} - path_params = {} if 'dashboard_id' in local_var_params: path_params['dashboardID'] = local_var_params['dashboard_id'] # noqa: E501 @@ -1114,38 +1271,12 @@ def get_dashboards_id_members_with_http_info(self, dashboard_id, **kwargs): # n if 'zap_trace_span' in local_var_params: header_params['Zap-Trace-Span'] = local_var_params['zap_trace_span'] # noqa: E501 - form_params = [] - local_var_files = {} - body_params = None # HTTP header `Accept` header_params['Accept'] = self.api_client.select_header_accept( ['application/json']) # noqa: E501 - # Authentication setting - auth_settings = [] # noqa: E501 - - # urlopen optional setting - urlopen_kw = None - if 'urlopen_kw' in kwargs: - urlopen_kw = kwargs['urlopen_kw'] - - return self.api_client.call_api( - '/api/v2/dashboards/{dashboardID}/members', 'GET', - path_params, - query_params, - header_params, - body=body_params, - post_params=form_params, - files=local_var_files, - response_type='ResourceMembers', # noqa: E501 - auth_settings=auth_settings, - async_req=local_var_params.get('async_req'), - _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 - _preload_content=local_var_params.get('_preload_content', True), - _request_timeout=local_var_params.get('_request_timeout'), - collection_formats=collection_formats, - urlopen_kw=urlopen_kw) + return local_var_params, path_params, query_params, header_params, body_params def get_dashboards_id_owners(self, dashboard_id, **kwargs): # noqa: E501,D401,D403 """List all dashboard owners. @@ -1184,30 +1315,68 @@ def get_dashboards_id_owners_with_http_info(self, dashboard_id, **kwargs): # no If the method is called asynchronously, returns the request thread. """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._get_dashboards_id_owners_prepare(dashboard_id, **kwargs) + + return self.api_client.call_api( + '/api/v2/dashboards/{dashboardID}/owners', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='ResourceOwners', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + async def get_dashboards_id_owners_async(self, dashboard_id, **kwargs): # noqa: E501,D401,D403 + """List all dashboard owners. + + This method makes an asynchronous HTTP request. + + :param async_req bool + :param str dashboard_id: The dashboard ID. (required) + :param str zap_trace_span: OpenTracing span context + :return: ResourceOwners + If the method is called asynchronously, + returns the request thread. + """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._get_dashboards_id_owners_prepare(dashboard_id, **kwargs) + + return await self.api_client.call_api( + '/api/v2/dashboards/{dashboardID}/owners', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='ResourceOwners', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + def _get_dashboards_id_owners_prepare(self, dashboard_id, **kwargs): # noqa: E501,D401,D403 local_var_params = locals() all_params = ['dashboard_id', 'zap_trace_span'] # noqa: E501 - all_params.append('async_req') - all_params.append('_return_http_data_only') - all_params.append('_preload_content') - all_params.append('_request_timeout') - all_params.append('urlopen_kw') - - for key, val in six.iteritems(local_var_params['kwargs']): - if key not in all_params: - raise TypeError( - "Got an unexpected keyword argument '%s'" - " to method get_dashboards_id_owners" % key - ) - local_var_params[key] = val - del local_var_params['kwargs'] + self._check_operation_params('get_dashboards_id_owners', all_params, local_var_params) # verify the required parameter 'dashboard_id' is set if ('dashboard_id' not in local_var_params or local_var_params['dashboard_id'] is None): raise ValueError("Missing the required parameter `dashboard_id` when calling `get_dashboards_id_owners`") # noqa: E501 - collection_formats = {} - path_params = {} if 'dashboard_id' in local_var_params: path_params['dashboardID'] = local_var_params['dashboard_id'] # noqa: E501 @@ -1218,38 +1387,12 @@ def get_dashboards_id_owners_with_http_info(self, dashboard_id, **kwargs): # no if 'zap_trace_span' in local_var_params: header_params['Zap-Trace-Span'] = local_var_params['zap_trace_span'] # noqa: E501 - form_params = [] - local_var_files = {} - body_params = None # HTTP header `Accept` header_params['Accept'] = self.api_client.select_header_accept( ['application/json']) # noqa: E501 - # Authentication setting - auth_settings = [] # noqa: E501 - - # urlopen optional setting - urlopen_kw = None - if 'urlopen_kw' in kwargs: - urlopen_kw = kwargs['urlopen_kw'] - - return self.api_client.call_api( - '/api/v2/dashboards/{dashboardID}/owners', 'GET', - path_params, - query_params, - header_params, - body=body_params, - post_params=form_params, - files=local_var_files, - response_type='ResourceOwners', # noqa: E501 - auth_settings=auth_settings, - async_req=local_var_params.get('async_req'), - _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 - _preload_content=local_var_params.get('_preload_content', True), - _request_timeout=local_var_params.get('_request_timeout'), - collection_formats=collection_formats, - urlopen_kw=urlopen_kw) + return local_var_params, path_params, query_params, header_params, body_params def patch_dashboards_id(self, dashboard_id, **kwargs): # noqa: E501,D401,D403 """Update a dashboard. @@ -1290,30 +1433,69 @@ def patch_dashboards_id_with_http_info(self, dashboard_id, **kwargs): # noqa: E If the method is called asynchronously, returns the request thread. """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._patch_dashboards_id_prepare(dashboard_id, **kwargs) + + return self.api_client.call_api( + '/api/v2/dashboards/{dashboardID}', 'PATCH', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='Dashboard', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + async def patch_dashboards_id_async(self, dashboard_id, **kwargs): # noqa: E501,D401,D403 + """Update a dashboard. + + This method makes an asynchronous HTTP request. + + :param async_req bool + :param str dashboard_id: The ID of the dashboard to update. (required) + :param str zap_trace_span: OpenTracing span context + :param PatchDashboardRequest patch_dashboard_request: + :return: Dashboard + If the method is called asynchronously, + returns the request thread. + """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._patch_dashboards_id_prepare(dashboard_id, **kwargs) + + return await self.api_client.call_api( + '/api/v2/dashboards/{dashboardID}', 'PATCH', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='Dashboard', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + def _patch_dashboards_id_prepare(self, dashboard_id, **kwargs): # noqa: E501,D401,D403 local_var_params = locals() all_params = ['dashboard_id', 'zap_trace_span', 'patch_dashboard_request'] # noqa: E501 - all_params.append('async_req') - all_params.append('_return_http_data_only') - all_params.append('_preload_content') - all_params.append('_request_timeout') - all_params.append('urlopen_kw') - - for key, val in six.iteritems(local_var_params['kwargs']): - if key not in all_params: - raise TypeError( - "Got an unexpected keyword argument '%s'" - " to method patch_dashboards_id" % key - ) - local_var_params[key] = val - del local_var_params['kwargs'] + self._check_operation_params('patch_dashboards_id', all_params, local_var_params) # verify the required parameter 'dashboard_id' is set if ('dashboard_id' not in local_var_params or local_var_params['dashboard_id'] is None): raise ValueError("Missing the required parameter `dashboard_id` when calling `patch_dashboards_id`") # noqa: E501 - collection_formats = {} - path_params = {} if 'dashboard_id' in local_var_params: path_params['dashboardID'] = local_var_params['dashboard_id'] # noqa: E501 @@ -1324,9 +1506,6 @@ def patch_dashboards_id_with_http_info(self, dashboard_id, **kwargs): # noqa: E if 'zap_trace_span' in local_var_params: header_params['Zap-Trace-Span'] = local_var_params['zap_trace_span'] # noqa: E501 - form_params = [] - local_var_files = {} - body_params = None if 'patch_dashboard_request' in local_var_params: body_params = local_var_params['patch_dashboard_request'] @@ -1338,30 +1517,7 @@ def patch_dashboards_id_with_http_info(self, dashboard_id, **kwargs): # noqa: E header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501 ['application/json']) # noqa: E501 - # Authentication setting - auth_settings = [] # noqa: E501 - - # urlopen optional setting - urlopen_kw = None - if 'urlopen_kw' in kwargs: - urlopen_kw = kwargs['urlopen_kw'] - - return self.api_client.call_api( - '/api/v2/dashboards/{dashboardID}', 'PATCH', - path_params, - query_params, - header_params, - body=body_params, - post_params=form_params, - files=local_var_files, - response_type='Dashboard', # noqa: E501 - auth_settings=auth_settings, - async_req=local_var_params.get('async_req'), - _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 - _preload_content=local_var_params.get('_preload_content', True), - _request_timeout=local_var_params.get('_request_timeout'), - collection_formats=collection_formats, - urlopen_kw=urlopen_kw) + return local_var_params, path_params, query_params, header_params, body_params def patch_dashboards_id_cells_id(self, dashboard_id, cell_id, cell_update, **kwargs): # noqa: E501,D401,D403 """Update the non-positional information related to a cell. @@ -1406,23 +1562,66 @@ def patch_dashboards_id_cells_id_with_http_info(self, dashboard_id, cell_id, cel If the method is called asynchronously, returns the request thread. """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._patch_dashboards_id_cells_id_prepare(dashboard_id, cell_id, cell_update, **kwargs) + + return self.api_client.call_api( + '/api/v2/dashboards/{dashboardID}/cells/{cellID}', 'PATCH', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='Cell', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + async def patch_dashboards_id_cells_id_async(self, dashboard_id, cell_id, cell_update, **kwargs): # noqa: E501,D401,D403 + """Update the non-positional information related to a cell. + + Updates the non positional information related to a cell. Updates to a single cell's positional data could cause grid conflicts. + This method makes an asynchronous HTTP request. + + :param async_req bool + :param str dashboard_id: The ID of the dashboard to update. (required) + :param str cell_id: The ID of the cell to update. (required) + :param CellUpdate cell_update: (required) + :param str zap_trace_span: OpenTracing span context + :return: Cell + If the method is called asynchronously, + returns the request thread. + """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._patch_dashboards_id_cells_id_prepare(dashboard_id, cell_id, cell_update, **kwargs) + + return await self.api_client.call_api( + '/api/v2/dashboards/{dashboardID}/cells/{cellID}', 'PATCH', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='Cell', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + def _patch_dashboards_id_cells_id_prepare(self, dashboard_id, cell_id, cell_update, **kwargs): # noqa: E501,D401,D403 local_var_params = locals() all_params = ['dashboard_id', 'cell_id', 'cell_update', 'zap_trace_span'] # noqa: E501 - all_params.append('async_req') - all_params.append('_return_http_data_only') - all_params.append('_preload_content') - all_params.append('_request_timeout') - all_params.append('urlopen_kw') - - for key, val in six.iteritems(local_var_params['kwargs']): - if key not in all_params: - raise TypeError( - "Got an unexpected keyword argument '%s'" - " to method patch_dashboards_id_cells_id" % key - ) - local_var_params[key] = val - del local_var_params['kwargs'] + self._check_operation_params('patch_dashboards_id_cells_id', all_params, local_var_params) # verify the required parameter 'dashboard_id' is set if ('dashboard_id' not in local_var_params or local_var_params['dashboard_id'] is None): @@ -1436,8 +1635,6 @@ def patch_dashboards_id_cells_id_with_http_info(self, dashboard_id, cell_id, cel local_var_params['cell_update'] is None): raise ValueError("Missing the required parameter `cell_update` when calling `patch_dashboards_id_cells_id`") # noqa: E501 - collection_formats = {} - path_params = {} if 'dashboard_id' in local_var_params: path_params['dashboardID'] = local_var_params['dashboard_id'] # noqa: E501 @@ -1450,9 +1647,6 @@ def patch_dashboards_id_cells_id_with_http_info(self, dashboard_id, cell_id, cel if 'zap_trace_span' in local_var_params: header_params['Zap-Trace-Span'] = local_var_params['zap_trace_span'] # noqa: E501 - form_params = [] - local_var_files = {} - body_params = None if 'cell_update' in local_var_params: body_params = local_var_params['cell_update'] @@ -1464,30 +1658,7 @@ def patch_dashboards_id_cells_id_with_http_info(self, dashboard_id, cell_id, cel header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501 ['application/json']) # noqa: E501 - # Authentication setting - auth_settings = [] # noqa: E501 - - # urlopen optional setting - urlopen_kw = None - if 'urlopen_kw' in kwargs: - urlopen_kw = kwargs['urlopen_kw'] - - return self.api_client.call_api( - '/api/v2/dashboards/{dashboardID}/cells/{cellID}', 'PATCH', - path_params, - query_params, - header_params, - body=body_params, - post_params=form_params, - files=local_var_files, - response_type='Cell', # noqa: E501 - auth_settings=auth_settings, - async_req=local_var_params.get('async_req'), - _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 - _preload_content=local_var_params.get('_preload_content', True), - _request_timeout=local_var_params.get('_request_timeout'), - collection_formats=collection_formats, - urlopen_kw=urlopen_kw) + return local_var_params, path_params, query_params, header_params, body_params def patch_dashboards_id_cells_id_view(self, dashboard_id, cell_id, view, **kwargs): # noqa: E501,D401,D403 """Update the view for a cell. @@ -1530,23 +1701,65 @@ def patch_dashboards_id_cells_id_view_with_http_info(self, dashboard_id, cell_id If the method is called asynchronously, returns the request thread. """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._patch_dashboards_id_cells_id_view_prepare(dashboard_id, cell_id, view, **kwargs) + + return self.api_client.call_api( + '/api/v2/dashboards/{dashboardID}/cells/{cellID}/view', 'PATCH', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='View', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + async def patch_dashboards_id_cells_id_view_async(self, dashboard_id, cell_id, view, **kwargs): # noqa: E501,D401,D403 + """Update the view for a cell. + + This method makes an asynchronous HTTP request. + + :param async_req bool + :param str dashboard_id: The ID of the dashboard to update. (required) + :param str cell_id: The ID of the cell to update. (required) + :param View view: (required) + :param str zap_trace_span: OpenTracing span context + :return: View + If the method is called asynchronously, + returns the request thread. + """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._patch_dashboards_id_cells_id_view_prepare(dashboard_id, cell_id, view, **kwargs) + + return await self.api_client.call_api( + '/api/v2/dashboards/{dashboardID}/cells/{cellID}/view', 'PATCH', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='View', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + def _patch_dashboards_id_cells_id_view_prepare(self, dashboard_id, cell_id, view, **kwargs): # noqa: E501,D401,D403 local_var_params = locals() all_params = ['dashboard_id', 'cell_id', 'view', 'zap_trace_span'] # noqa: E501 - all_params.append('async_req') - all_params.append('_return_http_data_only') - all_params.append('_preload_content') - all_params.append('_request_timeout') - all_params.append('urlopen_kw') - - for key, val in six.iteritems(local_var_params['kwargs']): - if key not in all_params: - raise TypeError( - "Got an unexpected keyword argument '%s'" - " to method patch_dashboards_id_cells_id_view" % key - ) - local_var_params[key] = val - del local_var_params['kwargs'] + self._check_operation_params('patch_dashboards_id_cells_id_view', all_params, local_var_params) # verify the required parameter 'dashboard_id' is set if ('dashboard_id' not in local_var_params or local_var_params['dashboard_id'] is None): @@ -1560,8 +1773,6 @@ def patch_dashboards_id_cells_id_view_with_http_info(self, dashboard_id, cell_id local_var_params['view'] is None): raise ValueError("Missing the required parameter `view` when calling `patch_dashboards_id_cells_id_view`") # noqa: E501 - collection_formats = {} - path_params = {} if 'dashboard_id' in local_var_params: path_params['dashboardID'] = local_var_params['dashboard_id'] # noqa: E501 @@ -1574,9 +1785,6 @@ def patch_dashboards_id_cells_id_view_with_http_info(self, dashboard_id, cell_id if 'zap_trace_span' in local_var_params: header_params['Zap-Trace-Span'] = local_var_params['zap_trace_span'] # noqa: E501 - form_params = [] - local_var_files = {} - body_params = None if 'view' in local_var_params: body_params = local_var_params['view'] @@ -1588,30 +1796,7 @@ def patch_dashboards_id_cells_id_view_with_http_info(self, dashboard_id, cell_id header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501 ['application/json']) # noqa: E501 - # Authentication setting - auth_settings = [] # noqa: E501 - - # urlopen optional setting - urlopen_kw = None - if 'urlopen_kw' in kwargs: - urlopen_kw = kwargs['urlopen_kw'] - - return self.api_client.call_api( - '/api/v2/dashboards/{dashboardID}/cells/{cellID}/view', 'PATCH', - path_params, - query_params, - header_params, - body=body_params, - post_params=form_params, - files=local_var_files, - response_type='View', # noqa: E501 - auth_settings=auth_settings, - async_req=local_var_params.get('async_req'), - _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 - _preload_content=local_var_params.get('_preload_content', True), - _request_timeout=local_var_params.get('_request_timeout'), - collection_formats=collection_formats, - urlopen_kw=urlopen_kw) + return local_var_params, path_params, query_params, header_params, body_params def post_dashboards(self, create_dashboard_request, **kwargs): # noqa: E501,D401,D403 """Create a dashboard. @@ -1650,30 +1835,68 @@ def post_dashboards_with_http_info(self, create_dashboard_request, **kwargs): # If the method is called asynchronously, returns the request thread. """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._post_dashboards_prepare(create_dashboard_request, **kwargs) + + return self.api_client.call_api( + '/api/v2/dashboards', 'POST', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='Dashboard', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + async def post_dashboards_async(self, create_dashboard_request, **kwargs): # noqa: E501,D401,D403 + """Create a dashboard. + + This method makes an asynchronous HTTP request. + + :param async_req bool + :param CreateDashboardRequest create_dashboard_request: Dashboard to create (required) + :param str zap_trace_span: OpenTracing span context + :return: Dashboard + If the method is called asynchronously, + returns the request thread. + """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._post_dashboards_prepare(create_dashboard_request, **kwargs) + + return await self.api_client.call_api( + '/api/v2/dashboards', 'POST', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='Dashboard', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + def _post_dashboards_prepare(self, create_dashboard_request, **kwargs): # noqa: E501,D401,D403 local_var_params = locals() all_params = ['create_dashboard_request', 'zap_trace_span'] # noqa: E501 - all_params.append('async_req') - all_params.append('_return_http_data_only') - all_params.append('_preload_content') - all_params.append('_request_timeout') - all_params.append('urlopen_kw') - - for key, val in six.iteritems(local_var_params['kwargs']): - if key not in all_params: - raise TypeError( - "Got an unexpected keyword argument '%s'" - " to method post_dashboards" % key - ) - local_var_params[key] = val - del local_var_params['kwargs'] + self._check_operation_params('post_dashboards', all_params, local_var_params) # verify the required parameter 'create_dashboard_request' is set if ('create_dashboard_request' not in local_var_params or local_var_params['create_dashboard_request'] is None): raise ValueError("Missing the required parameter `create_dashboard_request` when calling `post_dashboards`") # noqa: E501 - collection_formats = {} - path_params = {} query_params = [] @@ -1682,9 +1905,6 @@ def post_dashboards_with_http_info(self, create_dashboard_request, **kwargs): # if 'zap_trace_span' in local_var_params: header_params['Zap-Trace-Span'] = local_var_params['zap_trace_span'] # noqa: E501 - form_params = [] - local_var_files = {} - body_params = None if 'create_dashboard_request' in local_var_params: body_params = local_var_params['create_dashboard_request'] @@ -1696,30 +1916,7 @@ def post_dashboards_with_http_info(self, create_dashboard_request, **kwargs): # header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501 ['application/json']) # noqa: E501 - # Authentication setting - auth_settings = [] # noqa: E501 - - # urlopen optional setting - urlopen_kw = None - if 'urlopen_kw' in kwargs: - urlopen_kw = kwargs['urlopen_kw'] - - return self.api_client.call_api( - '/api/v2/dashboards', 'POST', - path_params, - query_params, - header_params, - body=body_params, - post_params=form_params, - files=local_var_files, - response_type='Dashboard', # noqa: E501 - auth_settings=auth_settings, - async_req=local_var_params.get('async_req'), - _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 - _preload_content=local_var_params.get('_preload_content', True), - _request_timeout=local_var_params.get('_request_timeout'), - collection_formats=collection_formats, - urlopen_kw=urlopen_kw) + return local_var_params, path_params, query_params, header_params, body_params def post_dashboards_id_cells(self, dashboard_id, create_cell, **kwargs): # noqa: E501,D401,D403 """Create a dashboard cell. @@ -1760,23 +1957,64 @@ def post_dashboards_id_cells_with_http_info(self, dashboard_id, create_cell, **k If the method is called asynchronously, returns the request thread. """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._post_dashboards_id_cells_prepare(dashboard_id, create_cell, **kwargs) + + return self.api_client.call_api( + '/api/v2/dashboards/{dashboardID}/cells', 'POST', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='Cell', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + async def post_dashboards_id_cells_async(self, dashboard_id, create_cell, **kwargs): # noqa: E501,D401,D403 + """Create a dashboard cell. + + This method makes an asynchronous HTTP request. + + :param async_req bool + :param str dashboard_id: The ID of the dashboard to update. (required) + :param CreateCell create_cell: Cell that will be added (required) + :param str zap_trace_span: OpenTracing span context + :return: Cell + If the method is called asynchronously, + returns the request thread. + """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._post_dashboards_id_cells_prepare(dashboard_id, create_cell, **kwargs) + + return await self.api_client.call_api( + '/api/v2/dashboards/{dashboardID}/cells', 'POST', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='Cell', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + def _post_dashboards_id_cells_prepare(self, dashboard_id, create_cell, **kwargs): # noqa: E501,D401,D403 local_var_params = locals() all_params = ['dashboard_id', 'create_cell', 'zap_trace_span'] # noqa: E501 - all_params.append('async_req') - all_params.append('_return_http_data_only') - all_params.append('_preload_content') - all_params.append('_request_timeout') - all_params.append('urlopen_kw') - - for key, val in six.iteritems(local_var_params['kwargs']): - if key not in all_params: - raise TypeError( - "Got an unexpected keyword argument '%s'" - " to method post_dashboards_id_cells" % key - ) - local_var_params[key] = val - del local_var_params['kwargs'] + self._check_operation_params('post_dashboards_id_cells', all_params, local_var_params) # verify the required parameter 'dashboard_id' is set if ('dashboard_id' not in local_var_params or local_var_params['dashboard_id'] is None): @@ -1786,8 +2024,6 @@ def post_dashboards_id_cells_with_http_info(self, dashboard_id, create_cell, **k local_var_params['create_cell'] is None): raise ValueError("Missing the required parameter `create_cell` when calling `post_dashboards_id_cells`") # noqa: E501 - collection_formats = {} - path_params = {} if 'dashboard_id' in local_var_params: path_params['dashboardID'] = local_var_params['dashboard_id'] # noqa: E501 @@ -1798,9 +2034,6 @@ def post_dashboards_id_cells_with_http_info(self, dashboard_id, create_cell, **k if 'zap_trace_span' in local_var_params: header_params['Zap-Trace-Span'] = local_var_params['zap_trace_span'] # noqa: E501 - form_params = [] - local_var_files = {} - body_params = None if 'create_cell' in local_var_params: body_params = local_var_params['create_cell'] @@ -1812,30 +2045,7 @@ def post_dashboards_id_cells_with_http_info(self, dashboard_id, create_cell, **k header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501 ['application/json']) # noqa: E501 - # Authentication setting - auth_settings = [] # noqa: E501 - - # urlopen optional setting - urlopen_kw = None - if 'urlopen_kw' in kwargs: - urlopen_kw = kwargs['urlopen_kw'] - - return self.api_client.call_api( - '/api/v2/dashboards/{dashboardID}/cells', 'POST', - path_params, - query_params, - header_params, - body=body_params, - post_params=form_params, - files=local_var_files, - response_type='Cell', # noqa: E501 - auth_settings=auth_settings, - async_req=local_var_params.get('async_req'), - _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 - _preload_content=local_var_params.get('_preload_content', True), - _request_timeout=local_var_params.get('_request_timeout'), - collection_formats=collection_formats, - urlopen_kw=urlopen_kw) + return local_var_params, path_params, query_params, header_params, body_params def post_dashboards_id_labels(self, dashboard_id, label_mapping, **kwargs): # noqa: E501,D401,D403 """Add a label to a dashboard. @@ -1876,23 +2086,64 @@ def post_dashboards_id_labels_with_http_info(self, dashboard_id, label_mapping, If the method is called asynchronously, returns the request thread. """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._post_dashboards_id_labels_prepare(dashboard_id, label_mapping, **kwargs) + + return self.api_client.call_api( + '/api/v2/dashboards/{dashboardID}/labels', 'POST', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='LabelResponse', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + async def post_dashboards_id_labels_async(self, dashboard_id, label_mapping, **kwargs): # noqa: E501,D401,D403 + """Add a label to a dashboard. + + This method makes an asynchronous HTTP request. + + :param async_req bool + :param str dashboard_id: The dashboard ID. (required) + :param LabelMapping label_mapping: Label to add (required) + :param str zap_trace_span: OpenTracing span context + :return: LabelResponse + If the method is called asynchronously, + returns the request thread. + """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._post_dashboards_id_labels_prepare(dashboard_id, label_mapping, **kwargs) + + return await self.api_client.call_api( + '/api/v2/dashboards/{dashboardID}/labels', 'POST', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='LabelResponse', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + def _post_dashboards_id_labels_prepare(self, dashboard_id, label_mapping, **kwargs): # noqa: E501,D401,D403 local_var_params = locals() all_params = ['dashboard_id', 'label_mapping', 'zap_trace_span'] # noqa: E501 - all_params.append('async_req') - all_params.append('_return_http_data_only') - all_params.append('_preload_content') - all_params.append('_request_timeout') - all_params.append('urlopen_kw') - - for key, val in six.iteritems(local_var_params['kwargs']): - if key not in all_params: - raise TypeError( - "Got an unexpected keyword argument '%s'" - " to method post_dashboards_id_labels" % key - ) - local_var_params[key] = val - del local_var_params['kwargs'] + self._check_operation_params('post_dashboards_id_labels', all_params, local_var_params) # verify the required parameter 'dashboard_id' is set if ('dashboard_id' not in local_var_params or local_var_params['dashboard_id'] is None): @@ -1902,8 +2153,6 @@ def post_dashboards_id_labels_with_http_info(self, dashboard_id, label_mapping, local_var_params['label_mapping'] is None): raise ValueError("Missing the required parameter `label_mapping` when calling `post_dashboards_id_labels`") # noqa: E501 - collection_formats = {} - path_params = {} if 'dashboard_id' in local_var_params: path_params['dashboardID'] = local_var_params['dashboard_id'] # noqa: E501 @@ -1914,9 +2163,6 @@ def post_dashboards_id_labels_with_http_info(self, dashboard_id, label_mapping, if 'zap_trace_span' in local_var_params: header_params['Zap-Trace-Span'] = local_var_params['zap_trace_span'] # noqa: E501 - form_params = [] - local_var_files = {} - body_params = None if 'label_mapping' in local_var_params: body_params = local_var_params['label_mapping'] @@ -1928,30 +2174,7 @@ def post_dashboards_id_labels_with_http_info(self, dashboard_id, label_mapping, header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501 ['application/json']) # noqa: E501 - # Authentication setting - auth_settings = [] # noqa: E501 - - # urlopen optional setting - urlopen_kw = None - if 'urlopen_kw' in kwargs: - urlopen_kw = kwargs['urlopen_kw'] - - return self.api_client.call_api( - '/api/v2/dashboards/{dashboardID}/labels', 'POST', - path_params, - query_params, - header_params, - body=body_params, - post_params=form_params, - files=local_var_files, - response_type='LabelResponse', # noqa: E501 - auth_settings=auth_settings, - async_req=local_var_params.get('async_req'), - _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 - _preload_content=local_var_params.get('_preload_content', True), - _request_timeout=local_var_params.get('_request_timeout'), - collection_formats=collection_formats, - urlopen_kw=urlopen_kw) + return local_var_params, path_params, query_params, header_params, body_params def post_dashboards_id_members(self, dashboard_id, add_resource_member_request_body, **kwargs): # noqa: E501,D401,D403 """Add a member to a dashboard. @@ -1992,23 +2215,64 @@ def post_dashboards_id_members_with_http_info(self, dashboard_id, add_resource_m If the method is called asynchronously, returns the request thread. """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._post_dashboards_id_members_prepare(dashboard_id, add_resource_member_request_body, **kwargs) + + return self.api_client.call_api( + '/api/v2/dashboards/{dashboardID}/members', 'POST', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='ResourceMember', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + async def post_dashboards_id_members_async(self, dashboard_id, add_resource_member_request_body, **kwargs): # noqa: E501,D401,D403 + """Add a member to a dashboard. + + This method makes an asynchronous HTTP request. + + :param async_req bool + :param str dashboard_id: The dashboard ID. (required) + :param AddResourceMemberRequestBody add_resource_member_request_body: User to add as member (required) + :param str zap_trace_span: OpenTracing span context + :return: ResourceMember + If the method is called asynchronously, + returns the request thread. + """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._post_dashboards_id_members_prepare(dashboard_id, add_resource_member_request_body, **kwargs) + + return await self.api_client.call_api( + '/api/v2/dashboards/{dashboardID}/members', 'POST', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='ResourceMember', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + def _post_dashboards_id_members_prepare(self, dashboard_id, add_resource_member_request_body, **kwargs): # noqa: E501,D401,D403 local_var_params = locals() all_params = ['dashboard_id', 'add_resource_member_request_body', 'zap_trace_span'] # noqa: E501 - all_params.append('async_req') - all_params.append('_return_http_data_only') - all_params.append('_preload_content') - all_params.append('_request_timeout') - all_params.append('urlopen_kw') - - for key, val in six.iteritems(local_var_params['kwargs']): - if key not in all_params: - raise TypeError( - "Got an unexpected keyword argument '%s'" - " to method post_dashboards_id_members" % key - ) - local_var_params[key] = val - del local_var_params['kwargs'] + self._check_operation_params('post_dashboards_id_members', all_params, local_var_params) # verify the required parameter 'dashboard_id' is set if ('dashboard_id' not in local_var_params or local_var_params['dashboard_id'] is None): @@ -2018,8 +2282,6 @@ def post_dashboards_id_members_with_http_info(self, dashboard_id, add_resource_m local_var_params['add_resource_member_request_body'] is None): raise ValueError("Missing the required parameter `add_resource_member_request_body` when calling `post_dashboards_id_members`") # noqa: E501 - collection_formats = {} - path_params = {} if 'dashboard_id' in local_var_params: path_params['dashboardID'] = local_var_params['dashboard_id'] # noqa: E501 @@ -2030,9 +2292,6 @@ def post_dashboards_id_members_with_http_info(self, dashboard_id, add_resource_m if 'zap_trace_span' in local_var_params: header_params['Zap-Trace-Span'] = local_var_params['zap_trace_span'] # noqa: E501 - form_params = [] - local_var_files = {} - body_params = None if 'add_resource_member_request_body' in local_var_params: body_params = local_var_params['add_resource_member_request_body'] @@ -2044,30 +2303,7 @@ def post_dashboards_id_members_with_http_info(self, dashboard_id, add_resource_m header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501 ['application/json']) # noqa: E501 - # Authentication setting - auth_settings = [] # noqa: E501 - - # urlopen optional setting - urlopen_kw = None - if 'urlopen_kw' in kwargs: - urlopen_kw = kwargs['urlopen_kw'] - - return self.api_client.call_api( - '/api/v2/dashboards/{dashboardID}/members', 'POST', - path_params, - query_params, - header_params, - body=body_params, - post_params=form_params, - files=local_var_files, - response_type='ResourceMember', # noqa: E501 - auth_settings=auth_settings, - async_req=local_var_params.get('async_req'), - _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 - _preload_content=local_var_params.get('_preload_content', True), - _request_timeout=local_var_params.get('_request_timeout'), - collection_formats=collection_formats, - urlopen_kw=urlopen_kw) + return local_var_params, path_params, query_params, header_params, body_params def post_dashboards_id_owners(self, dashboard_id, add_resource_member_request_body, **kwargs): # noqa: E501,D401,D403 """Add an owner to a dashboard. @@ -2108,23 +2344,64 @@ def post_dashboards_id_owners_with_http_info(self, dashboard_id, add_resource_me If the method is called asynchronously, returns the request thread. """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._post_dashboards_id_owners_prepare(dashboard_id, add_resource_member_request_body, **kwargs) + + return self.api_client.call_api( + '/api/v2/dashboards/{dashboardID}/owners', 'POST', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='ResourceOwner', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + async def post_dashboards_id_owners_async(self, dashboard_id, add_resource_member_request_body, **kwargs): # noqa: E501,D401,D403 + """Add an owner to a dashboard. + + This method makes an asynchronous HTTP request. + + :param async_req bool + :param str dashboard_id: The dashboard ID. (required) + :param AddResourceMemberRequestBody add_resource_member_request_body: User to add as owner (required) + :param str zap_trace_span: OpenTracing span context + :return: ResourceOwner + If the method is called asynchronously, + returns the request thread. + """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._post_dashboards_id_owners_prepare(dashboard_id, add_resource_member_request_body, **kwargs) + + return await self.api_client.call_api( + '/api/v2/dashboards/{dashboardID}/owners', 'POST', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='ResourceOwner', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + def _post_dashboards_id_owners_prepare(self, dashboard_id, add_resource_member_request_body, **kwargs): # noqa: E501,D401,D403 local_var_params = locals() all_params = ['dashboard_id', 'add_resource_member_request_body', 'zap_trace_span'] # noqa: E501 - all_params.append('async_req') - all_params.append('_return_http_data_only') - all_params.append('_preload_content') - all_params.append('_request_timeout') - all_params.append('urlopen_kw') - - for key, val in six.iteritems(local_var_params['kwargs']): - if key not in all_params: - raise TypeError( - "Got an unexpected keyword argument '%s'" - " to method post_dashboards_id_owners" % key - ) - local_var_params[key] = val - del local_var_params['kwargs'] + self._check_operation_params('post_dashboards_id_owners', all_params, local_var_params) # verify the required parameter 'dashboard_id' is set if ('dashboard_id' not in local_var_params or local_var_params['dashboard_id'] is None): @@ -2134,8 +2411,6 @@ def post_dashboards_id_owners_with_http_info(self, dashboard_id, add_resource_me local_var_params['add_resource_member_request_body'] is None): raise ValueError("Missing the required parameter `add_resource_member_request_body` when calling `post_dashboards_id_owners`") # noqa: E501 - collection_formats = {} - path_params = {} if 'dashboard_id' in local_var_params: path_params['dashboardID'] = local_var_params['dashboard_id'] # noqa: E501 @@ -2146,9 +2421,6 @@ def post_dashboards_id_owners_with_http_info(self, dashboard_id, add_resource_me if 'zap_trace_span' in local_var_params: header_params['Zap-Trace-Span'] = local_var_params['zap_trace_span'] # noqa: E501 - form_params = [] - local_var_files = {} - body_params = None if 'add_resource_member_request_body' in local_var_params: body_params = local_var_params['add_resource_member_request_body'] @@ -2160,30 +2432,7 @@ def post_dashboards_id_owners_with_http_info(self, dashboard_id, add_resource_me header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501 ['application/json']) # noqa: E501 - # Authentication setting - auth_settings = [] # noqa: E501 - - # urlopen optional setting - urlopen_kw = None - if 'urlopen_kw' in kwargs: - urlopen_kw = kwargs['urlopen_kw'] - - return self.api_client.call_api( - '/api/v2/dashboards/{dashboardID}/owners', 'POST', - path_params, - query_params, - header_params, - body=body_params, - post_params=form_params, - files=local_var_files, - response_type='ResourceOwner', # noqa: E501 - auth_settings=auth_settings, - async_req=local_var_params.get('async_req'), - _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 - _preload_content=local_var_params.get('_preload_content', True), - _request_timeout=local_var_params.get('_request_timeout'), - collection_formats=collection_formats, - urlopen_kw=urlopen_kw) + return local_var_params, path_params, query_params, header_params, body_params def put_dashboards_id_cells(self, dashboard_id, cell, **kwargs): # noqa: E501,D401,D403 """Replace cells in a dashboard. @@ -2226,23 +2475,65 @@ def put_dashboards_id_cells_with_http_info(self, dashboard_id, cell, **kwargs): If the method is called asynchronously, returns the request thread. """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._put_dashboards_id_cells_prepare(dashboard_id, cell, **kwargs) + + return self.api_client.call_api( + '/api/v2/dashboards/{dashboardID}/cells', 'PUT', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='Dashboard', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + async def put_dashboards_id_cells_async(self, dashboard_id, cell, **kwargs): # noqa: E501,D401,D403 + """Replace cells in a dashboard. + + Replaces all cells in a dashboard. This is used primarily to update the positional information of all cells. + This method makes an asynchronous HTTP request. + + :param async_req bool + :param str dashboard_id: The ID of the dashboard to update. (required) + :param list[Cell] cell: (required) + :param str zap_trace_span: OpenTracing span context + :return: Dashboard + If the method is called asynchronously, + returns the request thread. + """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._put_dashboards_id_cells_prepare(dashboard_id, cell, **kwargs) + + return await self.api_client.call_api( + '/api/v2/dashboards/{dashboardID}/cells', 'PUT', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='Dashboard', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + def _put_dashboards_id_cells_prepare(self, dashboard_id, cell, **kwargs): # noqa: E501,D401,D403 local_var_params = locals() all_params = ['dashboard_id', 'cell', 'zap_trace_span'] # noqa: E501 - all_params.append('async_req') - all_params.append('_return_http_data_only') - all_params.append('_preload_content') - all_params.append('_request_timeout') - all_params.append('urlopen_kw') - - for key, val in six.iteritems(local_var_params['kwargs']): - if key not in all_params: - raise TypeError( - "Got an unexpected keyword argument '%s'" - " to method put_dashboards_id_cells" % key - ) - local_var_params[key] = val - del local_var_params['kwargs'] + self._check_operation_params('put_dashboards_id_cells', all_params, local_var_params) # verify the required parameter 'dashboard_id' is set if ('dashboard_id' not in local_var_params or local_var_params['dashboard_id'] is None): @@ -2252,8 +2543,6 @@ def put_dashboards_id_cells_with_http_info(self, dashboard_id, cell, **kwargs): local_var_params['cell'] is None): raise ValueError("Missing the required parameter `cell` when calling `put_dashboards_id_cells`") # noqa: E501 - collection_formats = {} - path_params = {} if 'dashboard_id' in local_var_params: path_params['dashboardID'] = local_var_params['dashboard_id'] # noqa: E501 @@ -2264,9 +2553,6 @@ def put_dashboards_id_cells_with_http_info(self, dashboard_id, cell, **kwargs): if 'zap_trace_span' in local_var_params: header_params['Zap-Trace-Span'] = local_var_params['zap_trace_span'] # noqa: E501 - form_params = [] - local_var_files = {} - body_params = None if 'cell' in local_var_params: body_params = local_var_params['cell'] @@ -2278,27 +2564,4 @@ def put_dashboards_id_cells_with_http_info(self, dashboard_id, cell, **kwargs): header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501 ['application/json']) # noqa: E501 - # Authentication setting - auth_settings = [] # noqa: E501 - - # urlopen optional setting - urlopen_kw = None - if 'urlopen_kw' in kwargs: - urlopen_kw = kwargs['urlopen_kw'] - - return self.api_client.call_api( - '/api/v2/dashboards/{dashboardID}/cells', 'PUT', - path_params, - query_params, - header_params, - body=body_params, - post_params=form_params, - files=local_var_files, - response_type='Dashboard', # noqa: E501 - auth_settings=auth_settings, - async_req=local_var_params.get('async_req'), - _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 - _preload_content=local_var_params.get('_preload_content', True), - _request_timeout=local_var_params.get('_request_timeout'), - collection_formats=collection_formats, - urlopen_kw=urlopen_kw) + return local_var_params, path_params, query_params, header_params, body_params diff --git a/influxdb_client/service/dbr_ps_service.py b/influxdb_client/service/dbr_ps_service.py index 8ba96319..f87e3315 100644 --- a/influxdb_client/service/dbr_ps_service.py +++ b/influxdb_client/service/dbr_ps_service.py @@ -14,11 +14,10 @@ import re # noqa: F401 -# python 2 and python 3 compatibility library -import six +from influxdb_client.service._base_service import _BaseService -class DBRPsService(object): +class DBRPsService(_BaseService): """NOTE: This class is auto generated by OpenAPI Generator. Ref: https://openapi-generator.tech @@ -73,30 +72,70 @@ def delete_dbrpid_with_http_info(self, dbrp_id, **kwargs): # noqa: E501,D401,D4 If the method is called asynchronously, returns the request thread. """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._delete_dbrpid_prepare(dbrp_id, **kwargs) + + return self.api_client.call_api( + '/api/v2/dbrps/{dbrpID}', 'DELETE', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type=None, # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + async def delete_dbrpid_async(self, dbrp_id, **kwargs): # noqa: E501,D401,D403 + """Delete a database retention policy. + + This method makes an asynchronous HTTP request. + + :param async_req bool + :param str dbrp_id: The database retention policy mapping (required) + :param str zap_trace_span: OpenTracing span context + :param str org_id: Specifies the organization ID of the mapping + :param str org: Specifies the organization name of the mapping + :return: None + If the method is called asynchronously, + returns the request thread. + """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._delete_dbrpid_prepare(dbrp_id, **kwargs) + + return await self.api_client.call_api( + '/api/v2/dbrps/{dbrpID}', 'DELETE', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type=None, # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + def _delete_dbrpid_prepare(self, dbrp_id, **kwargs): # noqa: E501,D401,D403 local_var_params = locals() all_params = ['dbrp_id', 'zap_trace_span', 'org_id', 'org'] # noqa: E501 - all_params.append('async_req') - all_params.append('_return_http_data_only') - all_params.append('_preload_content') - all_params.append('_request_timeout') - all_params.append('urlopen_kw') - - for key, val in six.iteritems(local_var_params['kwargs']): - if key not in all_params: - raise TypeError( - "Got an unexpected keyword argument '%s'" - " to method delete_dbrpid" % key - ) - local_var_params[key] = val - del local_var_params['kwargs'] + self._check_operation_params('delete_dbrpid', all_params, local_var_params) # verify the required parameter 'dbrp_id' is set if ('dbrp_id' not in local_var_params or local_var_params['dbrp_id'] is None): raise ValueError("Missing the required parameter `dbrp_id` when calling `delete_dbrpid`") # noqa: E501 - collection_formats = {} - path_params = {} if 'dbrp_id' in local_var_params: path_params['dbrpID'] = local_var_params['dbrp_id'] # noqa: E501 @@ -111,38 +150,12 @@ def delete_dbrpid_with_http_info(self, dbrp_id, **kwargs): # noqa: E501,D401,D4 if 'zap_trace_span' in local_var_params: header_params['Zap-Trace-Span'] = local_var_params['zap_trace_span'] # noqa: E501 - form_params = [] - local_var_files = {} - body_params = None # HTTP header `Accept` header_params['Accept'] = self.api_client.select_header_accept( ['application/json']) # noqa: E501 - # Authentication setting - auth_settings = [] # noqa: E501 - - # urlopen optional setting - urlopen_kw = None - if 'urlopen_kw' in kwargs: - urlopen_kw = kwargs['urlopen_kw'] - - return self.api_client.call_api( - '/api/v2/dbrps/{dbrpID}', 'DELETE', - path_params, - query_params, - header_params, - body=body_params, - post_params=form_params, - files=local_var_files, - response_type=None, # noqa: E501 - auth_settings=auth_settings, - async_req=local_var_params.get('async_req'), - _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 - _preload_content=local_var_params.get('_preload_content', True), - _request_timeout=local_var_params.get('_request_timeout'), - collection_formats=collection_formats, - urlopen_kw=urlopen_kw) + return local_var_params, path_params, query_params, header_params, body_params def get_dbr_ps(self, **kwargs): # noqa: E501,D401,D403 """List database retention policy mappings. @@ -193,25 +206,69 @@ def get_dbr_ps_with_http_info(self, **kwargs): # noqa: E501,D401,D403 If the method is called asynchronously, returns the request thread. """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._get_dbr_ps_prepare(**kwargs) + + return self.api_client.call_api( + '/api/v2/dbrps', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='DBRPs', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + async def get_dbr_ps_async(self, **kwargs): # noqa: E501,D401,D403 + """List database retention policy mappings. + + This method makes an asynchronous HTTP request. + + :param async_req bool + :param str zap_trace_span: OpenTracing span context + :param str org_id: Specifies the organization ID to filter on + :param str org: Specifies the organization name to filter on + :param str id: Specifies the mapping ID to filter on + :param str bucket_id: Specifies the bucket ID to filter on + :param bool default: Specifies filtering on default + :param str db: Specifies the database to filter on + :param str rp: Specifies the retention policy to filter on + :return: DBRPs + If the method is called asynchronously, + returns the request thread. + """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._get_dbr_ps_prepare(**kwargs) + + return await self.api_client.call_api( + '/api/v2/dbrps', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='DBRPs', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + def _get_dbr_ps_prepare(self, **kwargs): # noqa: E501,D401,D403 local_var_params = locals() all_params = ['zap_trace_span', 'org_id', 'org', 'id', 'bucket_id', 'default', 'db', 'rp'] # noqa: E501 - all_params.append('async_req') - all_params.append('_return_http_data_only') - all_params.append('_preload_content') - all_params.append('_request_timeout') - all_params.append('urlopen_kw') - - for key, val in six.iteritems(local_var_params['kwargs']): - if key not in all_params: - raise TypeError( - "Got an unexpected keyword argument '%s'" - " to method get_dbr_ps" % key - ) - local_var_params[key] = val - del local_var_params['kwargs'] - - collection_formats = {} + self._check_operation_params('get_dbr_ps', all_params, local_var_params) path_params = {} @@ -235,38 +292,12 @@ def get_dbr_ps_with_http_info(self, **kwargs): # noqa: E501,D401,D403 if 'zap_trace_span' in local_var_params: header_params['Zap-Trace-Span'] = local_var_params['zap_trace_span'] # noqa: E501 - form_params = [] - local_var_files = {} - body_params = None # HTTP header `Accept` header_params['Accept'] = self.api_client.select_header_accept( ['application/json']) # noqa: E501 - # Authentication setting - auth_settings = [] # noqa: E501 - - # urlopen optional setting - urlopen_kw = None - if 'urlopen_kw' in kwargs: - urlopen_kw = kwargs['urlopen_kw'] - - return self.api_client.call_api( - '/api/v2/dbrps', 'GET', - path_params, - query_params, - header_params, - body=body_params, - post_params=form_params, - files=local_var_files, - response_type='DBRPs', # noqa: E501 - auth_settings=auth_settings, - async_req=local_var_params.get('async_req'), - _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 - _preload_content=local_var_params.get('_preload_content', True), - _request_timeout=local_var_params.get('_request_timeout'), - collection_formats=collection_formats, - urlopen_kw=urlopen_kw) + return local_var_params, path_params, query_params, header_params, body_params def get_dbr_ps_id(self, dbrp_id, **kwargs): # noqa: E501,D401,D403 """Retrieve a database retention policy mapping. @@ -309,30 +340,70 @@ def get_dbr_ps_id_with_http_info(self, dbrp_id, **kwargs): # noqa: E501,D401,D4 If the method is called asynchronously, returns the request thread. """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._get_dbr_ps_id_prepare(dbrp_id, **kwargs) + + return self.api_client.call_api( + '/api/v2/dbrps/{dbrpID}', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='DBRPGet', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + async def get_dbr_ps_id_async(self, dbrp_id, **kwargs): # noqa: E501,D401,D403 + """Retrieve a database retention policy mapping. + + This method makes an asynchronous HTTP request. + + :param async_req bool + :param str dbrp_id: The database retention policy mapping ID (required) + :param str zap_trace_span: OpenTracing span context + :param str org_id: Specifies the organization ID of the mapping + :param str org: Specifies the organization name of the mapping + :return: DBRPGet + If the method is called asynchronously, + returns the request thread. + """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._get_dbr_ps_id_prepare(dbrp_id, **kwargs) + + return await self.api_client.call_api( + '/api/v2/dbrps/{dbrpID}', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='DBRPGet', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + def _get_dbr_ps_id_prepare(self, dbrp_id, **kwargs): # noqa: E501,D401,D403 local_var_params = locals() all_params = ['dbrp_id', 'zap_trace_span', 'org_id', 'org'] # noqa: E501 - all_params.append('async_req') - all_params.append('_return_http_data_only') - all_params.append('_preload_content') - all_params.append('_request_timeout') - all_params.append('urlopen_kw') - - for key, val in six.iteritems(local_var_params['kwargs']): - if key not in all_params: - raise TypeError( - "Got an unexpected keyword argument '%s'" - " to method get_dbr_ps_id" % key - ) - local_var_params[key] = val - del local_var_params['kwargs'] + self._check_operation_params('get_dbr_ps_id', all_params, local_var_params) # verify the required parameter 'dbrp_id' is set if ('dbrp_id' not in local_var_params or local_var_params['dbrp_id'] is None): raise ValueError("Missing the required parameter `dbrp_id` when calling `get_dbr_ps_id`") # noqa: E501 - collection_formats = {} - path_params = {} if 'dbrp_id' in local_var_params: path_params['dbrpID'] = local_var_params['dbrp_id'] # noqa: E501 @@ -347,38 +418,12 @@ def get_dbr_ps_id_with_http_info(self, dbrp_id, **kwargs): # noqa: E501,D401,D4 if 'zap_trace_span' in local_var_params: header_params['Zap-Trace-Span'] = local_var_params['zap_trace_span'] # noqa: E501 - form_params = [] - local_var_files = {} - body_params = None # HTTP header `Accept` header_params['Accept'] = self.api_client.select_header_accept( ['application/json']) # noqa: E501 - # Authentication setting - auth_settings = [] # noqa: E501 - - # urlopen optional setting - urlopen_kw = None - if 'urlopen_kw' in kwargs: - urlopen_kw = kwargs['urlopen_kw'] - - return self.api_client.call_api( - '/api/v2/dbrps/{dbrpID}', 'GET', - path_params, - query_params, - header_params, - body=body_params, - post_params=form_params, - files=local_var_files, - response_type='DBRPGet', # noqa: E501 - auth_settings=auth_settings, - async_req=local_var_params.get('async_req'), - _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 - _preload_content=local_var_params.get('_preload_content', True), - _request_timeout=local_var_params.get('_request_timeout'), - collection_formats=collection_formats, - urlopen_kw=urlopen_kw) + return local_var_params, path_params, query_params, header_params, body_params def patch_dbrpid(self, dbrp_id, dbrp_update, **kwargs): # noqa: E501,D401,D403 """Update a database retention policy mapping. @@ -423,23 +468,66 @@ def patch_dbrpid_with_http_info(self, dbrp_id, dbrp_update, **kwargs): # noqa: If the method is called asynchronously, returns the request thread. """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._patch_dbrpid_prepare(dbrp_id, dbrp_update, **kwargs) + + return self.api_client.call_api( + '/api/v2/dbrps/{dbrpID}', 'PATCH', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='DBRPGet', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + async def patch_dbrpid_async(self, dbrp_id, dbrp_update, **kwargs): # noqa: E501,D401,D403 + """Update a database retention policy mapping. + + This method makes an asynchronous HTTP request. + + :param async_req bool + :param str dbrp_id: The database retention policy mapping. (required) + :param DBRPUpdate dbrp_update: Database retention policy update to apply (required) + :param str zap_trace_span: OpenTracing span context + :param str org_id: Specifies the organization ID of the mapping + :param str org: Specifies the organization name of the mapping + :return: DBRPGet + If the method is called asynchronously, + returns the request thread. + """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._patch_dbrpid_prepare(dbrp_id, dbrp_update, **kwargs) + + return await self.api_client.call_api( + '/api/v2/dbrps/{dbrpID}', 'PATCH', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='DBRPGet', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + def _patch_dbrpid_prepare(self, dbrp_id, dbrp_update, **kwargs): # noqa: E501,D401,D403 local_var_params = locals() all_params = ['dbrp_id', 'dbrp_update', 'zap_trace_span', 'org_id', 'org'] # noqa: E501 - all_params.append('async_req') - all_params.append('_return_http_data_only') - all_params.append('_preload_content') - all_params.append('_request_timeout') - all_params.append('urlopen_kw') - - for key, val in six.iteritems(local_var_params['kwargs']): - if key not in all_params: - raise TypeError( - "Got an unexpected keyword argument '%s'" - " to method patch_dbrpid" % key - ) - local_var_params[key] = val - del local_var_params['kwargs'] + self._check_operation_params('patch_dbrpid', all_params, local_var_params) # verify the required parameter 'dbrp_id' is set if ('dbrp_id' not in local_var_params or local_var_params['dbrp_id'] is None): @@ -449,8 +537,6 @@ def patch_dbrpid_with_http_info(self, dbrp_id, dbrp_update, **kwargs): # noqa: local_var_params['dbrp_update'] is None): raise ValueError("Missing the required parameter `dbrp_update` when calling `patch_dbrpid`") # noqa: E501 - collection_formats = {} - path_params = {} if 'dbrp_id' in local_var_params: path_params['dbrpID'] = local_var_params['dbrp_id'] # noqa: E501 @@ -465,9 +551,6 @@ def patch_dbrpid_with_http_info(self, dbrp_id, dbrp_update, **kwargs): # noqa: if 'zap_trace_span' in local_var_params: header_params['Zap-Trace-Span'] = local_var_params['zap_trace_span'] # noqa: E501 - form_params = [] - local_var_files = {} - body_params = None if 'dbrp_update' in local_var_params: body_params = local_var_params['dbrp_update'] @@ -479,30 +562,7 @@ def patch_dbrpid_with_http_info(self, dbrp_id, dbrp_update, **kwargs): # noqa: header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501 ['application/json']) # noqa: E501 - # Authentication setting - auth_settings = [] # noqa: E501 - - # urlopen optional setting - urlopen_kw = None - if 'urlopen_kw' in kwargs: - urlopen_kw = kwargs['urlopen_kw'] - - return self.api_client.call_api( - '/api/v2/dbrps/{dbrpID}', 'PATCH', - path_params, - query_params, - header_params, - body=body_params, - post_params=form_params, - files=local_var_files, - response_type='DBRPGet', # noqa: E501 - auth_settings=auth_settings, - async_req=local_var_params.get('async_req'), - _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 - _preload_content=local_var_params.get('_preload_content', True), - _request_timeout=local_var_params.get('_request_timeout'), - collection_formats=collection_formats, - urlopen_kw=urlopen_kw) + return local_var_params, path_params, query_params, header_params, body_params def post_dbrp(self, dbrp_create, **kwargs): # noqa: E501,D401,D403 """Add a database retention policy mapping. @@ -541,30 +601,68 @@ def post_dbrp_with_http_info(self, dbrp_create, **kwargs): # noqa: E501,D401,D4 If the method is called asynchronously, returns the request thread. """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._post_dbrp_prepare(dbrp_create, **kwargs) + + return self.api_client.call_api( + '/api/v2/dbrps', 'POST', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='DBRP', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + async def post_dbrp_async(self, dbrp_create, **kwargs): # noqa: E501,D401,D403 + """Add a database retention policy mapping. + + This method makes an asynchronous HTTP request. + + :param async_req bool + :param DBRPCreate dbrp_create: The database retention policy mapping to add (required) + :param str zap_trace_span: OpenTracing span context + :return: DBRP + If the method is called asynchronously, + returns the request thread. + """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._post_dbrp_prepare(dbrp_create, **kwargs) + + return await self.api_client.call_api( + '/api/v2/dbrps', 'POST', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='DBRP', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + def _post_dbrp_prepare(self, dbrp_create, **kwargs): # noqa: E501,D401,D403 local_var_params = locals() all_params = ['dbrp_create', 'zap_trace_span'] # noqa: E501 - all_params.append('async_req') - all_params.append('_return_http_data_only') - all_params.append('_preload_content') - all_params.append('_request_timeout') - all_params.append('urlopen_kw') - - for key, val in six.iteritems(local_var_params['kwargs']): - if key not in all_params: - raise TypeError( - "Got an unexpected keyword argument '%s'" - " to method post_dbrp" % key - ) - local_var_params[key] = val - del local_var_params['kwargs'] + self._check_operation_params('post_dbrp', all_params, local_var_params) # verify the required parameter 'dbrp_create' is set if ('dbrp_create' not in local_var_params or local_var_params['dbrp_create'] is None): raise ValueError("Missing the required parameter `dbrp_create` when calling `post_dbrp`") # noqa: E501 - collection_formats = {} - path_params = {} query_params = [] @@ -573,9 +671,6 @@ def post_dbrp_with_http_info(self, dbrp_create, **kwargs): # noqa: E501,D401,D4 if 'zap_trace_span' in local_var_params: header_params['Zap-Trace-Span'] = local_var_params['zap_trace_span'] # noqa: E501 - form_params = [] - local_var_files = {} - body_params = None if 'dbrp_create' in local_var_params: body_params = local_var_params['dbrp_create'] @@ -587,27 +682,4 @@ def post_dbrp_with_http_info(self, dbrp_create, **kwargs): # noqa: E501,D401,D4 header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501 ['application/json']) # noqa: E501 - # Authentication setting - auth_settings = [] # noqa: E501 - - # urlopen optional setting - urlopen_kw = None - if 'urlopen_kw' in kwargs: - urlopen_kw = kwargs['urlopen_kw'] - - return self.api_client.call_api( - '/api/v2/dbrps', 'POST', - path_params, - query_params, - header_params, - body=body_params, - post_params=form_params, - files=local_var_files, - response_type='DBRP', # noqa: E501 - auth_settings=auth_settings, - async_req=local_var_params.get('async_req'), - _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 - _preload_content=local_var_params.get('_preload_content', True), - _request_timeout=local_var_params.get('_request_timeout'), - collection_formats=collection_formats, - urlopen_kw=urlopen_kw) + return local_var_params, path_params, query_params, header_params, body_params diff --git a/influxdb_client/service/delete_service.py b/influxdb_client/service/delete_service.py index 7e625be8..91af22e0 100644 --- a/influxdb_client/service/delete_service.py +++ b/influxdb_client/service/delete_service.py @@ -14,11 +14,10 @@ import re # noqa: F401 -# python 2 and python 3 compatibility library -import six +from influxdb_client.service._base_service import _BaseService -class DeleteService(object): +class DeleteService(_BaseService): """NOTE: This class is auto generated by OpenAPI Generator. Ref: https://openapi-generator.tech @@ -77,67 +76,8 @@ def post_delete_with_http_info(self, delete_predicate_request, **kwargs): # noq If the method is called asynchronously, returns the request thread. """ # noqa: E501 - local_var_params = locals() - - all_params = ['delete_predicate_request', 'zap_trace_span', 'org', 'bucket', 'org_id', 'bucket_id'] # noqa: E501 - all_params.append('async_req') - all_params.append('_return_http_data_only') - all_params.append('_preload_content') - all_params.append('_request_timeout') - all_params.append('urlopen_kw') - - for key, val in six.iteritems(local_var_params['kwargs']): - if key not in all_params: - raise TypeError( - "Got an unexpected keyword argument '%s'" - " to method post_delete" % key - ) - local_var_params[key] = val - del local_var_params['kwargs'] - # verify the required parameter 'delete_predicate_request' is set - if ('delete_predicate_request' not in local_var_params or - local_var_params['delete_predicate_request'] is None): - raise ValueError("Missing the required parameter `delete_predicate_request` when calling `post_delete`") # noqa: E501 - - collection_formats = {} - - path_params = {} - - query_params = [] - if 'org' in local_var_params: - query_params.append(('org', local_var_params['org'])) # noqa: E501 - if 'bucket' in local_var_params: - query_params.append(('bucket', local_var_params['bucket'])) # noqa: E501 - if 'org_id' in local_var_params: - query_params.append(('orgID', local_var_params['org_id'])) # noqa: E501 - if 'bucket_id' in local_var_params: - query_params.append(('bucketID', local_var_params['bucket_id'])) # noqa: E501 - - header_params = {} - if 'zap_trace_span' in local_var_params: - header_params['Zap-Trace-Span'] = local_var_params['zap_trace_span'] # noqa: E501 - - form_params = [] - local_var_files = {} - - body_params = None - if 'delete_predicate_request' in local_var_params: - body_params = local_var_params['delete_predicate_request'] - # HTTP header `Accept` - header_params['Accept'] = self.api_client.select_header_accept( - ['application/json']) # noqa: E501 - - # HTTP header `Content-Type` - header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501 - ['application/json']) # noqa: E501 - - # Authentication setting - auth_settings = [] # noqa: E501 - - # urlopen optional setting - urlopen_kw = None - if 'urlopen_kw' in kwargs: - urlopen_kw = kwargs['urlopen_kw'] + local_var_params, path_params, query_params, header_params, body_params = \ + self._post_delete_prepare(delete_predicate_request, **kwargs) return self.api_client.call_api( '/api/v2/delete', 'POST', @@ -145,24 +85,21 @@ def post_delete_with_http_info(self, delete_predicate_request, **kwargs): # noq query_params, header_params, body=body_params, - post_params=form_params, - files=local_var_files, + post_params=[], + files={}, response_type=None, # noqa: E501 - auth_settings=auth_settings, + auth_settings=[], async_req=local_var_params.get('async_req'), _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 _preload_content=local_var_params.get('_preload_content', True), _request_timeout=local_var_params.get('_request_timeout'), - collection_formats=collection_formats, - urlopen_kw=urlopen_kw) + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) async def post_delete_async(self, delete_predicate_request, **kwargs): # noqa: E501,D401,D403 """Delete data. - This method makes a synchronous HTTP request by default. To make an - asynchronous HTTP request, please pass async_req=True - >>> thread = api.post_delete_with_http_info(delete_predicate_request, async_req=True) - >>> result = thread.get() + This method makes an asynchronous HTTP request. :param async_req bool :param DeletePredicateRequest delete_predicate_request: Deletes data from an InfluxDB bucket. (required) @@ -175,30 +112,36 @@ async def post_delete_async(self, delete_predicate_request, **kwargs): # noqa: If the method is called asynchronously, returns the request thread. """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._post_delete_prepare(delete_predicate_request, **kwargs) + + return await self.api_client.call_api( + '/api/v2/delete', 'POST', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type=None, # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + def _post_delete_prepare(self, delete_predicate_request, **kwargs): # noqa: E501,D401,D403 local_var_params = locals() all_params = ['delete_predicate_request', 'zap_trace_span', 'org', 'bucket', 'org_id', 'bucket_id'] # noqa: E501 - all_params.append('async_req') - all_params.append('_return_http_data_only') - all_params.append('_preload_content') - all_params.append('_request_timeout') - all_params.append('urlopen_kw') - - for key, val in six.iteritems(local_var_params['kwargs']): - if key not in all_params: - raise TypeError( - "Got an unexpected keyword argument '%s'" - " to method post_delete" % key - ) - local_var_params[key] = val - del local_var_params['kwargs'] + self._check_operation_params('post_delete', all_params, local_var_params) # verify the required parameter 'delete_predicate_request' is set if ('delete_predicate_request' not in local_var_params or local_var_params['delete_predicate_request'] is None): raise ValueError("Missing the required parameter `delete_predicate_request` when calling `post_delete`") # noqa: E501 - collection_formats = {} - path_params = {} query_params = [] @@ -215,9 +158,6 @@ async def post_delete_async(self, delete_predicate_request, **kwargs): # noqa: if 'zap_trace_span' in local_var_params: header_params['Zap-Trace-Span'] = local_var_params['zap_trace_span'] # noqa: E501 - form_params = [] - local_var_files = {} - body_params = None if 'delete_predicate_request' in local_var_params: body_params = local_var_params['delete_predicate_request'] @@ -229,27 +169,4 @@ async def post_delete_async(self, delete_predicate_request, **kwargs): # noqa: header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501 ['application/json']) # noqa: E501 - # Authentication setting - auth_settings = [] # noqa: E501 - - # urlopen optional setting - urlopen_kw = None - if 'urlopen_kw' in kwargs: - urlopen_kw = kwargs['urlopen_kw'] - - return await self.api_client.call_api( - '/api/v2/delete', 'POST', - path_params, - query_params, - header_params, - body=body_params, - post_params=form_params, - files=local_var_files, - response_type=None, # noqa: E501 - auth_settings=auth_settings, - async_req=local_var_params.get('async_req'), - _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 - _preload_content=local_var_params.get('_preload_content', True), - _request_timeout=local_var_params.get('_request_timeout'), - collection_formats=collection_formats, - urlopen_kw=urlopen_kw) + return local_var_params, path_params, query_params, header_params, body_params diff --git a/influxdb_client/service/health_service.py b/influxdb_client/service/health_service.py index 963abf51..aa5a5add 100644 --- a/influxdb_client/service/health_service.py +++ b/influxdb_client/service/health_service.py @@ -14,11 +14,10 @@ import re # noqa: F401 -# python 2 and python 3 compatibility library -import six +from influxdb_client.service._base_service import _BaseService -class HealthService(object): +class HealthService(_BaseService): """NOTE: This class is auto generated by OpenAPI Generator. Ref: https://openapi-generator.tech @@ -67,25 +66,62 @@ def get_health_with_http_info(self, **kwargs): # noqa: E501,D401,D403 If the method is called asynchronously, returns the request thread. """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._get_health_prepare(**kwargs) + + return self.api_client.call_api( + '/health', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='HealthCheck', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + async def get_health_async(self, **kwargs): # noqa: E501,D401,D403 + """Get the health of an instance. + + This method makes an asynchronous HTTP request. + + :param async_req bool + :param str zap_trace_span: OpenTracing span context + :return: HealthCheck + If the method is called asynchronously, + returns the request thread. + """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._get_health_prepare(**kwargs) + + return await self.api_client.call_api( + '/health', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='HealthCheck', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + def _get_health_prepare(self, **kwargs): # noqa: E501,D401,D403 local_var_params = locals() all_params = ['zap_trace_span'] # noqa: E501 - all_params.append('async_req') - all_params.append('_return_http_data_only') - all_params.append('_preload_content') - all_params.append('_request_timeout') - all_params.append('urlopen_kw') - - for key, val in six.iteritems(local_var_params['kwargs']): - if key not in all_params: - raise TypeError( - "Got an unexpected keyword argument '%s'" - " to method get_health" % key - ) - local_var_params[key] = val - del local_var_params['kwargs'] - - collection_formats = {} + self._check_operation_params('get_health', all_params, local_var_params) path_params = {} @@ -95,35 +131,9 @@ def get_health_with_http_info(self, **kwargs): # noqa: E501,D401,D403 if 'zap_trace_span' in local_var_params: header_params['Zap-Trace-Span'] = local_var_params['zap_trace_span'] # noqa: E501 - form_params = [] - local_var_files = {} - body_params = None # HTTP header `Accept` header_params['Accept'] = self.api_client.select_header_accept( ['application/json']) # noqa: E501 - # Authentication setting - auth_settings = [] # noqa: E501 - - # urlopen optional setting - urlopen_kw = None - if 'urlopen_kw' in kwargs: - urlopen_kw = kwargs['urlopen_kw'] - - return self.api_client.call_api( - '/health', 'GET', - path_params, - query_params, - header_params, - body=body_params, - post_params=form_params, - files=local_var_files, - response_type='HealthCheck', # noqa: E501 - auth_settings=auth_settings, - async_req=local_var_params.get('async_req'), - _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 - _preload_content=local_var_params.get('_preload_content', True), - _request_timeout=local_var_params.get('_request_timeout'), - collection_formats=collection_formats, - urlopen_kw=urlopen_kw) + return local_var_params, path_params, query_params, header_params, body_params diff --git a/influxdb_client/service/invocable_scripts_service.py b/influxdb_client/service/invocable_scripts_service.py index 699dea37..d11da1af 100644 --- a/influxdb_client/service/invocable_scripts_service.py +++ b/influxdb_client/service/invocable_scripts_service.py @@ -14,11 +14,10 @@ import re # noqa: F401 -# python 2 and python 3 compatibility library -import six +from influxdb_client.service._base_service import _BaseService -class InvocableScriptsService(object): +class InvocableScriptsService(_BaseService): """NOTE: This class is auto generated by OpenAPI Generator. Ref: https://openapi-generator.tech @@ -69,30 +68,68 @@ def delete_scripts_id_with_http_info(self, script_id, **kwargs): # noqa: E501,D If the method is called asynchronously, returns the request thread. """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._delete_scripts_id_prepare(script_id, **kwargs) + + return self.api_client.call_api( + '/api/v2/scripts/{scriptID}', 'DELETE', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type=None, # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + async def delete_scripts_id_async(self, script_id, **kwargs): # noqa: E501,D401,D403 + """Delete a script. + + Deletes a script and all associated records. + This method makes an asynchronous HTTP request. + + :param async_req bool + :param str script_id: The ID of the script to delete. (required) + :return: None + If the method is called asynchronously, + returns the request thread. + """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._delete_scripts_id_prepare(script_id, **kwargs) + + return await self.api_client.call_api( + '/api/v2/scripts/{scriptID}', 'DELETE', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type=None, # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + def _delete_scripts_id_prepare(self, script_id, **kwargs): # noqa: E501,D401,D403 local_var_params = locals() all_params = ['script_id'] # noqa: E501 - all_params.append('async_req') - all_params.append('_return_http_data_only') - all_params.append('_preload_content') - all_params.append('_request_timeout') - all_params.append('urlopen_kw') - - for key, val in six.iteritems(local_var_params['kwargs']): - if key not in all_params: - raise TypeError( - "Got an unexpected keyword argument '%s'" - " to method delete_scripts_id" % key - ) - local_var_params[key] = val - del local_var_params['kwargs'] + self._check_operation_params('delete_scripts_id', all_params, local_var_params) # verify the required parameter 'script_id' is set if ('script_id' not in local_var_params or local_var_params['script_id'] is None): raise ValueError("Missing the required parameter `script_id` when calling `delete_scripts_id`") # noqa: E501 - collection_formats = {} - path_params = {} if 'script_id' in local_var_params: path_params['scriptID'] = local_var_params['script_id'] # noqa: E501 @@ -101,38 +138,12 @@ def delete_scripts_id_with_http_info(self, script_id, **kwargs): # noqa: E501,D header_params = {} - form_params = [] - local_var_files = {} - body_params = None # HTTP header `Accept` header_params['Accept'] = self.api_client.select_header_accept( ['application/json']) # noqa: E501 - # Authentication setting - auth_settings = [] # noqa: E501 - - # urlopen optional setting - urlopen_kw = None - if 'urlopen_kw' in kwargs: - urlopen_kw = kwargs['urlopen_kw'] - - return self.api_client.call_api( - '/api/v2/scripts/{scriptID}', 'DELETE', - path_params, - query_params, - header_params, - body=body_params, - post_params=form_params, - files=local_var_files, - response_type=None, # noqa: E501 - auth_settings=auth_settings, - async_req=local_var_params.get('async_req'), - _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 - _preload_content=local_var_params.get('_preload_content', True), - _request_timeout=local_var_params.get('_request_timeout'), - collection_formats=collection_formats, - urlopen_kw=urlopen_kw) + return local_var_params, path_params, query_params, header_params, body_params def get_scripts(self, **kwargs): # noqa: E501,D401,D403 """List scripts. @@ -171,25 +182,63 @@ def get_scripts_with_http_info(self, **kwargs): # noqa: E501,D401,D403 If the method is called asynchronously, returns the request thread. """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._get_scripts_prepare(**kwargs) + + return self.api_client.call_api( + '/api/v2/scripts', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='Scripts', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + async def get_scripts_async(self, **kwargs): # noqa: E501,D401,D403 + """List scripts. + + This method makes an asynchronous HTTP request. + + :param async_req bool + :param int limit: The number of scripts to return. + :param int offset: The offset for pagination. + :return: Scripts + If the method is called asynchronously, + returns the request thread. + """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._get_scripts_prepare(**kwargs) + + return await self.api_client.call_api( + '/api/v2/scripts', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='Scripts', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + def _get_scripts_prepare(self, **kwargs): # noqa: E501,D401,D403 local_var_params = locals() all_params = ['limit', 'offset'] # noqa: E501 - all_params.append('async_req') - all_params.append('_return_http_data_only') - all_params.append('_preload_content') - all_params.append('_request_timeout') - all_params.append('urlopen_kw') - - for key, val in six.iteritems(local_var_params['kwargs']): - if key not in all_params: - raise TypeError( - "Got an unexpected keyword argument '%s'" - " to method get_scripts" % key - ) - local_var_params[key] = val - del local_var_params['kwargs'] - - collection_formats = {} + self._check_operation_params('get_scripts', all_params, local_var_params) path_params = {} @@ -201,38 +250,12 @@ def get_scripts_with_http_info(self, **kwargs): # noqa: E501,D401,D403 header_params = {} - form_params = [] - local_var_files = {} - body_params = None # HTTP header `Accept` header_params['Accept'] = self.api_client.select_header_accept( ['application/json']) # noqa: E501 - # Authentication setting - auth_settings = [] # noqa: E501 - - # urlopen optional setting - urlopen_kw = None - if 'urlopen_kw' in kwargs: - urlopen_kw = kwargs['urlopen_kw'] - - return self.api_client.call_api( - '/api/v2/scripts', 'GET', - path_params, - query_params, - header_params, - body=body_params, - post_params=form_params, - files=local_var_files, - response_type='Scripts', # noqa: E501 - auth_settings=auth_settings, - async_req=local_var_params.get('async_req'), - _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 - _preload_content=local_var_params.get('_preload_content', True), - _request_timeout=local_var_params.get('_request_timeout'), - collection_formats=collection_formats, - urlopen_kw=urlopen_kw) + return local_var_params, path_params, query_params, header_params, body_params def get_scripts_id(self, script_id, **kwargs): # noqa: E501,D401,D403 """Retrieve a script. @@ -271,30 +294,68 @@ def get_scripts_id_with_http_info(self, script_id, **kwargs): # noqa: E501,D401 If the method is called asynchronously, returns the request thread. """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._get_scripts_id_prepare(script_id, **kwargs) + + return self.api_client.call_api( + '/api/v2/scripts/{scriptID}', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='Script', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + async def get_scripts_id_async(self, script_id, **kwargs): # noqa: E501,D401,D403 + """Retrieve a script. + + Uses script ID to retrieve details of an invocable script. + This method makes an asynchronous HTTP request. + + :param async_req bool + :param str script_id: The script ID. (required) + :return: Script + If the method is called asynchronously, + returns the request thread. + """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._get_scripts_id_prepare(script_id, **kwargs) + + return await self.api_client.call_api( + '/api/v2/scripts/{scriptID}', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='Script', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + def _get_scripts_id_prepare(self, script_id, **kwargs): # noqa: E501,D401,D403 local_var_params = locals() all_params = ['script_id'] # noqa: E501 - all_params.append('async_req') - all_params.append('_return_http_data_only') - all_params.append('_preload_content') - all_params.append('_request_timeout') - all_params.append('urlopen_kw') - - for key, val in six.iteritems(local_var_params['kwargs']): - if key not in all_params: - raise TypeError( - "Got an unexpected keyword argument '%s'" - " to method get_scripts_id" % key - ) - local_var_params[key] = val - del local_var_params['kwargs'] + self._check_operation_params('get_scripts_id', all_params, local_var_params) # verify the required parameter 'script_id' is set if ('script_id' not in local_var_params or local_var_params['script_id'] is None): raise ValueError("Missing the required parameter `script_id` when calling `get_scripts_id`") # noqa: E501 - collection_formats = {} - path_params = {} if 'script_id' in local_var_params: path_params['scriptID'] = local_var_params['script_id'] # noqa: E501 @@ -303,38 +364,12 @@ def get_scripts_id_with_http_info(self, script_id, **kwargs): # noqa: E501,D401 header_params = {} - form_params = [] - local_var_files = {} - body_params = None # HTTP header `Accept` header_params['Accept'] = self.api_client.select_header_accept( ['application/json']) # noqa: E501 - # Authentication setting - auth_settings = [] # noqa: E501 - - # urlopen optional setting - urlopen_kw = None - if 'urlopen_kw' in kwargs: - urlopen_kw = kwargs['urlopen_kw'] - - return self.api_client.call_api( - '/api/v2/scripts/{scriptID}', 'GET', - path_params, - query_params, - header_params, - body=body_params, - post_params=form_params, - files=local_var_files, - response_type='Script', # noqa: E501 - auth_settings=auth_settings, - async_req=local_var_params.get('async_req'), - _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 - _preload_content=local_var_params.get('_preload_content', True), - _request_timeout=local_var_params.get('_request_timeout'), - collection_formats=collection_formats, - urlopen_kw=urlopen_kw) + return local_var_params, path_params, query_params, header_params, body_params def patch_scripts_id(self, script_id, script_update_request, **kwargs): # noqa: E501,D401,D403 """Update a script. @@ -375,23 +410,64 @@ def patch_scripts_id_with_http_info(self, script_id, script_update_request, **kw If the method is called asynchronously, returns the request thread. """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._patch_scripts_id_prepare(script_id, script_update_request, **kwargs) + + return self.api_client.call_api( + '/api/v2/scripts/{scriptID}', 'PATCH', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='Script', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + async def patch_scripts_id_async(self, script_id, script_update_request, **kwargs): # noqa: E501,D401,D403 + """Update a script. + + Updates properties (`name`, `description`, and `script`) of an invocable script. + This method makes an asynchronous HTTP request. + + :param async_req bool + :param str script_id: The script ID. (required) + :param ScriptUpdateRequest script_update_request: Script update to apply (required) + :return: Script + If the method is called asynchronously, + returns the request thread. + """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._patch_scripts_id_prepare(script_id, script_update_request, **kwargs) + + return await self.api_client.call_api( + '/api/v2/scripts/{scriptID}', 'PATCH', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='Script', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + def _patch_scripts_id_prepare(self, script_id, script_update_request, **kwargs): # noqa: E501,D401,D403 local_var_params = locals() all_params = ['script_id', 'script_update_request'] # noqa: E501 - all_params.append('async_req') - all_params.append('_return_http_data_only') - all_params.append('_preload_content') - all_params.append('_request_timeout') - all_params.append('urlopen_kw') - - for key, val in six.iteritems(local_var_params['kwargs']): - if key not in all_params: - raise TypeError( - "Got an unexpected keyword argument '%s'" - " to method patch_scripts_id" % key - ) - local_var_params[key] = val - del local_var_params['kwargs'] + self._check_operation_params('patch_scripts_id', all_params, local_var_params) # verify the required parameter 'script_id' is set if ('script_id' not in local_var_params or local_var_params['script_id'] is None): @@ -401,8 +477,6 @@ def patch_scripts_id_with_http_info(self, script_id, script_update_request, **kw local_var_params['script_update_request'] is None): raise ValueError("Missing the required parameter `script_update_request` when calling `patch_scripts_id`") # noqa: E501 - collection_formats = {} - path_params = {} if 'script_id' in local_var_params: path_params['scriptID'] = local_var_params['script_id'] # noqa: E501 @@ -411,9 +485,6 @@ def patch_scripts_id_with_http_info(self, script_id, script_update_request, **kw header_params = {} - form_params = [] - local_var_files = {} - body_params = None if 'script_update_request' in local_var_params: body_params = local_var_params['script_update_request'] @@ -425,30 +496,7 @@ def patch_scripts_id_with_http_info(self, script_id, script_update_request, **kw header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501 ['application/json']) # noqa: E501 - # Authentication setting - auth_settings = [] # noqa: E501 - - # urlopen optional setting - urlopen_kw = None - if 'urlopen_kw' in kwargs: - urlopen_kw = kwargs['urlopen_kw'] - - return self.api_client.call_api( - '/api/v2/scripts/{scriptID}', 'PATCH', - path_params, - query_params, - header_params, - body=body_params, - post_params=form_params, - files=local_var_files, - response_type='Script', # noqa: E501 - auth_settings=auth_settings, - async_req=local_var_params.get('async_req'), - _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 - _preload_content=local_var_params.get('_preload_content', True), - _request_timeout=local_var_params.get('_request_timeout'), - collection_formats=collection_formats, - urlopen_kw=urlopen_kw) + return local_var_params, path_params, query_params, header_params, body_params def post_scripts(self, script_create_request, **kwargs): # noqa: E501,D401,D403 """Create a script. @@ -485,39 +533,73 @@ def post_scripts_with_http_info(self, script_create_request, **kwargs): # noqa: If the method is called asynchronously, returns the request thread. """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._post_scripts_prepare(script_create_request, **kwargs) + + return self.api_client.call_api( + '/api/v2/scripts', 'POST', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='Script', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + async def post_scripts_async(self, script_create_request, **kwargs): # noqa: E501,D401,D403 + """Create a script. + + This method makes an asynchronous HTTP request. + + :param async_req bool + :param ScriptCreateRequest script_create_request: The script to create. (required) + :return: Script + If the method is called asynchronously, + returns the request thread. + """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._post_scripts_prepare(script_create_request, **kwargs) + + return await self.api_client.call_api( + '/api/v2/scripts', 'POST', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='Script', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + def _post_scripts_prepare(self, script_create_request, **kwargs): # noqa: E501,D401,D403 local_var_params = locals() all_params = ['script_create_request'] # noqa: E501 - all_params.append('async_req') - all_params.append('_return_http_data_only') - all_params.append('_preload_content') - all_params.append('_request_timeout') - all_params.append('urlopen_kw') - - for key, val in six.iteritems(local_var_params['kwargs']): - if key not in all_params: - raise TypeError( - "Got an unexpected keyword argument '%s'" - " to method post_scripts" % key - ) - local_var_params[key] = val - del local_var_params['kwargs'] + self._check_operation_params('post_scripts', all_params, local_var_params) # verify the required parameter 'script_create_request' is set if ('script_create_request' not in local_var_params or local_var_params['script_create_request'] is None): raise ValueError("Missing the required parameter `script_create_request` when calling `post_scripts`") # noqa: E501 - collection_formats = {} - path_params = {} query_params = [] header_params = {} - form_params = [] - local_var_files = {} - body_params = None if 'script_create_request' in local_var_params: body_params = local_var_params['script_create_request'] @@ -529,30 +611,7 @@ def post_scripts_with_http_info(self, script_create_request, **kwargs): # noqa: header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501 ['application/json']) # noqa: E501 - # Authentication setting - auth_settings = [] # noqa: E501 - - # urlopen optional setting - urlopen_kw = None - if 'urlopen_kw' in kwargs: - urlopen_kw = kwargs['urlopen_kw'] - - return self.api_client.call_api( - '/api/v2/scripts', 'POST', - path_params, - query_params, - header_params, - body=body_params, - post_params=form_params, - files=local_var_files, - response_type='Script', # noqa: E501 - auth_settings=auth_settings, - async_req=local_var_params.get('async_req'), - _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 - _preload_content=local_var_params.get('_preload_content', True), - _request_timeout=local_var_params.get('_request_timeout'), - collection_formats=collection_formats, - urlopen_kw=urlopen_kw) + return local_var_params, path_params, query_params, header_params, body_params def post_scripts_id_invoke(self, script_id, **kwargs): # noqa: E501,D401,D403 """Invoke a script. @@ -593,30 +652,69 @@ def post_scripts_id_invoke_with_http_info(self, script_id, **kwargs): # noqa: E If the method is called asynchronously, returns the request thread. """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._post_scripts_id_invoke_prepare(script_id, **kwargs) + + return self.api_client.call_api( + '/api/v2/scripts/{scriptID}/invoke', 'POST', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='str', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + async def post_scripts_id_invoke_async(self, script_id, **kwargs): # noqa: E501,D401,D403 + """Invoke a script. + + Invokes a script and substitutes `params` keys referenced in the script with `params` key-values sent in the request body. + This method makes an asynchronous HTTP request. + + :param async_req bool + :param str script_id: (required) + :param ScriptInvocationParams script_invocation_params: + :return: str + If the method is called asynchronously, + returns the request thread. + """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._post_scripts_id_invoke_prepare(script_id, **kwargs) + + return await self.api_client.call_api( + '/api/v2/scripts/{scriptID}/invoke', 'POST', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='str', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + def _post_scripts_id_invoke_prepare(self, script_id, **kwargs): # noqa: E501,D401,D403 local_var_params = locals() all_params = ['script_id', 'script_invocation_params'] # noqa: E501 - all_params.append('async_req') - all_params.append('_return_http_data_only') - all_params.append('_preload_content') - all_params.append('_request_timeout') - all_params.append('urlopen_kw') - - for key, val in six.iteritems(local_var_params['kwargs']): - if key not in all_params: - raise TypeError( - "Got an unexpected keyword argument '%s'" - " to method post_scripts_id_invoke" % key - ) - local_var_params[key] = val - del local_var_params['kwargs'] + self._check_operation_params('post_scripts_id_invoke', all_params, local_var_params) # verify the required parameter 'script_id' is set if ('script_id' not in local_var_params or local_var_params['script_id'] is None): raise ValueError("Missing the required parameter `script_id` when calling `post_scripts_id_invoke`") # noqa: E501 - collection_formats = {} - path_params = {} if 'script_id' in local_var_params: path_params['scriptID'] = local_var_params['script_id'] # noqa: E501 @@ -625,9 +723,6 @@ def post_scripts_id_invoke_with_http_info(self, script_id, **kwargs): # noqa: E header_params = {} - form_params = [] - local_var_files = {} - body_params = None if 'script_invocation_params' in local_var_params: body_params = local_var_params['script_invocation_params'] @@ -639,27 +734,4 @@ def post_scripts_id_invoke_with_http_info(self, script_id, **kwargs): # noqa: E header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501 ['application/json']) # noqa: E501 - # Authentication setting - auth_settings = [] # noqa: E501 - - # urlopen optional setting - urlopen_kw = None - if 'urlopen_kw' in kwargs: - urlopen_kw = kwargs['urlopen_kw'] - - return self.api_client.call_api( - '/api/v2/scripts/{scriptID}/invoke', 'POST', - path_params, - query_params, - header_params, - body=body_params, - post_params=form_params, - files=local_var_files, - response_type='str', # noqa: E501 - auth_settings=auth_settings, - async_req=local_var_params.get('async_req'), - _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 - _preload_content=local_var_params.get('_preload_content', True), - _request_timeout=local_var_params.get('_request_timeout'), - collection_formats=collection_formats, - urlopen_kw=urlopen_kw) + return local_var_params, path_params, query_params, header_params, body_params diff --git a/influxdb_client/service/labels_service.py b/influxdb_client/service/labels_service.py index c3bb3989..e10110a1 100644 --- a/influxdb_client/service/labels_service.py +++ b/influxdb_client/service/labels_service.py @@ -14,11 +14,10 @@ import re # noqa: F401 -# python 2 and python 3 compatibility library -import six +from influxdb_client.service._base_service import _BaseService -class LabelsService(object): +class LabelsService(_BaseService): """NOTE: This class is auto generated by OpenAPI Generator. Ref: https://openapi-generator.tech @@ -69,30 +68,68 @@ def delete_labels_id_with_http_info(self, label_id, **kwargs): # noqa: E501,D40 If the method is called asynchronously, returns the request thread. """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._delete_labels_id_prepare(label_id, **kwargs) + + return self.api_client.call_api( + '/api/v2/labels/{labelID}', 'DELETE', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type=None, # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + async def delete_labels_id_async(self, label_id, **kwargs): # noqa: E501,D401,D403 + """Delete a label. + + This method makes an asynchronous HTTP request. + + :param async_req bool + :param str label_id: The ID of the label to delete. (required) + :param str zap_trace_span: OpenTracing span context + :return: None + If the method is called asynchronously, + returns the request thread. + """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._delete_labels_id_prepare(label_id, **kwargs) + + return await self.api_client.call_api( + '/api/v2/labels/{labelID}', 'DELETE', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type=None, # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + def _delete_labels_id_prepare(self, label_id, **kwargs): # noqa: E501,D401,D403 local_var_params = locals() all_params = ['label_id', 'zap_trace_span'] # noqa: E501 - all_params.append('async_req') - all_params.append('_return_http_data_only') - all_params.append('_preload_content') - all_params.append('_request_timeout') - all_params.append('urlopen_kw') - - for key, val in six.iteritems(local_var_params['kwargs']): - if key not in all_params: - raise TypeError( - "Got an unexpected keyword argument '%s'" - " to method delete_labels_id" % key - ) - local_var_params[key] = val - del local_var_params['kwargs'] + self._check_operation_params('delete_labels_id', all_params, local_var_params) # verify the required parameter 'label_id' is set if ('label_id' not in local_var_params or local_var_params['label_id'] is None): raise ValueError("Missing the required parameter `label_id` when calling `delete_labels_id`") # noqa: E501 - collection_formats = {} - path_params = {} if 'label_id' in local_var_params: path_params['labelID'] = local_var_params['label_id'] # noqa: E501 @@ -103,38 +140,12 @@ def delete_labels_id_with_http_info(self, label_id, **kwargs): # noqa: E501,D40 if 'zap_trace_span' in local_var_params: header_params['Zap-Trace-Span'] = local_var_params['zap_trace_span'] # noqa: E501 - form_params = [] - local_var_files = {} - body_params = None # HTTP header `Accept` header_params['Accept'] = self.api_client.select_header_accept( ['application/json']) # noqa: E501 - # Authentication setting - auth_settings = [] # noqa: E501 - - # urlopen optional setting - urlopen_kw = None - if 'urlopen_kw' in kwargs: - urlopen_kw = kwargs['urlopen_kw'] - - return self.api_client.call_api( - '/api/v2/labels/{labelID}', 'DELETE', - path_params, - query_params, - header_params, - body=body_params, - post_params=form_params, - files=local_var_files, - response_type=None, # noqa: E501 - auth_settings=auth_settings, - async_req=local_var_params.get('async_req'), - _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 - _preload_content=local_var_params.get('_preload_content', True), - _request_timeout=local_var_params.get('_request_timeout'), - collection_formats=collection_formats, - urlopen_kw=urlopen_kw) + return local_var_params, path_params, query_params, header_params, body_params def get_labels(self, **kwargs): # noqa: E501,D401,D403 """List all labels. @@ -173,25 +184,63 @@ def get_labels_with_http_info(self, **kwargs): # noqa: E501,D401,D403 If the method is called asynchronously, returns the request thread. """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._get_labels_prepare(**kwargs) + + return self.api_client.call_api( + '/api/v2/labels', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='LabelsResponse', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + async def get_labels_async(self, **kwargs): # noqa: E501,D401,D403 + """List all labels. + + This method makes an asynchronous HTTP request. + + :param async_req bool + :param str zap_trace_span: OpenTracing span context + :param str org_id: The organization ID. + :return: LabelsResponse + If the method is called asynchronously, + returns the request thread. + """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._get_labels_prepare(**kwargs) + + return await self.api_client.call_api( + '/api/v2/labels', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='LabelsResponse', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + def _get_labels_prepare(self, **kwargs): # noqa: E501,D401,D403 local_var_params = locals() all_params = ['zap_trace_span', 'org_id'] # noqa: E501 - all_params.append('async_req') - all_params.append('_return_http_data_only') - all_params.append('_preload_content') - all_params.append('_request_timeout') - all_params.append('urlopen_kw') - - for key, val in six.iteritems(local_var_params['kwargs']): - if key not in all_params: - raise TypeError( - "Got an unexpected keyword argument '%s'" - " to method get_labels" % key - ) - local_var_params[key] = val - del local_var_params['kwargs'] - - collection_formats = {} + self._check_operation_params('get_labels', all_params, local_var_params) path_params = {} @@ -203,38 +252,12 @@ def get_labels_with_http_info(self, **kwargs): # noqa: E501,D401,D403 if 'zap_trace_span' in local_var_params: header_params['Zap-Trace-Span'] = local_var_params['zap_trace_span'] # noqa: E501 - form_params = [] - local_var_files = {} - body_params = None # HTTP header `Accept` header_params['Accept'] = self.api_client.select_header_accept( ['application/json']) # noqa: E501 - # Authentication setting - auth_settings = [] # noqa: E501 - - # urlopen optional setting - urlopen_kw = None - if 'urlopen_kw' in kwargs: - urlopen_kw = kwargs['urlopen_kw'] - - return self.api_client.call_api( - '/api/v2/labels', 'GET', - path_params, - query_params, - header_params, - body=body_params, - post_params=form_params, - files=local_var_files, - response_type='LabelsResponse', # noqa: E501 - auth_settings=auth_settings, - async_req=local_var_params.get('async_req'), - _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 - _preload_content=local_var_params.get('_preload_content', True), - _request_timeout=local_var_params.get('_request_timeout'), - collection_formats=collection_formats, - urlopen_kw=urlopen_kw) + return local_var_params, path_params, query_params, header_params, body_params def get_labels_id(self, label_id, **kwargs): # noqa: E501,D401,D403 """Retrieve a label. @@ -273,30 +296,68 @@ def get_labels_id_with_http_info(self, label_id, **kwargs): # noqa: E501,D401,D If the method is called asynchronously, returns the request thread. """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._get_labels_id_prepare(label_id, **kwargs) + + return self.api_client.call_api( + '/api/v2/labels/{labelID}', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='LabelResponse', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + async def get_labels_id_async(self, label_id, **kwargs): # noqa: E501,D401,D403 + """Retrieve a label. + + This method makes an asynchronous HTTP request. + + :param async_req bool + :param str label_id: The ID of the label to update. (required) + :param str zap_trace_span: OpenTracing span context + :return: LabelResponse + If the method is called asynchronously, + returns the request thread. + """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._get_labels_id_prepare(label_id, **kwargs) + + return await self.api_client.call_api( + '/api/v2/labels/{labelID}', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='LabelResponse', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + def _get_labels_id_prepare(self, label_id, **kwargs): # noqa: E501,D401,D403 local_var_params = locals() all_params = ['label_id', 'zap_trace_span'] # noqa: E501 - all_params.append('async_req') - all_params.append('_return_http_data_only') - all_params.append('_preload_content') - all_params.append('_request_timeout') - all_params.append('urlopen_kw') - - for key, val in six.iteritems(local_var_params['kwargs']): - if key not in all_params: - raise TypeError( - "Got an unexpected keyword argument '%s'" - " to method get_labels_id" % key - ) - local_var_params[key] = val - del local_var_params['kwargs'] + self._check_operation_params('get_labels_id', all_params, local_var_params) # verify the required parameter 'label_id' is set if ('label_id' not in local_var_params or local_var_params['label_id'] is None): raise ValueError("Missing the required parameter `label_id` when calling `get_labels_id`") # noqa: E501 - collection_formats = {} - path_params = {} if 'label_id' in local_var_params: path_params['labelID'] = local_var_params['label_id'] # noqa: E501 @@ -307,38 +368,12 @@ def get_labels_id_with_http_info(self, label_id, **kwargs): # noqa: E501,D401,D if 'zap_trace_span' in local_var_params: header_params['Zap-Trace-Span'] = local_var_params['zap_trace_span'] # noqa: E501 - form_params = [] - local_var_files = {} - body_params = None # HTTP header `Accept` header_params['Accept'] = self.api_client.select_header_accept( ['application/json']) # noqa: E501 - # Authentication setting - auth_settings = [] # noqa: E501 - - # urlopen optional setting - urlopen_kw = None - if 'urlopen_kw' in kwargs: - urlopen_kw = kwargs['urlopen_kw'] - - return self.api_client.call_api( - '/api/v2/labels/{labelID}', 'GET', - path_params, - query_params, - header_params, - body=body_params, - post_params=form_params, - files=local_var_files, - response_type='LabelResponse', # noqa: E501 - auth_settings=auth_settings, - async_req=local_var_params.get('async_req'), - _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 - _preload_content=local_var_params.get('_preload_content', True), - _request_timeout=local_var_params.get('_request_timeout'), - collection_formats=collection_formats, - urlopen_kw=urlopen_kw) + return local_var_params, path_params, query_params, header_params, body_params def patch_labels_id(self, label_id, label_update, **kwargs): # noqa: E501,D401,D403 """Update a label. @@ -379,23 +414,64 @@ def patch_labels_id_with_http_info(self, label_id, label_update, **kwargs): # n If the method is called asynchronously, returns the request thread. """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._patch_labels_id_prepare(label_id, label_update, **kwargs) + + return self.api_client.call_api( + '/api/v2/labels/{labelID}', 'PATCH', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='LabelResponse', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + async def patch_labels_id_async(self, label_id, label_update, **kwargs): # noqa: E501,D401,D403 + """Update a label. + + This method makes an asynchronous HTTP request. + + :param async_req bool + :param str label_id: The ID of the label to update. (required) + :param LabelUpdate label_update: Label update (required) + :param str zap_trace_span: OpenTracing span context + :return: LabelResponse + If the method is called asynchronously, + returns the request thread. + """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._patch_labels_id_prepare(label_id, label_update, **kwargs) + + return await self.api_client.call_api( + '/api/v2/labels/{labelID}', 'PATCH', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='LabelResponse', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + def _patch_labels_id_prepare(self, label_id, label_update, **kwargs): # noqa: E501,D401,D403 local_var_params = locals() all_params = ['label_id', 'label_update', 'zap_trace_span'] # noqa: E501 - all_params.append('async_req') - all_params.append('_return_http_data_only') - all_params.append('_preload_content') - all_params.append('_request_timeout') - all_params.append('urlopen_kw') - - for key, val in six.iteritems(local_var_params['kwargs']): - if key not in all_params: - raise TypeError( - "Got an unexpected keyword argument '%s'" - " to method patch_labels_id" % key - ) - local_var_params[key] = val - del local_var_params['kwargs'] + self._check_operation_params('patch_labels_id', all_params, local_var_params) # verify the required parameter 'label_id' is set if ('label_id' not in local_var_params or local_var_params['label_id'] is None): @@ -405,8 +481,6 @@ def patch_labels_id_with_http_info(self, label_id, label_update, **kwargs): # n local_var_params['label_update'] is None): raise ValueError("Missing the required parameter `label_update` when calling `patch_labels_id`") # noqa: E501 - collection_formats = {} - path_params = {} if 'label_id' in local_var_params: path_params['labelID'] = local_var_params['label_id'] # noqa: E501 @@ -417,9 +491,6 @@ def patch_labels_id_with_http_info(self, label_id, label_update, **kwargs): # n if 'zap_trace_span' in local_var_params: header_params['Zap-Trace-Span'] = local_var_params['zap_trace_span'] # noqa: E501 - form_params = [] - local_var_files = {} - body_params = None if 'label_update' in local_var_params: body_params = local_var_params['label_update'] @@ -431,30 +502,7 @@ def patch_labels_id_with_http_info(self, label_id, label_update, **kwargs): # n header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501 ['application/json']) # noqa: E501 - # Authentication setting - auth_settings = [] # noqa: E501 - - # urlopen optional setting - urlopen_kw = None - if 'urlopen_kw' in kwargs: - urlopen_kw = kwargs['urlopen_kw'] - - return self.api_client.call_api( - '/api/v2/labels/{labelID}', 'PATCH', - path_params, - query_params, - header_params, - body=body_params, - post_params=form_params, - files=local_var_files, - response_type='LabelResponse', # noqa: E501 - auth_settings=auth_settings, - async_req=local_var_params.get('async_req'), - _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 - _preload_content=local_var_params.get('_preload_content', True), - _request_timeout=local_var_params.get('_request_timeout'), - collection_formats=collection_formats, - urlopen_kw=urlopen_kw) + return local_var_params, path_params, query_params, header_params, body_params def post_labels(self, label_create_request, **kwargs): # noqa: E501,D401,D403 """Create a label. @@ -491,39 +539,73 @@ def post_labels_with_http_info(self, label_create_request, **kwargs): # noqa: E If the method is called asynchronously, returns the request thread. """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._post_labels_prepare(label_create_request, **kwargs) + + return self.api_client.call_api( + '/api/v2/labels', 'POST', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='LabelResponse', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + async def post_labels_async(self, label_create_request, **kwargs): # noqa: E501,D401,D403 + """Create a label. + + This method makes an asynchronous HTTP request. + + :param async_req bool + :param LabelCreateRequest label_create_request: Label to create (required) + :return: LabelResponse + If the method is called asynchronously, + returns the request thread. + """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._post_labels_prepare(label_create_request, **kwargs) + + return await self.api_client.call_api( + '/api/v2/labels', 'POST', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='LabelResponse', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + def _post_labels_prepare(self, label_create_request, **kwargs): # noqa: E501,D401,D403 local_var_params = locals() all_params = ['label_create_request'] # noqa: E501 - all_params.append('async_req') - all_params.append('_return_http_data_only') - all_params.append('_preload_content') - all_params.append('_request_timeout') - all_params.append('urlopen_kw') - - for key, val in six.iteritems(local_var_params['kwargs']): - if key not in all_params: - raise TypeError( - "Got an unexpected keyword argument '%s'" - " to method post_labels" % key - ) - local_var_params[key] = val - del local_var_params['kwargs'] + self._check_operation_params('post_labels', all_params, local_var_params) # verify the required parameter 'label_create_request' is set if ('label_create_request' not in local_var_params or local_var_params['label_create_request'] is None): raise ValueError("Missing the required parameter `label_create_request` when calling `post_labels`") # noqa: E501 - collection_formats = {} - path_params = {} query_params = [] header_params = {} - form_params = [] - local_var_files = {} - body_params = None if 'label_create_request' in local_var_params: body_params = local_var_params['label_create_request'] @@ -535,27 +617,4 @@ def post_labels_with_http_info(self, label_create_request, **kwargs): # noqa: E header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501 ['application/json']) # noqa: E501 - # Authentication setting - auth_settings = [] # noqa: E501 - - # urlopen optional setting - urlopen_kw = None - if 'urlopen_kw' in kwargs: - urlopen_kw = kwargs['urlopen_kw'] - - return self.api_client.call_api( - '/api/v2/labels', 'POST', - path_params, - query_params, - header_params, - body=body_params, - post_params=form_params, - files=local_var_files, - response_type='LabelResponse', # noqa: E501 - auth_settings=auth_settings, - async_req=local_var_params.get('async_req'), - _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 - _preload_content=local_var_params.get('_preload_content', True), - _request_timeout=local_var_params.get('_request_timeout'), - collection_formats=collection_formats, - urlopen_kw=urlopen_kw) + return local_var_params, path_params, query_params, header_params, body_params diff --git a/influxdb_client/service/legacy_authorizations_service.py b/influxdb_client/service/legacy_authorizations_service.py index 80289420..d7436ef9 100644 --- a/influxdb_client/service/legacy_authorizations_service.py +++ b/influxdb_client/service/legacy_authorizations_service.py @@ -14,11 +14,10 @@ import re # noqa: F401 -# python 2 and python 3 compatibility library -import six +from influxdb_client.service._base_service import _BaseService -class LegacyAuthorizationsService(object): +class LegacyAuthorizationsService(_BaseService): """NOTE: This class is auto generated by OpenAPI Generator. Ref: https://openapi-generator.tech @@ -69,30 +68,68 @@ def delete_legacy_authorizations_id_with_http_info(self, auth_id, **kwargs): # If the method is called asynchronously, returns the request thread. """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._delete_legacy_authorizations_id_prepare(auth_id, **kwargs) + + return self.api_client.call_api( + '/private/legacy/authorizations/{authID}', 'DELETE', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type=None, # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + async def delete_legacy_authorizations_id_async(self, auth_id, **kwargs): # noqa: E501,D401,D403 + """Delete a legacy authorization. + + This method makes an asynchronous HTTP request. + + :param async_req bool + :param str auth_id: The ID of the legacy authorization to delete. (required) + :param str zap_trace_span: OpenTracing span context + :return: None + If the method is called asynchronously, + returns the request thread. + """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._delete_legacy_authorizations_id_prepare(auth_id, **kwargs) + + return await self.api_client.call_api( + '/private/legacy/authorizations/{authID}', 'DELETE', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type=None, # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + def _delete_legacy_authorizations_id_prepare(self, auth_id, **kwargs): # noqa: E501,D401,D403 local_var_params = locals() all_params = ['auth_id', 'zap_trace_span'] # noqa: E501 - all_params.append('async_req') - all_params.append('_return_http_data_only') - all_params.append('_preload_content') - all_params.append('_request_timeout') - all_params.append('urlopen_kw') - - for key, val in six.iteritems(local_var_params['kwargs']): - if key not in all_params: - raise TypeError( - "Got an unexpected keyword argument '%s'" - " to method delete_legacy_authorizations_id" % key - ) - local_var_params[key] = val - del local_var_params['kwargs'] + self._check_operation_params('delete_legacy_authorizations_id', all_params, local_var_params) # verify the required parameter 'auth_id' is set if ('auth_id' not in local_var_params or local_var_params['auth_id'] is None): raise ValueError("Missing the required parameter `auth_id` when calling `delete_legacy_authorizations_id`") # noqa: E501 - collection_formats = {} - path_params = {} if 'auth_id' in local_var_params: path_params['authID'] = local_var_params['auth_id'] # noqa: E501 @@ -103,38 +140,12 @@ def delete_legacy_authorizations_id_with_http_info(self, auth_id, **kwargs): # if 'zap_trace_span' in local_var_params: header_params['Zap-Trace-Span'] = local_var_params['zap_trace_span'] # noqa: E501 - form_params = [] - local_var_files = {} - body_params = None # HTTP header `Accept` header_params['Accept'] = self.api_client.select_header_accept( ['application/json']) # noqa: E501 - # Authentication setting - auth_settings = [] # noqa: E501 - - # urlopen optional setting - urlopen_kw = None - if 'urlopen_kw' in kwargs: - urlopen_kw = kwargs['urlopen_kw'] - - return self.api_client.call_api( - '/private/legacy/authorizations/{authID}', 'DELETE', - path_params, - query_params, - header_params, - body=body_params, - post_params=form_params, - files=local_var_files, - response_type=None, # noqa: E501 - auth_settings=auth_settings, - async_req=local_var_params.get('async_req'), - _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 - _preload_content=local_var_params.get('_preload_content', True), - _request_timeout=local_var_params.get('_request_timeout'), - collection_formats=collection_formats, - urlopen_kw=urlopen_kw) + return local_var_params, path_params, query_params, header_params, body_params def get_legacy_authorizations(self, **kwargs): # noqa: E501,D401,D403 """List all legacy authorizations. @@ -183,25 +194,68 @@ def get_legacy_authorizations_with_http_info(self, **kwargs): # noqa: E501,D401 If the method is called asynchronously, returns the request thread. """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._get_legacy_authorizations_prepare(**kwargs) + + return self.api_client.call_api( + '/private/legacy/authorizations', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='Authorizations', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + async def get_legacy_authorizations_async(self, **kwargs): # noqa: E501,D401,D403 + """List all legacy authorizations. + + This method makes an asynchronous HTTP request. + + :param async_req bool + :param str zap_trace_span: OpenTracing span context + :param str user_id: Only show legacy authorizations that belong to a user ID. + :param str user: Only show legacy authorizations that belong to a user name. + :param str org_id: Only show legacy authorizations that belong to an organization ID. + :param str org: Only show legacy authorizations that belong to a organization name. + :param str token: Only show legacy authorizations with a specified token (auth name). + :param str auth_id: Only show legacy authorizations with a specified auth ID. + :return: Authorizations + If the method is called asynchronously, + returns the request thread. + """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._get_legacy_authorizations_prepare(**kwargs) + + return await self.api_client.call_api( + '/private/legacy/authorizations', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='Authorizations', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + def _get_legacy_authorizations_prepare(self, **kwargs): # noqa: E501,D401,D403 local_var_params = locals() all_params = ['zap_trace_span', 'user_id', 'user', 'org_id', 'org', 'token', 'auth_id'] # noqa: E501 - all_params.append('async_req') - all_params.append('_return_http_data_only') - all_params.append('_preload_content') - all_params.append('_request_timeout') - all_params.append('urlopen_kw') - - for key, val in six.iteritems(local_var_params['kwargs']): - if key not in all_params: - raise TypeError( - "Got an unexpected keyword argument '%s'" - " to method get_legacy_authorizations" % key - ) - local_var_params[key] = val - del local_var_params['kwargs'] - - collection_formats = {} + self._check_operation_params('get_legacy_authorizations', all_params, local_var_params) path_params = {} @@ -223,38 +277,12 @@ def get_legacy_authorizations_with_http_info(self, **kwargs): # noqa: E501,D401 if 'zap_trace_span' in local_var_params: header_params['Zap-Trace-Span'] = local_var_params['zap_trace_span'] # noqa: E501 - form_params = [] - local_var_files = {} - body_params = None # HTTP header `Accept` header_params['Accept'] = self.api_client.select_header_accept( ['application/json']) # noqa: E501 - # Authentication setting - auth_settings = [] # noqa: E501 - - # urlopen optional setting - urlopen_kw = None - if 'urlopen_kw' in kwargs: - urlopen_kw = kwargs['urlopen_kw'] - - return self.api_client.call_api( - '/private/legacy/authorizations', 'GET', - path_params, - query_params, - header_params, - body=body_params, - post_params=form_params, - files=local_var_files, - response_type='Authorizations', # noqa: E501 - auth_settings=auth_settings, - async_req=local_var_params.get('async_req'), - _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 - _preload_content=local_var_params.get('_preload_content', True), - _request_timeout=local_var_params.get('_request_timeout'), - collection_formats=collection_formats, - urlopen_kw=urlopen_kw) + return local_var_params, path_params, query_params, header_params, body_params def get_legacy_authorizations_id(self, auth_id, **kwargs): # noqa: E501,D401,D403 """Retrieve a legacy authorization. @@ -293,30 +321,68 @@ def get_legacy_authorizations_id_with_http_info(self, auth_id, **kwargs): # noq If the method is called asynchronously, returns the request thread. """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._get_legacy_authorizations_id_prepare(auth_id, **kwargs) + + return self.api_client.call_api( + '/private/legacy/authorizations/{authID}', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='Authorization', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + async def get_legacy_authorizations_id_async(self, auth_id, **kwargs): # noqa: E501,D401,D403 + """Retrieve a legacy authorization. + + This method makes an asynchronous HTTP request. + + :param async_req bool + :param str auth_id: The ID of the legacy authorization to get. (required) + :param str zap_trace_span: OpenTracing span context + :return: Authorization + If the method is called asynchronously, + returns the request thread. + """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._get_legacy_authorizations_id_prepare(auth_id, **kwargs) + + return await self.api_client.call_api( + '/private/legacy/authorizations/{authID}', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='Authorization', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + def _get_legacy_authorizations_id_prepare(self, auth_id, **kwargs): # noqa: E501,D401,D403 local_var_params = locals() all_params = ['auth_id', 'zap_trace_span'] # noqa: E501 - all_params.append('async_req') - all_params.append('_return_http_data_only') - all_params.append('_preload_content') - all_params.append('_request_timeout') - all_params.append('urlopen_kw') - - for key, val in six.iteritems(local_var_params['kwargs']): - if key not in all_params: - raise TypeError( - "Got an unexpected keyword argument '%s'" - " to method get_legacy_authorizations_id" % key - ) - local_var_params[key] = val - del local_var_params['kwargs'] + self._check_operation_params('get_legacy_authorizations_id', all_params, local_var_params) # verify the required parameter 'auth_id' is set if ('auth_id' not in local_var_params or local_var_params['auth_id'] is None): raise ValueError("Missing the required parameter `auth_id` when calling `get_legacy_authorizations_id`") # noqa: E501 - collection_formats = {} - path_params = {} if 'auth_id' in local_var_params: path_params['authID'] = local_var_params['auth_id'] # noqa: E501 @@ -327,38 +393,12 @@ def get_legacy_authorizations_id_with_http_info(self, auth_id, **kwargs): # noq if 'zap_trace_span' in local_var_params: header_params['Zap-Trace-Span'] = local_var_params['zap_trace_span'] # noqa: E501 - form_params = [] - local_var_files = {} - body_params = None # HTTP header `Accept` header_params['Accept'] = self.api_client.select_header_accept( ['application/json']) # noqa: E501 - # Authentication setting - auth_settings = [] # noqa: E501 - - # urlopen optional setting - urlopen_kw = None - if 'urlopen_kw' in kwargs: - urlopen_kw = kwargs['urlopen_kw'] - - return self.api_client.call_api( - '/private/legacy/authorizations/{authID}', 'GET', - path_params, - query_params, - header_params, - body=body_params, - post_params=form_params, - files=local_var_files, - response_type='Authorization', # noqa: E501 - auth_settings=auth_settings, - async_req=local_var_params.get('async_req'), - _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 - _preload_content=local_var_params.get('_preload_content', True), - _request_timeout=local_var_params.get('_request_timeout'), - collection_formats=collection_formats, - urlopen_kw=urlopen_kw) + return local_var_params, path_params, query_params, header_params, body_params def patch_legacy_authorizations_id(self, auth_id, authorization_update_request, **kwargs): # noqa: E501,D401,D403 """Update a legacy authorization to be active or inactive. @@ -399,23 +439,64 @@ def patch_legacy_authorizations_id_with_http_info(self, auth_id, authorization_u If the method is called asynchronously, returns the request thread. """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._patch_legacy_authorizations_id_prepare(auth_id, authorization_update_request, **kwargs) + + return self.api_client.call_api( + '/private/legacy/authorizations/{authID}', 'PATCH', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='Authorization', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + async def patch_legacy_authorizations_id_async(self, auth_id, authorization_update_request, **kwargs): # noqa: E501,D401,D403 + """Update a legacy authorization to be active or inactive. + + This method makes an asynchronous HTTP request. + + :param async_req bool + :param str auth_id: The ID of the legacy authorization to update. (required) + :param AuthorizationUpdateRequest authorization_update_request: Legacy authorization to update (required) + :param str zap_trace_span: OpenTracing span context + :return: Authorization + If the method is called asynchronously, + returns the request thread. + """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._patch_legacy_authorizations_id_prepare(auth_id, authorization_update_request, **kwargs) + + return await self.api_client.call_api( + '/private/legacy/authorizations/{authID}', 'PATCH', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='Authorization', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + def _patch_legacy_authorizations_id_prepare(self, auth_id, authorization_update_request, **kwargs): # noqa: E501,D401,D403 local_var_params = locals() all_params = ['auth_id', 'authorization_update_request', 'zap_trace_span'] # noqa: E501 - all_params.append('async_req') - all_params.append('_return_http_data_only') - all_params.append('_preload_content') - all_params.append('_request_timeout') - all_params.append('urlopen_kw') - - for key, val in six.iteritems(local_var_params['kwargs']): - if key not in all_params: - raise TypeError( - "Got an unexpected keyword argument '%s'" - " to method patch_legacy_authorizations_id" % key - ) - local_var_params[key] = val - del local_var_params['kwargs'] + self._check_operation_params('patch_legacy_authorizations_id', all_params, local_var_params) # verify the required parameter 'auth_id' is set if ('auth_id' not in local_var_params or local_var_params['auth_id'] is None): @@ -425,8 +506,6 @@ def patch_legacy_authorizations_id_with_http_info(self, auth_id, authorization_u local_var_params['authorization_update_request'] is None): raise ValueError("Missing the required parameter `authorization_update_request` when calling `patch_legacy_authorizations_id`") # noqa: E501 - collection_formats = {} - path_params = {} if 'auth_id' in local_var_params: path_params['authID'] = local_var_params['auth_id'] # noqa: E501 @@ -437,9 +516,6 @@ def patch_legacy_authorizations_id_with_http_info(self, auth_id, authorization_u if 'zap_trace_span' in local_var_params: header_params['Zap-Trace-Span'] = local_var_params['zap_trace_span'] # noqa: E501 - form_params = [] - local_var_files = {} - body_params = None if 'authorization_update_request' in local_var_params: body_params = local_var_params['authorization_update_request'] @@ -451,30 +527,7 @@ def patch_legacy_authorizations_id_with_http_info(self, auth_id, authorization_u header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501 ['application/json']) # noqa: E501 - # Authentication setting - auth_settings = [] # noqa: E501 - - # urlopen optional setting - urlopen_kw = None - if 'urlopen_kw' in kwargs: - urlopen_kw = kwargs['urlopen_kw'] - - return self.api_client.call_api( - '/private/legacy/authorizations/{authID}', 'PATCH', - path_params, - query_params, - header_params, - body=body_params, - post_params=form_params, - files=local_var_files, - response_type='Authorization', # noqa: E501 - auth_settings=auth_settings, - async_req=local_var_params.get('async_req'), - _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 - _preload_content=local_var_params.get('_preload_content', True), - _request_timeout=local_var_params.get('_request_timeout'), - collection_formats=collection_formats, - urlopen_kw=urlopen_kw) + return local_var_params, path_params, query_params, header_params, body_params def post_legacy_authorizations(self, legacy_authorization_post_request, **kwargs): # noqa: E501,D401,D403 """Create a legacy authorization. @@ -513,30 +566,68 @@ def post_legacy_authorizations_with_http_info(self, legacy_authorization_post_re If the method is called asynchronously, returns the request thread. """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._post_legacy_authorizations_prepare(legacy_authorization_post_request, **kwargs) + + return self.api_client.call_api( + '/private/legacy/authorizations', 'POST', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='Authorization', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + async def post_legacy_authorizations_async(self, legacy_authorization_post_request, **kwargs): # noqa: E501,D401,D403 + """Create a legacy authorization. + + This method makes an asynchronous HTTP request. + + :param async_req bool + :param LegacyAuthorizationPostRequest legacy_authorization_post_request: Legacy authorization to create (required) + :param str zap_trace_span: OpenTracing span context + :return: Authorization + If the method is called asynchronously, + returns the request thread. + """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._post_legacy_authorizations_prepare(legacy_authorization_post_request, **kwargs) + + return await self.api_client.call_api( + '/private/legacy/authorizations', 'POST', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='Authorization', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + def _post_legacy_authorizations_prepare(self, legacy_authorization_post_request, **kwargs): # noqa: E501,D401,D403 local_var_params = locals() all_params = ['legacy_authorization_post_request', 'zap_trace_span'] # noqa: E501 - all_params.append('async_req') - all_params.append('_return_http_data_only') - all_params.append('_preload_content') - all_params.append('_request_timeout') - all_params.append('urlopen_kw') - - for key, val in six.iteritems(local_var_params['kwargs']): - if key not in all_params: - raise TypeError( - "Got an unexpected keyword argument '%s'" - " to method post_legacy_authorizations" % key - ) - local_var_params[key] = val - del local_var_params['kwargs'] + self._check_operation_params('post_legacy_authorizations', all_params, local_var_params) # verify the required parameter 'legacy_authorization_post_request' is set if ('legacy_authorization_post_request' not in local_var_params or local_var_params['legacy_authorization_post_request'] is None): raise ValueError("Missing the required parameter `legacy_authorization_post_request` when calling `post_legacy_authorizations`") # noqa: E501 - collection_formats = {} - path_params = {} query_params = [] @@ -545,9 +636,6 @@ def post_legacy_authorizations_with_http_info(self, legacy_authorization_post_re if 'zap_trace_span' in local_var_params: header_params['Zap-Trace-Span'] = local_var_params['zap_trace_span'] # noqa: E501 - form_params = [] - local_var_files = {} - body_params = None if 'legacy_authorization_post_request' in local_var_params: body_params = local_var_params['legacy_authorization_post_request'] @@ -559,30 +647,7 @@ def post_legacy_authorizations_with_http_info(self, legacy_authorization_post_re header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501 ['application/json']) # noqa: E501 - # Authentication setting - auth_settings = [] # noqa: E501 - - # urlopen optional setting - urlopen_kw = None - if 'urlopen_kw' in kwargs: - urlopen_kw = kwargs['urlopen_kw'] - - return self.api_client.call_api( - '/private/legacy/authorizations', 'POST', - path_params, - query_params, - header_params, - body=body_params, - post_params=form_params, - files=local_var_files, - response_type='Authorization', # noqa: E501 - auth_settings=auth_settings, - async_req=local_var_params.get('async_req'), - _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 - _preload_content=local_var_params.get('_preload_content', True), - _request_timeout=local_var_params.get('_request_timeout'), - collection_formats=collection_formats, - urlopen_kw=urlopen_kw) + return local_var_params, path_params, query_params, header_params, body_params def post_legacy_authorizations_id_password(self, auth_id, password_reset_body, **kwargs): # noqa: E501,D401,D403 """Set a legacy authorization password. @@ -623,23 +688,64 @@ def post_legacy_authorizations_id_password_with_http_info(self, auth_id, passwor If the method is called asynchronously, returns the request thread. """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._post_legacy_authorizations_id_password_prepare(auth_id, password_reset_body, **kwargs) + + return self.api_client.call_api( + '/private/legacy/authorizations/{authID}/password', 'POST', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type=None, # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + async def post_legacy_authorizations_id_password_async(self, auth_id, password_reset_body, **kwargs): # noqa: E501,D401,D403 + """Set a legacy authorization password. + + This method makes an asynchronous HTTP request. + + :param async_req bool + :param str auth_id: The ID of the legacy authorization to update. (required) + :param PasswordResetBody password_reset_body: New password (required) + :param str zap_trace_span: OpenTracing span context + :return: None + If the method is called asynchronously, + returns the request thread. + """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._post_legacy_authorizations_id_password_prepare(auth_id, password_reset_body, **kwargs) + + return await self.api_client.call_api( + '/private/legacy/authorizations/{authID}/password', 'POST', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type=None, # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + def _post_legacy_authorizations_id_password_prepare(self, auth_id, password_reset_body, **kwargs): # noqa: E501,D401,D403 local_var_params = locals() all_params = ['auth_id', 'password_reset_body', 'zap_trace_span'] # noqa: E501 - all_params.append('async_req') - all_params.append('_return_http_data_only') - all_params.append('_preload_content') - all_params.append('_request_timeout') - all_params.append('urlopen_kw') - - for key, val in six.iteritems(local_var_params['kwargs']): - if key not in all_params: - raise TypeError( - "Got an unexpected keyword argument '%s'" - " to method post_legacy_authorizations_id_password" % key - ) - local_var_params[key] = val - del local_var_params['kwargs'] + self._check_operation_params('post_legacy_authorizations_id_password', all_params, local_var_params) # verify the required parameter 'auth_id' is set if ('auth_id' not in local_var_params or local_var_params['auth_id'] is None): @@ -649,8 +755,6 @@ def post_legacy_authorizations_id_password_with_http_info(self, auth_id, passwor local_var_params['password_reset_body'] is None): raise ValueError("Missing the required parameter `password_reset_body` when calling `post_legacy_authorizations_id_password`") # noqa: E501 - collection_formats = {} - path_params = {} if 'auth_id' in local_var_params: path_params['authID'] = local_var_params['auth_id'] # noqa: E501 @@ -661,9 +765,6 @@ def post_legacy_authorizations_id_password_with_http_info(self, auth_id, passwor if 'zap_trace_span' in local_var_params: header_params['Zap-Trace-Span'] = local_var_params['zap_trace_span'] # noqa: E501 - form_params = [] - local_var_files = {} - body_params = None if 'password_reset_body' in local_var_params: body_params = local_var_params['password_reset_body'] @@ -675,27 +776,4 @@ def post_legacy_authorizations_id_password_with_http_info(self, auth_id, passwor header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501 ['application/json']) # noqa: E501 - # Authentication setting - auth_settings = [] # noqa: E501 - - # urlopen optional setting - urlopen_kw = None - if 'urlopen_kw' in kwargs: - urlopen_kw = kwargs['urlopen_kw'] - - return self.api_client.call_api( - '/private/legacy/authorizations/{authID}/password', 'POST', - path_params, - query_params, - header_params, - body=body_params, - post_params=form_params, - files=local_var_files, - response_type=None, # noqa: E501 - auth_settings=auth_settings, - async_req=local_var_params.get('async_req'), - _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 - _preload_content=local_var_params.get('_preload_content', True), - _request_timeout=local_var_params.get('_request_timeout'), - collection_formats=collection_formats, - urlopen_kw=urlopen_kw) + return local_var_params, path_params, query_params, header_params, body_params diff --git a/influxdb_client/service/metrics_service.py b/influxdb_client/service/metrics_service.py index 86aeaba0..77c0336c 100644 --- a/influxdb_client/service/metrics_service.py +++ b/influxdb_client/service/metrics_service.py @@ -14,11 +14,10 @@ import re # noqa: F401 -# python 2 and python 3 compatibility library -import six +from influxdb_client.service._base_service import _BaseService -class MetricsService(object): +class MetricsService(_BaseService): """NOTE: This class is auto generated by OpenAPI Generator. Ref: https://openapi-generator.tech @@ -67,25 +66,62 @@ def get_metrics_with_http_info(self, **kwargs): # noqa: E501,D401,D403 If the method is called asynchronously, returns the request thread. """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._get_metrics_prepare(**kwargs) + + return self.api_client.call_api( + '/metrics', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='str', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + async def get_metrics_async(self, **kwargs): # noqa: E501,D401,D403 + """Get metrics of an instance. + + This method makes an asynchronous HTTP request. + + :param async_req bool + :param str zap_trace_span: OpenTracing span context + :return: str + If the method is called asynchronously, + returns the request thread. + """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._get_metrics_prepare(**kwargs) + + return await self.api_client.call_api( + '/metrics', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='str', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + def _get_metrics_prepare(self, **kwargs): # noqa: E501,D401,D403 local_var_params = locals() all_params = ['zap_trace_span'] # noqa: E501 - all_params.append('async_req') - all_params.append('_return_http_data_only') - all_params.append('_preload_content') - all_params.append('_request_timeout') - all_params.append('urlopen_kw') - - for key, val in six.iteritems(local_var_params['kwargs']): - if key not in all_params: - raise TypeError( - "Got an unexpected keyword argument '%s'" - " to method get_metrics" % key - ) - local_var_params[key] = val - del local_var_params['kwargs'] - - collection_formats = {} + self._check_operation_params('get_metrics', all_params, local_var_params) path_params = {} @@ -95,35 +131,9 @@ def get_metrics_with_http_info(self, **kwargs): # noqa: E501,D401,D403 if 'zap_trace_span' in local_var_params: header_params['Zap-Trace-Span'] = local_var_params['zap_trace_span'] # noqa: E501 - form_params = [] - local_var_files = {} - body_params = None # HTTP header `Accept` header_params['Accept'] = self.api_client.select_header_accept( ['text/plain', 'application/json']) # noqa: E501 - # Authentication setting - auth_settings = [] # noqa: E501 - - # urlopen optional setting - urlopen_kw = None - if 'urlopen_kw' in kwargs: - urlopen_kw = kwargs['urlopen_kw'] - - return self.api_client.call_api( - '/metrics', 'GET', - path_params, - query_params, - header_params, - body=body_params, - post_params=form_params, - files=local_var_files, - response_type='str', # noqa: E501 - auth_settings=auth_settings, - async_req=local_var_params.get('async_req'), - _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 - _preload_content=local_var_params.get('_preload_content', True), - _request_timeout=local_var_params.get('_request_timeout'), - collection_formats=collection_formats, - urlopen_kw=urlopen_kw) + return local_var_params, path_params, query_params, header_params, body_params diff --git a/influxdb_client/service/notification_endpoints_service.py b/influxdb_client/service/notification_endpoints_service.py index c745c48d..1b13157f 100644 --- a/influxdb_client/service/notification_endpoints_service.py +++ b/influxdb_client/service/notification_endpoints_service.py @@ -14,11 +14,10 @@ import re # noqa: F401 -# python 2 and python 3 compatibility library -import six +from influxdb_client.service._base_service import _BaseService -class NotificationEndpointsService(object): +class NotificationEndpointsService(_BaseService): """NOTE: This class is auto generated by OpenAPI Generator. Ref: https://openapi-generator.tech @@ -67,39 +66,73 @@ def create_notification_endpoint_with_http_info(self, post_notification_endpoint If the method is called asynchronously, returns the request thread. """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._create_notification_endpoint_prepare(post_notification_endpoint, **kwargs) + + return self.api_client.call_api( + '/api/v2/notificationEndpoints', 'POST', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='NotificationEndpoint', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + async def create_notification_endpoint_async(self, post_notification_endpoint, **kwargs): # noqa: E501,D401,D403 + """Add a notification endpoint. + + This method makes an asynchronous HTTP request. + + :param async_req bool + :param PostNotificationEndpoint post_notification_endpoint: Notification endpoint to create (required) + :return: NotificationEndpoint + If the method is called asynchronously, + returns the request thread. + """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._create_notification_endpoint_prepare(post_notification_endpoint, **kwargs) + + return await self.api_client.call_api( + '/api/v2/notificationEndpoints', 'POST', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='NotificationEndpoint', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + def _create_notification_endpoint_prepare(self, post_notification_endpoint, **kwargs): # noqa: E501,D401,D403 local_var_params = locals() all_params = ['post_notification_endpoint'] # noqa: E501 - all_params.append('async_req') - all_params.append('_return_http_data_only') - all_params.append('_preload_content') - all_params.append('_request_timeout') - all_params.append('urlopen_kw') - - for key, val in six.iteritems(local_var_params['kwargs']): - if key not in all_params: - raise TypeError( - "Got an unexpected keyword argument '%s'" - " to method create_notification_endpoint" % key - ) - local_var_params[key] = val - del local_var_params['kwargs'] + self._check_operation_params('create_notification_endpoint', all_params, local_var_params) # verify the required parameter 'post_notification_endpoint' is set if ('post_notification_endpoint' not in local_var_params or local_var_params['post_notification_endpoint'] is None): raise ValueError("Missing the required parameter `post_notification_endpoint` when calling `create_notification_endpoint`") # noqa: E501 - collection_formats = {} - path_params = {} query_params = [] header_params = {} - form_params = [] - local_var_files = {} - body_params = None if 'post_notification_endpoint' in local_var_params: body_params = local_var_params['post_notification_endpoint'] @@ -111,30 +144,7 @@ def create_notification_endpoint_with_http_info(self, post_notification_endpoint header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501 ['application/json']) # noqa: E501 - # Authentication setting - auth_settings = [] # noqa: E501 - - # urlopen optional setting - urlopen_kw = None - if 'urlopen_kw' in kwargs: - urlopen_kw = kwargs['urlopen_kw'] - - return self.api_client.call_api( - '/api/v2/notificationEndpoints', 'POST', - path_params, - query_params, - header_params, - body=body_params, - post_params=form_params, - files=local_var_files, - response_type='NotificationEndpoint', # noqa: E501 - auth_settings=auth_settings, - async_req=local_var_params.get('async_req'), - _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 - _preload_content=local_var_params.get('_preload_content', True), - _request_timeout=local_var_params.get('_request_timeout'), - collection_formats=collection_formats, - urlopen_kw=urlopen_kw) + return local_var_params, path_params, query_params, header_params, body_params def delete_notification_endpoints_id(self, endpoint_id, **kwargs): # noqa: E501,D401,D403 """Delete a notification endpoint. @@ -173,30 +183,68 @@ def delete_notification_endpoints_id_with_http_info(self, endpoint_id, **kwargs) If the method is called asynchronously, returns the request thread. """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._delete_notification_endpoints_id_prepare(endpoint_id, **kwargs) + + return self.api_client.call_api( + '/api/v2/notificationEndpoints/{endpointID}', 'DELETE', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type=None, # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + async def delete_notification_endpoints_id_async(self, endpoint_id, **kwargs): # noqa: E501,D401,D403 + """Delete a notification endpoint. + + This method makes an asynchronous HTTP request. + + :param async_req bool + :param str endpoint_id: The notification endpoint ID. (required) + :param str zap_trace_span: OpenTracing span context + :return: None + If the method is called asynchronously, + returns the request thread. + """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._delete_notification_endpoints_id_prepare(endpoint_id, **kwargs) + + return await self.api_client.call_api( + '/api/v2/notificationEndpoints/{endpointID}', 'DELETE', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type=None, # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + def _delete_notification_endpoints_id_prepare(self, endpoint_id, **kwargs): # noqa: E501,D401,D403 local_var_params = locals() all_params = ['endpoint_id', 'zap_trace_span'] # noqa: E501 - all_params.append('async_req') - all_params.append('_return_http_data_only') - all_params.append('_preload_content') - all_params.append('_request_timeout') - all_params.append('urlopen_kw') - - for key, val in six.iteritems(local_var_params['kwargs']): - if key not in all_params: - raise TypeError( - "Got an unexpected keyword argument '%s'" - " to method delete_notification_endpoints_id" % key - ) - local_var_params[key] = val - del local_var_params['kwargs'] + self._check_operation_params('delete_notification_endpoints_id', all_params, local_var_params) # verify the required parameter 'endpoint_id' is set if ('endpoint_id' not in local_var_params or local_var_params['endpoint_id'] is None): raise ValueError("Missing the required parameter `endpoint_id` when calling `delete_notification_endpoints_id`") # noqa: E501 - collection_formats = {} - path_params = {} if 'endpoint_id' in local_var_params: path_params['endpointID'] = local_var_params['endpoint_id'] # noqa: E501 @@ -207,38 +255,12 @@ def delete_notification_endpoints_id_with_http_info(self, endpoint_id, **kwargs) if 'zap_trace_span' in local_var_params: header_params['Zap-Trace-Span'] = local_var_params['zap_trace_span'] # noqa: E501 - form_params = [] - local_var_files = {} - body_params = None # HTTP header `Accept` header_params['Accept'] = self.api_client.select_header_accept( ['application/json']) # noqa: E501 - # Authentication setting - auth_settings = [] # noqa: E501 - - # urlopen optional setting - urlopen_kw = None - if 'urlopen_kw' in kwargs: - urlopen_kw = kwargs['urlopen_kw'] - - return self.api_client.call_api( - '/api/v2/notificationEndpoints/{endpointID}', 'DELETE', - path_params, - query_params, - header_params, - body=body_params, - post_params=form_params, - files=local_var_files, - response_type=None, # noqa: E501 - auth_settings=auth_settings, - async_req=local_var_params.get('async_req'), - _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 - _preload_content=local_var_params.get('_preload_content', True), - _request_timeout=local_var_params.get('_request_timeout'), - collection_formats=collection_formats, - urlopen_kw=urlopen_kw) + return local_var_params, path_params, query_params, header_params, body_params def delete_notification_endpoints_id_labels_id(self, endpoint_id, label_id, **kwargs): # noqa: E501,D401,D403 """Delete a label from a notification endpoint. @@ -279,23 +301,64 @@ def delete_notification_endpoints_id_labels_id_with_http_info(self, endpoint_id, If the method is called asynchronously, returns the request thread. """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._delete_notification_endpoints_id_labels_id_prepare(endpoint_id, label_id, **kwargs) + + return self.api_client.call_api( + '/api/v2/notificationEndpoints/{endpointID}/labels/{labelID}', 'DELETE', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type=None, # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + async def delete_notification_endpoints_id_labels_id_async(self, endpoint_id, label_id, **kwargs): # noqa: E501,D401,D403 + """Delete a label from a notification endpoint. + + This method makes an asynchronous HTTP request. + + :param async_req bool + :param str endpoint_id: The notification endpoint ID. (required) + :param str label_id: The ID of the label to delete. (required) + :param str zap_trace_span: OpenTracing span context + :return: None + If the method is called asynchronously, + returns the request thread. + """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._delete_notification_endpoints_id_labels_id_prepare(endpoint_id, label_id, **kwargs) + + return await self.api_client.call_api( + '/api/v2/notificationEndpoints/{endpointID}/labels/{labelID}', 'DELETE', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type=None, # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + def _delete_notification_endpoints_id_labels_id_prepare(self, endpoint_id, label_id, **kwargs): # noqa: E501,D401,D403 local_var_params = locals() all_params = ['endpoint_id', 'label_id', 'zap_trace_span'] # noqa: E501 - all_params.append('async_req') - all_params.append('_return_http_data_only') - all_params.append('_preload_content') - all_params.append('_request_timeout') - all_params.append('urlopen_kw') - - for key, val in six.iteritems(local_var_params['kwargs']): - if key not in all_params: - raise TypeError( - "Got an unexpected keyword argument '%s'" - " to method delete_notification_endpoints_id_labels_id" % key - ) - local_var_params[key] = val - del local_var_params['kwargs'] + self._check_operation_params('delete_notification_endpoints_id_labels_id', all_params, local_var_params) # verify the required parameter 'endpoint_id' is set if ('endpoint_id' not in local_var_params or local_var_params['endpoint_id'] is None): @@ -305,8 +368,6 @@ def delete_notification_endpoints_id_labels_id_with_http_info(self, endpoint_id, local_var_params['label_id'] is None): raise ValueError("Missing the required parameter `label_id` when calling `delete_notification_endpoints_id_labels_id`") # noqa: E501 - collection_formats = {} - path_params = {} if 'endpoint_id' in local_var_params: path_params['endpointID'] = local_var_params['endpoint_id'] # noqa: E501 @@ -319,38 +380,12 @@ def delete_notification_endpoints_id_labels_id_with_http_info(self, endpoint_id, if 'zap_trace_span' in local_var_params: header_params['Zap-Trace-Span'] = local_var_params['zap_trace_span'] # noqa: E501 - form_params = [] - local_var_files = {} - body_params = None # HTTP header `Accept` header_params['Accept'] = self.api_client.select_header_accept( ['application/json']) # noqa: E501 - # Authentication setting - auth_settings = [] # noqa: E501 - - # urlopen optional setting - urlopen_kw = None - if 'urlopen_kw' in kwargs: - urlopen_kw = kwargs['urlopen_kw'] - - return self.api_client.call_api( - '/api/v2/notificationEndpoints/{endpointID}/labels/{labelID}', 'DELETE', - path_params, - query_params, - header_params, - body=body_params, - post_params=form_params, - files=local_var_files, - response_type=None, # noqa: E501 - auth_settings=auth_settings, - async_req=local_var_params.get('async_req'), - _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 - _preload_content=local_var_params.get('_preload_content', True), - _request_timeout=local_var_params.get('_request_timeout'), - collection_formats=collection_formats, - urlopen_kw=urlopen_kw) + return local_var_params, path_params, query_params, header_params, body_params def get_notification_endpoints(self, org_id, **kwargs): # noqa: E501,D401,D403 """List all notification endpoints. @@ -393,23 +428,65 @@ def get_notification_endpoints_with_http_info(self, org_id, **kwargs): # noqa: If the method is called asynchronously, returns the request thread. """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._get_notification_endpoints_prepare(org_id, **kwargs) + + return self.api_client.call_api( + '/api/v2/notificationEndpoints', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='NotificationEndpoints', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + async def get_notification_endpoints_async(self, org_id, **kwargs): # noqa: E501,D401,D403 + """List all notification endpoints. + + This method makes an asynchronous HTTP request. + + :param async_req bool + :param str org_id: Only show notification endpoints that belong to specific organization ID. (required) + :param str zap_trace_span: OpenTracing span context + :param int offset: + :param int limit: + :return: NotificationEndpoints + If the method is called asynchronously, + returns the request thread. + """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._get_notification_endpoints_prepare(org_id, **kwargs) + + return await self.api_client.call_api( + '/api/v2/notificationEndpoints', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='NotificationEndpoints', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + def _get_notification_endpoints_prepare(self, org_id, **kwargs): # noqa: E501,D401,D403 local_var_params = locals() all_params = ['org_id', 'zap_trace_span', 'offset', 'limit'] # noqa: E501 - all_params.append('async_req') - all_params.append('_return_http_data_only') - all_params.append('_preload_content') - all_params.append('_request_timeout') - all_params.append('urlopen_kw') - - for key, val in six.iteritems(local_var_params['kwargs']): - if key not in all_params: - raise TypeError( - "Got an unexpected keyword argument '%s'" - " to method get_notification_endpoints" % key - ) - local_var_params[key] = val - del local_var_params['kwargs'] + self._check_operation_params('get_notification_endpoints', all_params, local_var_params) # verify the required parameter 'org_id' is set if ('org_id' not in local_var_params or local_var_params['org_id'] is None): @@ -421,8 +498,6 @@ def get_notification_endpoints_with_http_info(self, org_id, **kwargs): # noqa: raise ValueError("Invalid value for parameter `limit` when calling `get_notification_endpoints`, must be a value less than or equal to `100`") # noqa: E501 if 'limit' in local_var_params and local_var_params['limit'] < 1: # noqa: E501 raise ValueError("Invalid value for parameter `limit` when calling `get_notification_endpoints`, must be a value greater than or equal to `1`") # noqa: E501 - collection_formats = {} - path_params = {} query_params = [] @@ -437,38 +512,12 @@ def get_notification_endpoints_with_http_info(self, org_id, **kwargs): # noqa: if 'zap_trace_span' in local_var_params: header_params['Zap-Trace-Span'] = local_var_params['zap_trace_span'] # noqa: E501 - form_params = [] - local_var_files = {} - body_params = None # HTTP header `Accept` header_params['Accept'] = self.api_client.select_header_accept( ['application/json']) # noqa: E501 - # Authentication setting - auth_settings = [] # noqa: E501 - - # urlopen optional setting - urlopen_kw = None - if 'urlopen_kw' in kwargs: - urlopen_kw = kwargs['urlopen_kw'] - - return self.api_client.call_api( - '/api/v2/notificationEndpoints', 'GET', - path_params, - query_params, - header_params, - body=body_params, - post_params=form_params, - files=local_var_files, - response_type='NotificationEndpoints', # noqa: E501 - auth_settings=auth_settings, - async_req=local_var_params.get('async_req'), - _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 - _preload_content=local_var_params.get('_preload_content', True), - _request_timeout=local_var_params.get('_request_timeout'), - collection_formats=collection_formats, - urlopen_kw=urlopen_kw) + return local_var_params, path_params, query_params, header_params, body_params def get_notification_endpoints_id(self, endpoint_id, **kwargs): # noqa: E501,D401,D403 """Retrieve a notification endpoint. @@ -507,30 +556,68 @@ def get_notification_endpoints_id_with_http_info(self, endpoint_id, **kwargs): If the method is called asynchronously, returns the request thread. """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._get_notification_endpoints_id_prepare(endpoint_id, **kwargs) + + return self.api_client.call_api( + '/api/v2/notificationEndpoints/{endpointID}', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='NotificationEndpoint', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + async def get_notification_endpoints_id_async(self, endpoint_id, **kwargs): # noqa: E501,D401,D403 + """Retrieve a notification endpoint. + + This method makes an asynchronous HTTP request. + + :param async_req bool + :param str endpoint_id: The notification endpoint ID. (required) + :param str zap_trace_span: OpenTracing span context + :return: NotificationEndpoint + If the method is called asynchronously, + returns the request thread. + """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._get_notification_endpoints_id_prepare(endpoint_id, **kwargs) + + return await self.api_client.call_api( + '/api/v2/notificationEndpoints/{endpointID}', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='NotificationEndpoint', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + def _get_notification_endpoints_id_prepare(self, endpoint_id, **kwargs): # noqa: E501,D401,D403 local_var_params = locals() all_params = ['endpoint_id', 'zap_trace_span'] # noqa: E501 - all_params.append('async_req') - all_params.append('_return_http_data_only') - all_params.append('_preload_content') - all_params.append('_request_timeout') - all_params.append('urlopen_kw') - - for key, val in six.iteritems(local_var_params['kwargs']): - if key not in all_params: - raise TypeError( - "Got an unexpected keyword argument '%s'" - " to method get_notification_endpoints_id" % key - ) - local_var_params[key] = val - del local_var_params['kwargs'] + self._check_operation_params('get_notification_endpoints_id', all_params, local_var_params) # verify the required parameter 'endpoint_id' is set if ('endpoint_id' not in local_var_params or local_var_params['endpoint_id'] is None): raise ValueError("Missing the required parameter `endpoint_id` when calling `get_notification_endpoints_id`") # noqa: E501 - collection_formats = {} - path_params = {} if 'endpoint_id' in local_var_params: path_params['endpointID'] = local_var_params['endpoint_id'] # noqa: E501 @@ -541,38 +628,12 @@ def get_notification_endpoints_id_with_http_info(self, endpoint_id, **kwargs): if 'zap_trace_span' in local_var_params: header_params['Zap-Trace-Span'] = local_var_params['zap_trace_span'] # noqa: E501 - form_params = [] - local_var_files = {} - body_params = None # HTTP header `Accept` header_params['Accept'] = self.api_client.select_header_accept( ['application/json']) # noqa: E501 - # Authentication setting - auth_settings = [] # noqa: E501 - - # urlopen optional setting - urlopen_kw = None - if 'urlopen_kw' in kwargs: - urlopen_kw = kwargs['urlopen_kw'] - - return self.api_client.call_api( - '/api/v2/notificationEndpoints/{endpointID}', 'GET', - path_params, - query_params, - header_params, - body=body_params, - post_params=form_params, - files=local_var_files, - response_type='NotificationEndpoint', # noqa: E501 - auth_settings=auth_settings, - async_req=local_var_params.get('async_req'), - _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 - _preload_content=local_var_params.get('_preload_content', True), - _request_timeout=local_var_params.get('_request_timeout'), - collection_formats=collection_formats, - urlopen_kw=urlopen_kw) + return local_var_params, path_params, query_params, header_params, body_params def get_notification_endpoints_id_labels(self, endpoint_id, **kwargs): # noqa: E501,D401,D403 """List all labels for a notification endpoint. @@ -611,30 +672,68 @@ def get_notification_endpoints_id_labels_with_http_info(self, endpoint_id, **kwa If the method is called asynchronously, returns the request thread. """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._get_notification_endpoints_id_labels_prepare(endpoint_id, **kwargs) + + return self.api_client.call_api( + '/api/v2/notificationEndpoints/{endpointID}/labels', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='LabelsResponse', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + async def get_notification_endpoints_id_labels_async(self, endpoint_id, **kwargs): # noqa: E501,D401,D403 + """List all labels for a notification endpoint. + + This method makes an asynchronous HTTP request. + + :param async_req bool + :param str endpoint_id: The notification endpoint ID. (required) + :param str zap_trace_span: OpenTracing span context + :return: LabelsResponse + If the method is called asynchronously, + returns the request thread. + """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._get_notification_endpoints_id_labels_prepare(endpoint_id, **kwargs) + + return await self.api_client.call_api( + '/api/v2/notificationEndpoints/{endpointID}/labels', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='LabelsResponse', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + def _get_notification_endpoints_id_labels_prepare(self, endpoint_id, **kwargs): # noqa: E501,D401,D403 local_var_params = locals() all_params = ['endpoint_id', 'zap_trace_span'] # noqa: E501 - all_params.append('async_req') - all_params.append('_return_http_data_only') - all_params.append('_preload_content') - all_params.append('_request_timeout') - all_params.append('urlopen_kw') - - for key, val in six.iteritems(local_var_params['kwargs']): - if key not in all_params: - raise TypeError( - "Got an unexpected keyword argument '%s'" - " to method get_notification_endpoints_id_labels" % key - ) - local_var_params[key] = val - del local_var_params['kwargs'] + self._check_operation_params('get_notification_endpoints_id_labels', all_params, local_var_params) # verify the required parameter 'endpoint_id' is set if ('endpoint_id' not in local_var_params or local_var_params['endpoint_id'] is None): raise ValueError("Missing the required parameter `endpoint_id` when calling `get_notification_endpoints_id_labels`") # noqa: E501 - collection_formats = {} - path_params = {} if 'endpoint_id' in local_var_params: path_params['endpointID'] = local_var_params['endpoint_id'] # noqa: E501 @@ -645,38 +744,12 @@ def get_notification_endpoints_id_labels_with_http_info(self, endpoint_id, **kwa if 'zap_trace_span' in local_var_params: header_params['Zap-Trace-Span'] = local_var_params['zap_trace_span'] # noqa: E501 - form_params = [] - local_var_files = {} - body_params = None # HTTP header `Accept` header_params['Accept'] = self.api_client.select_header_accept( ['application/json']) # noqa: E501 - # Authentication setting - auth_settings = [] # noqa: E501 - - # urlopen optional setting - urlopen_kw = None - if 'urlopen_kw' in kwargs: - urlopen_kw = kwargs['urlopen_kw'] - - return self.api_client.call_api( - '/api/v2/notificationEndpoints/{endpointID}/labels', 'GET', - path_params, - query_params, - header_params, - body=body_params, - post_params=form_params, - files=local_var_files, - response_type='LabelsResponse', # noqa: E501 - auth_settings=auth_settings, - async_req=local_var_params.get('async_req'), - _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 - _preload_content=local_var_params.get('_preload_content', True), - _request_timeout=local_var_params.get('_request_timeout'), - collection_formats=collection_formats, - urlopen_kw=urlopen_kw) + return local_var_params, path_params, query_params, header_params, body_params def patch_notification_endpoints_id(self, endpoint_id, notification_endpoint_update, **kwargs): # noqa: E501,D401,D403 """Update a notification endpoint. @@ -717,23 +790,64 @@ def patch_notification_endpoints_id_with_http_info(self, endpoint_id, notificati If the method is called asynchronously, returns the request thread. """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._patch_notification_endpoints_id_prepare(endpoint_id, notification_endpoint_update, **kwargs) + + return self.api_client.call_api( + '/api/v2/notificationEndpoints/{endpointID}', 'PATCH', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='NotificationEndpoint', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + async def patch_notification_endpoints_id_async(self, endpoint_id, notification_endpoint_update, **kwargs): # noqa: E501,D401,D403 + """Update a notification endpoint. + + This method makes an asynchronous HTTP request. + + :param async_req bool + :param str endpoint_id: The notification endpoint ID. (required) + :param NotificationEndpointUpdate notification_endpoint_update: Check update to apply (required) + :param str zap_trace_span: OpenTracing span context + :return: NotificationEndpoint + If the method is called asynchronously, + returns the request thread. + """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._patch_notification_endpoints_id_prepare(endpoint_id, notification_endpoint_update, **kwargs) + + return await self.api_client.call_api( + '/api/v2/notificationEndpoints/{endpointID}', 'PATCH', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='NotificationEndpoint', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + def _patch_notification_endpoints_id_prepare(self, endpoint_id, notification_endpoint_update, **kwargs): # noqa: E501,D401,D403 local_var_params = locals() all_params = ['endpoint_id', 'notification_endpoint_update', 'zap_trace_span'] # noqa: E501 - all_params.append('async_req') - all_params.append('_return_http_data_only') - all_params.append('_preload_content') - all_params.append('_request_timeout') - all_params.append('urlopen_kw') - - for key, val in six.iteritems(local_var_params['kwargs']): - if key not in all_params: - raise TypeError( - "Got an unexpected keyword argument '%s'" - " to method patch_notification_endpoints_id" % key - ) - local_var_params[key] = val - del local_var_params['kwargs'] + self._check_operation_params('patch_notification_endpoints_id', all_params, local_var_params) # verify the required parameter 'endpoint_id' is set if ('endpoint_id' not in local_var_params or local_var_params['endpoint_id'] is None): @@ -743,8 +857,6 @@ def patch_notification_endpoints_id_with_http_info(self, endpoint_id, notificati local_var_params['notification_endpoint_update'] is None): raise ValueError("Missing the required parameter `notification_endpoint_update` when calling `patch_notification_endpoints_id`") # noqa: E501 - collection_formats = {} - path_params = {} if 'endpoint_id' in local_var_params: path_params['endpointID'] = local_var_params['endpoint_id'] # noqa: E501 @@ -755,9 +867,6 @@ def patch_notification_endpoints_id_with_http_info(self, endpoint_id, notificati if 'zap_trace_span' in local_var_params: header_params['Zap-Trace-Span'] = local_var_params['zap_trace_span'] # noqa: E501 - form_params = [] - local_var_files = {} - body_params = None if 'notification_endpoint_update' in local_var_params: body_params = local_var_params['notification_endpoint_update'] @@ -769,30 +878,7 @@ def patch_notification_endpoints_id_with_http_info(self, endpoint_id, notificati header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501 ['application/json']) # noqa: E501 - # Authentication setting - auth_settings = [] # noqa: E501 - - # urlopen optional setting - urlopen_kw = None - if 'urlopen_kw' in kwargs: - urlopen_kw = kwargs['urlopen_kw'] - - return self.api_client.call_api( - '/api/v2/notificationEndpoints/{endpointID}', 'PATCH', - path_params, - query_params, - header_params, - body=body_params, - post_params=form_params, - files=local_var_files, - response_type='NotificationEndpoint', # noqa: E501 - auth_settings=auth_settings, - async_req=local_var_params.get('async_req'), - _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 - _preload_content=local_var_params.get('_preload_content', True), - _request_timeout=local_var_params.get('_request_timeout'), - collection_formats=collection_formats, - urlopen_kw=urlopen_kw) + return local_var_params, path_params, query_params, header_params, body_params def post_notification_endpoint_id_labels(self, endpoint_id, label_mapping, **kwargs): # noqa: E501,D401,D403 """Add a label to a notification endpoint. @@ -833,23 +919,64 @@ def post_notification_endpoint_id_labels_with_http_info(self, endpoint_id, label If the method is called asynchronously, returns the request thread. """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._post_notification_endpoint_id_labels_prepare(endpoint_id, label_mapping, **kwargs) + + return self.api_client.call_api( + '/api/v2/notificationEndpoints/{endpointID}/labels', 'POST', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='LabelResponse', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + async def post_notification_endpoint_id_labels_async(self, endpoint_id, label_mapping, **kwargs): # noqa: E501,D401,D403 + """Add a label to a notification endpoint. + + This method makes an asynchronous HTTP request. + + :param async_req bool + :param str endpoint_id: The notification endpoint ID. (required) + :param LabelMapping label_mapping: Label to add (required) + :param str zap_trace_span: OpenTracing span context + :return: LabelResponse + If the method is called asynchronously, + returns the request thread. + """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._post_notification_endpoint_id_labels_prepare(endpoint_id, label_mapping, **kwargs) + + return await self.api_client.call_api( + '/api/v2/notificationEndpoints/{endpointID}/labels', 'POST', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='LabelResponse', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + def _post_notification_endpoint_id_labels_prepare(self, endpoint_id, label_mapping, **kwargs): # noqa: E501,D401,D403 local_var_params = locals() all_params = ['endpoint_id', 'label_mapping', 'zap_trace_span'] # noqa: E501 - all_params.append('async_req') - all_params.append('_return_http_data_only') - all_params.append('_preload_content') - all_params.append('_request_timeout') - all_params.append('urlopen_kw') - - for key, val in six.iteritems(local_var_params['kwargs']): - if key not in all_params: - raise TypeError( - "Got an unexpected keyword argument '%s'" - " to method post_notification_endpoint_id_labels" % key - ) - local_var_params[key] = val - del local_var_params['kwargs'] + self._check_operation_params('post_notification_endpoint_id_labels', all_params, local_var_params) # verify the required parameter 'endpoint_id' is set if ('endpoint_id' not in local_var_params or local_var_params['endpoint_id'] is None): @@ -859,8 +986,6 @@ def post_notification_endpoint_id_labels_with_http_info(self, endpoint_id, label local_var_params['label_mapping'] is None): raise ValueError("Missing the required parameter `label_mapping` when calling `post_notification_endpoint_id_labels`") # noqa: E501 - collection_formats = {} - path_params = {} if 'endpoint_id' in local_var_params: path_params['endpointID'] = local_var_params['endpoint_id'] # noqa: E501 @@ -871,9 +996,6 @@ def post_notification_endpoint_id_labels_with_http_info(self, endpoint_id, label if 'zap_trace_span' in local_var_params: header_params['Zap-Trace-Span'] = local_var_params['zap_trace_span'] # noqa: E501 - form_params = [] - local_var_files = {} - body_params = None if 'label_mapping' in local_var_params: body_params = local_var_params['label_mapping'] @@ -885,30 +1007,7 @@ def post_notification_endpoint_id_labels_with_http_info(self, endpoint_id, label header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501 ['application/json']) # noqa: E501 - # Authentication setting - auth_settings = [] # noqa: E501 - - # urlopen optional setting - urlopen_kw = None - if 'urlopen_kw' in kwargs: - urlopen_kw = kwargs['urlopen_kw'] - - return self.api_client.call_api( - '/api/v2/notificationEndpoints/{endpointID}/labels', 'POST', - path_params, - query_params, - header_params, - body=body_params, - post_params=form_params, - files=local_var_files, - response_type='LabelResponse', # noqa: E501 - auth_settings=auth_settings, - async_req=local_var_params.get('async_req'), - _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 - _preload_content=local_var_params.get('_preload_content', True), - _request_timeout=local_var_params.get('_request_timeout'), - collection_formats=collection_formats, - urlopen_kw=urlopen_kw) + return local_var_params, path_params, query_params, header_params, body_params def put_notification_endpoints_id(self, endpoint_id, notification_endpoint, **kwargs): # noqa: E501,D401,D403 """Update a notification endpoint. @@ -949,23 +1048,64 @@ def put_notification_endpoints_id_with_http_info(self, endpoint_id, notification If the method is called asynchronously, returns the request thread. """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._put_notification_endpoints_id_prepare(endpoint_id, notification_endpoint, **kwargs) + + return self.api_client.call_api( + '/api/v2/notificationEndpoints/{endpointID}', 'PUT', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='NotificationEndpoint', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + async def put_notification_endpoints_id_async(self, endpoint_id, notification_endpoint, **kwargs): # noqa: E501,D401,D403 + """Update a notification endpoint. + + This method makes an asynchronous HTTP request. + + :param async_req bool + :param str endpoint_id: The notification endpoint ID. (required) + :param NotificationEndpoint notification_endpoint: A new notification endpoint to replace the existing endpoint with (required) + :param str zap_trace_span: OpenTracing span context + :return: NotificationEndpoint + If the method is called asynchronously, + returns the request thread. + """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._put_notification_endpoints_id_prepare(endpoint_id, notification_endpoint, **kwargs) + + return await self.api_client.call_api( + '/api/v2/notificationEndpoints/{endpointID}', 'PUT', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='NotificationEndpoint', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + def _put_notification_endpoints_id_prepare(self, endpoint_id, notification_endpoint, **kwargs): # noqa: E501,D401,D403 local_var_params = locals() all_params = ['endpoint_id', 'notification_endpoint', 'zap_trace_span'] # noqa: E501 - all_params.append('async_req') - all_params.append('_return_http_data_only') - all_params.append('_preload_content') - all_params.append('_request_timeout') - all_params.append('urlopen_kw') - - for key, val in six.iteritems(local_var_params['kwargs']): - if key not in all_params: - raise TypeError( - "Got an unexpected keyword argument '%s'" - " to method put_notification_endpoints_id" % key - ) - local_var_params[key] = val - del local_var_params['kwargs'] + self._check_operation_params('put_notification_endpoints_id', all_params, local_var_params) # verify the required parameter 'endpoint_id' is set if ('endpoint_id' not in local_var_params or local_var_params['endpoint_id'] is None): @@ -975,8 +1115,6 @@ def put_notification_endpoints_id_with_http_info(self, endpoint_id, notification local_var_params['notification_endpoint'] is None): raise ValueError("Missing the required parameter `notification_endpoint` when calling `put_notification_endpoints_id`") # noqa: E501 - collection_formats = {} - path_params = {} if 'endpoint_id' in local_var_params: path_params['endpointID'] = local_var_params['endpoint_id'] # noqa: E501 @@ -987,9 +1125,6 @@ def put_notification_endpoints_id_with_http_info(self, endpoint_id, notification if 'zap_trace_span' in local_var_params: header_params['Zap-Trace-Span'] = local_var_params['zap_trace_span'] # noqa: E501 - form_params = [] - local_var_files = {} - body_params = None if 'notification_endpoint' in local_var_params: body_params = local_var_params['notification_endpoint'] @@ -1001,27 +1136,4 @@ def put_notification_endpoints_id_with_http_info(self, endpoint_id, notification header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501 ['application/json']) # noqa: E501 - # Authentication setting - auth_settings = [] # noqa: E501 - - # urlopen optional setting - urlopen_kw = None - if 'urlopen_kw' in kwargs: - urlopen_kw = kwargs['urlopen_kw'] - - return self.api_client.call_api( - '/api/v2/notificationEndpoints/{endpointID}', 'PUT', - path_params, - query_params, - header_params, - body=body_params, - post_params=form_params, - files=local_var_files, - response_type='NotificationEndpoint', # noqa: E501 - auth_settings=auth_settings, - async_req=local_var_params.get('async_req'), - _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 - _preload_content=local_var_params.get('_preload_content', True), - _request_timeout=local_var_params.get('_request_timeout'), - collection_formats=collection_formats, - urlopen_kw=urlopen_kw) + return local_var_params, path_params, query_params, header_params, body_params diff --git a/influxdb_client/service/notification_rules_service.py b/influxdb_client/service/notification_rules_service.py index 10f052a9..e92352c0 100644 --- a/influxdb_client/service/notification_rules_service.py +++ b/influxdb_client/service/notification_rules_service.py @@ -14,11 +14,10 @@ import re # noqa: F401 -# python 2 and python 3 compatibility library -import six +from influxdb_client.service._base_service import _BaseService -class NotificationRulesService(object): +class NotificationRulesService(_BaseService): """NOTE: This class is auto generated by OpenAPI Generator. Ref: https://openapi-generator.tech @@ -67,39 +66,73 @@ def create_notification_rule_with_http_info(self, post_notification_rule, **kwar If the method is called asynchronously, returns the request thread. """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._create_notification_rule_prepare(post_notification_rule, **kwargs) + + return self.api_client.call_api( + '/api/v2/notificationRules', 'POST', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='NotificationRule', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + async def create_notification_rule_async(self, post_notification_rule, **kwargs): # noqa: E501,D401,D403 + """Add a notification rule. + + This method makes an asynchronous HTTP request. + + :param async_req bool + :param PostNotificationRule post_notification_rule: Notification rule to create (required) + :return: NotificationRule + If the method is called asynchronously, + returns the request thread. + """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._create_notification_rule_prepare(post_notification_rule, **kwargs) + + return await self.api_client.call_api( + '/api/v2/notificationRules', 'POST', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='NotificationRule', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + def _create_notification_rule_prepare(self, post_notification_rule, **kwargs): # noqa: E501,D401,D403 local_var_params = locals() all_params = ['post_notification_rule'] # noqa: E501 - all_params.append('async_req') - all_params.append('_return_http_data_only') - all_params.append('_preload_content') - all_params.append('_request_timeout') - all_params.append('urlopen_kw') - - for key, val in six.iteritems(local_var_params['kwargs']): - if key not in all_params: - raise TypeError( - "Got an unexpected keyword argument '%s'" - " to method create_notification_rule" % key - ) - local_var_params[key] = val - del local_var_params['kwargs'] + self._check_operation_params('create_notification_rule', all_params, local_var_params) # verify the required parameter 'post_notification_rule' is set if ('post_notification_rule' not in local_var_params or local_var_params['post_notification_rule'] is None): raise ValueError("Missing the required parameter `post_notification_rule` when calling `create_notification_rule`") # noqa: E501 - collection_formats = {} - path_params = {} query_params = [] header_params = {} - form_params = [] - local_var_files = {} - body_params = None if 'post_notification_rule' in local_var_params: body_params = local_var_params['post_notification_rule'] @@ -111,30 +144,7 @@ def create_notification_rule_with_http_info(self, post_notification_rule, **kwar header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501 ['application/json']) # noqa: E501 - # Authentication setting - auth_settings = [] # noqa: E501 - - # urlopen optional setting - urlopen_kw = None - if 'urlopen_kw' in kwargs: - urlopen_kw = kwargs['urlopen_kw'] - - return self.api_client.call_api( - '/api/v2/notificationRules', 'POST', - path_params, - query_params, - header_params, - body=body_params, - post_params=form_params, - files=local_var_files, - response_type='NotificationRule', # noqa: E501 - auth_settings=auth_settings, - async_req=local_var_params.get('async_req'), - _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 - _preload_content=local_var_params.get('_preload_content', True), - _request_timeout=local_var_params.get('_request_timeout'), - collection_formats=collection_formats, - urlopen_kw=urlopen_kw) + return local_var_params, path_params, query_params, header_params, body_params def delete_notification_rules_id(self, rule_id, **kwargs): # noqa: E501,D401,D403 """Delete a notification rule. @@ -173,30 +183,68 @@ def delete_notification_rules_id_with_http_info(self, rule_id, **kwargs): # noq If the method is called asynchronously, returns the request thread. """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._delete_notification_rules_id_prepare(rule_id, **kwargs) + + return self.api_client.call_api( + '/api/v2/notificationRules/{ruleID}', 'DELETE', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type=None, # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + async def delete_notification_rules_id_async(self, rule_id, **kwargs): # noqa: E501,D401,D403 + """Delete a notification rule. + + This method makes an asynchronous HTTP request. + + :param async_req bool + :param str rule_id: The notification rule ID. (required) + :param str zap_trace_span: OpenTracing span context + :return: None + If the method is called asynchronously, + returns the request thread. + """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._delete_notification_rules_id_prepare(rule_id, **kwargs) + + return await self.api_client.call_api( + '/api/v2/notificationRules/{ruleID}', 'DELETE', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type=None, # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + def _delete_notification_rules_id_prepare(self, rule_id, **kwargs): # noqa: E501,D401,D403 local_var_params = locals() all_params = ['rule_id', 'zap_trace_span'] # noqa: E501 - all_params.append('async_req') - all_params.append('_return_http_data_only') - all_params.append('_preload_content') - all_params.append('_request_timeout') - all_params.append('urlopen_kw') - - for key, val in six.iteritems(local_var_params['kwargs']): - if key not in all_params: - raise TypeError( - "Got an unexpected keyword argument '%s'" - " to method delete_notification_rules_id" % key - ) - local_var_params[key] = val - del local_var_params['kwargs'] + self._check_operation_params('delete_notification_rules_id', all_params, local_var_params) # verify the required parameter 'rule_id' is set if ('rule_id' not in local_var_params or local_var_params['rule_id'] is None): raise ValueError("Missing the required parameter `rule_id` when calling `delete_notification_rules_id`") # noqa: E501 - collection_formats = {} - path_params = {} if 'rule_id' in local_var_params: path_params['ruleID'] = local_var_params['rule_id'] # noqa: E501 @@ -207,38 +255,12 @@ def delete_notification_rules_id_with_http_info(self, rule_id, **kwargs): # noq if 'zap_trace_span' in local_var_params: header_params['Zap-Trace-Span'] = local_var_params['zap_trace_span'] # noqa: E501 - form_params = [] - local_var_files = {} - body_params = None # HTTP header `Accept` header_params['Accept'] = self.api_client.select_header_accept( ['application/json']) # noqa: E501 - # Authentication setting - auth_settings = [] # noqa: E501 - - # urlopen optional setting - urlopen_kw = None - if 'urlopen_kw' in kwargs: - urlopen_kw = kwargs['urlopen_kw'] - - return self.api_client.call_api( - '/api/v2/notificationRules/{ruleID}', 'DELETE', - path_params, - query_params, - header_params, - body=body_params, - post_params=form_params, - files=local_var_files, - response_type=None, # noqa: E501 - auth_settings=auth_settings, - async_req=local_var_params.get('async_req'), - _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 - _preload_content=local_var_params.get('_preload_content', True), - _request_timeout=local_var_params.get('_request_timeout'), - collection_formats=collection_formats, - urlopen_kw=urlopen_kw) + return local_var_params, path_params, query_params, header_params, body_params def delete_notification_rules_id_labels_id(self, rule_id, label_id, **kwargs): # noqa: E501,D401,D403 """Delete label from a notification rule. @@ -279,23 +301,64 @@ def delete_notification_rules_id_labels_id_with_http_info(self, rule_id, label_i If the method is called asynchronously, returns the request thread. """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._delete_notification_rules_id_labels_id_prepare(rule_id, label_id, **kwargs) + + return self.api_client.call_api( + '/api/v2/notificationRules/{ruleID}/labels/{labelID}', 'DELETE', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type=None, # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + async def delete_notification_rules_id_labels_id_async(self, rule_id, label_id, **kwargs): # noqa: E501,D401,D403 + """Delete label from a notification rule. + + This method makes an asynchronous HTTP request. + + :param async_req bool + :param str rule_id: The notification rule ID. (required) + :param str label_id: The ID of the label to delete. (required) + :param str zap_trace_span: OpenTracing span context + :return: None + If the method is called asynchronously, + returns the request thread. + """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._delete_notification_rules_id_labels_id_prepare(rule_id, label_id, **kwargs) + + return await self.api_client.call_api( + '/api/v2/notificationRules/{ruleID}/labels/{labelID}', 'DELETE', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type=None, # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + def _delete_notification_rules_id_labels_id_prepare(self, rule_id, label_id, **kwargs): # noqa: E501,D401,D403 local_var_params = locals() all_params = ['rule_id', 'label_id', 'zap_trace_span'] # noqa: E501 - all_params.append('async_req') - all_params.append('_return_http_data_only') - all_params.append('_preload_content') - all_params.append('_request_timeout') - all_params.append('urlopen_kw') - - for key, val in six.iteritems(local_var_params['kwargs']): - if key not in all_params: - raise TypeError( - "Got an unexpected keyword argument '%s'" - " to method delete_notification_rules_id_labels_id" % key - ) - local_var_params[key] = val - del local_var_params['kwargs'] + self._check_operation_params('delete_notification_rules_id_labels_id', all_params, local_var_params) # verify the required parameter 'rule_id' is set if ('rule_id' not in local_var_params or local_var_params['rule_id'] is None): @@ -305,8 +368,6 @@ def delete_notification_rules_id_labels_id_with_http_info(self, rule_id, label_i local_var_params['label_id'] is None): raise ValueError("Missing the required parameter `label_id` when calling `delete_notification_rules_id_labels_id`") # noqa: E501 - collection_formats = {} - path_params = {} if 'rule_id' in local_var_params: path_params['ruleID'] = local_var_params['rule_id'] # noqa: E501 @@ -319,38 +380,12 @@ def delete_notification_rules_id_labels_id_with_http_info(self, rule_id, label_i if 'zap_trace_span' in local_var_params: header_params['Zap-Trace-Span'] = local_var_params['zap_trace_span'] # noqa: E501 - form_params = [] - local_var_files = {} - body_params = None # HTTP header `Accept` header_params['Accept'] = self.api_client.select_header_accept( ['application/json']) # noqa: E501 - # Authentication setting - auth_settings = [] # noqa: E501 - - # urlopen optional setting - urlopen_kw = None - if 'urlopen_kw' in kwargs: - urlopen_kw = kwargs['urlopen_kw'] - - return self.api_client.call_api( - '/api/v2/notificationRules/{ruleID}/labels/{labelID}', 'DELETE', - path_params, - query_params, - header_params, - body=body_params, - post_params=form_params, - files=local_var_files, - response_type=None, # noqa: E501 - auth_settings=auth_settings, - async_req=local_var_params.get('async_req'), - _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 - _preload_content=local_var_params.get('_preload_content', True), - _request_timeout=local_var_params.get('_request_timeout'), - collection_formats=collection_formats, - urlopen_kw=urlopen_kw) + return local_var_params, path_params, query_params, header_params, body_params def get_notification_rules(self, org_id, **kwargs): # noqa: E501,D401,D403 """List all notification rules. @@ -397,23 +432,67 @@ def get_notification_rules_with_http_info(self, org_id, **kwargs): # noqa: E501 If the method is called asynchronously, returns the request thread. """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._get_notification_rules_prepare(org_id, **kwargs) + + return self.api_client.call_api( + '/api/v2/notificationRules', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='NotificationRules', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + async def get_notification_rules_async(self, org_id, **kwargs): # noqa: E501,D401,D403 + """List all notification rules. + + This method makes an asynchronous HTTP request. + + :param async_req bool + :param str org_id: Only show notification rules that belong to a specific organization ID. (required) + :param str zap_trace_span: OpenTracing span context + :param int offset: + :param int limit: + :param str check_id: Only show notifications that belong to the specific check ID. + :param str tag: Only return notification rules that "would match" statuses which contain the tag key value pairs provided. + :return: NotificationRules + If the method is called asynchronously, + returns the request thread. + """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._get_notification_rules_prepare(org_id, **kwargs) + + return await self.api_client.call_api( + '/api/v2/notificationRules', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='NotificationRules', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + def _get_notification_rules_prepare(self, org_id, **kwargs): # noqa: E501,D401,D403 local_var_params = locals() all_params = ['org_id', 'zap_trace_span', 'offset', 'limit', 'check_id', 'tag'] # noqa: E501 - all_params.append('async_req') - all_params.append('_return_http_data_only') - all_params.append('_preload_content') - all_params.append('_request_timeout') - all_params.append('urlopen_kw') - - for key, val in six.iteritems(local_var_params['kwargs']): - if key not in all_params: - raise TypeError( - "Got an unexpected keyword argument '%s'" - " to method get_notification_rules" % key - ) - local_var_params[key] = val - del local_var_params['kwargs'] + self._check_operation_params('get_notification_rules', all_params, local_var_params) # verify the required parameter 'org_id' is set if ('org_id' not in local_var_params or local_var_params['org_id'] is None): @@ -427,8 +506,6 @@ def get_notification_rules_with_http_info(self, org_id, **kwargs): # noqa: E501 raise ValueError("Invalid value for parameter `limit` when calling `get_notification_rules`, must be a value greater than or equal to `1`") # noqa: E501 if 'tag' in local_var_params and not re.search(r'^[a-zA-Z0-9_]+:[a-zA-Z0-9_]+$', local_var_params['tag']): # noqa: E501 raise ValueError("Invalid value for parameter `tag` when calling `get_notification_rules`, must conform to the pattern `/^[a-zA-Z0-9_]+:[a-zA-Z0-9_]+$/`") # noqa: E501 - collection_formats = {} - path_params = {} query_params = [] @@ -447,38 +524,12 @@ def get_notification_rules_with_http_info(self, org_id, **kwargs): # noqa: E501 if 'zap_trace_span' in local_var_params: header_params['Zap-Trace-Span'] = local_var_params['zap_trace_span'] # noqa: E501 - form_params = [] - local_var_files = {} - body_params = None # HTTP header `Accept` header_params['Accept'] = self.api_client.select_header_accept( ['application/json']) # noqa: E501 - # Authentication setting - auth_settings = [] # noqa: E501 - - # urlopen optional setting - urlopen_kw = None - if 'urlopen_kw' in kwargs: - urlopen_kw = kwargs['urlopen_kw'] - - return self.api_client.call_api( - '/api/v2/notificationRules', 'GET', - path_params, - query_params, - header_params, - body=body_params, - post_params=form_params, - files=local_var_files, - response_type='NotificationRules', # noqa: E501 - auth_settings=auth_settings, - async_req=local_var_params.get('async_req'), - _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 - _preload_content=local_var_params.get('_preload_content', True), - _request_timeout=local_var_params.get('_request_timeout'), - collection_formats=collection_formats, - urlopen_kw=urlopen_kw) + return local_var_params, path_params, query_params, header_params, body_params def get_notification_rules_id(self, rule_id, **kwargs): # noqa: E501,D401,D403 """Retrieve a notification rule. @@ -517,30 +568,68 @@ def get_notification_rules_id_with_http_info(self, rule_id, **kwargs): # noqa: If the method is called asynchronously, returns the request thread. """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._get_notification_rules_id_prepare(rule_id, **kwargs) + + return self.api_client.call_api( + '/api/v2/notificationRules/{ruleID}', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='NotificationRule', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + async def get_notification_rules_id_async(self, rule_id, **kwargs): # noqa: E501,D401,D403 + """Retrieve a notification rule. + + This method makes an asynchronous HTTP request. + + :param async_req bool + :param str rule_id: The notification rule ID. (required) + :param str zap_trace_span: OpenTracing span context + :return: NotificationRule + If the method is called asynchronously, + returns the request thread. + """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._get_notification_rules_id_prepare(rule_id, **kwargs) + + return await self.api_client.call_api( + '/api/v2/notificationRules/{ruleID}', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='NotificationRule', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + def _get_notification_rules_id_prepare(self, rule_id, **kwargs): # noqa: E501,D401,D403 local_var_params = locals() all_params = ['rule_id', 'zap_trace_span'] # noqa: E501 - all_params.append('async_req') - all_params.append('_return_http_data_only') - all_params.append('_preload_content') - all_params.append('_request_timeout') - all_params.append('urlopen_kw') - - for key, val in six.iteritems(local_var_params['kwargs']): - if key not in all_params: - raise TypeError( - "Got an unexpected keyword argument '%s'" - " to method get_notification_rules_id" % key - ) - local_var_params[key] = val - del local_var_params['kwargs'] + self._check_operation_params('get_notification_rules_id', all_params, local_var_params) # verify the required parameter 'rule_id' is set if ('rule_id' not in local_var_params or local_var_params['rule_id'] is None): raise ValueError("Missing the required parameter `rule_id` when calling `get_notification_rules_id`") # noqa: E501 - collection_formats = {} - path_params = {} if 'rule_id' in local_var_params: path_params['ruleID'] = local_var_params['rule_id'] # noqa: E501 @@ -551,38 +640,12 @@ def get_notification_rules_id_with_http_info(self, rule_id, **kwargs): # noqa: if 'zap_trace_span' in local_var_params: header_params['Zap-Trace-Span'] = local_var_params['zap_trace_span'] # noqa: E501 - form_params = [] - local_var_files = {} - body_params = None # HTTP header `Accept` header_params['Accept'] = self.api_client.select_header_accept( ['application/json']) # noqa: E501 - # Authentication setting - auth_settings = [] # noqa: E501 - - # urlopen optional setting - urlopen_kw = None - if 'urlopen_kw' in kwargs: - urlopen_kw = kwargs['urlopen_kw'] - - return self.api_client.call_api( - '/api/v2/notificationRules/{ruleID}', 'GET', - path_params, - query_params, - header_params, - body=body_params, - post_params=form_params, - files=local_var_files, - response_type='NotificationRule', # noqa: E501 - auth_settings=auth_settings, - async_req=local_var_params.get('async_req'), - _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 - _preload_content=local_var_params.get('_preload_content', True), - _request_timeout=local_var_params.get('_request_timeout'), - collection_formats=collection_formats, - urlopen_kw=urlopen_kw) + return local_var_params, path_params, query_params, header_params, body_params def get_notification_rules_id_labels(self, rule_id, **kwargs): # noqa: E501,D401,D403 """List all labels for a notification rule. @@ -621,30 +684,68 @@ def get_notification_rules_id_labels_with_http_info(self, rule_id, **kwargs): # If the method is called asynchronously, returns the request thread. """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._get_notification_rules_id_labels_prepare(rule_id, **kwargs) + + return self.api_client.call_api( + '/api/v2/notificationRules/{ruleID}/labels', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='LabelsResponse', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + async def get_notification_rules_id_labels_async(self, rule_id, **kwargs): # noqa: E501,D401,D403 + """List all labels for a notification rule. + + This method makes an asynchronous HTTP request. + + :param async_req bool + :param str rule_id: The notification rule ID. (required) + :param str zap_trace_span: OpenTracing span context + :return: LabelsResponse + If the method is called asynchronously, + returns the request thread. + """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._get_notification_rules_id_labels_prepare(rule_id, **kwargs) + + return await self.api_client.call_api( + '/api/v2/notificationRules/{ruleID}/labels', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='LabelsResponse', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + def _get_notification_rules_id_labels_prepare(self, rule_id, **kwargs): # noqa: E501,D401,D403 local_var_params = locals() all_params = ['rule_id', 'zap_trace_span'] # noqa: E501 - all_params.append('async_req') - all_params.append('_return_http_data_only') - all_params.append('_preload_content') - all_params.append('_request_timeout') - all_params.append('urlopen_kw') - - for key, val in six.iteritems(local_var_params['kwargs']): - if key not in all_params: - raise TypeError( - "Got an unexpected keyword argument '%s'" - " to method get_notification_rules_id_labels" % key - ) - local_var_params[key] = val - del local_var_params['kwargs'] + self._check_operation_params('get_notification_rules_id_labels', all_params, local_var_params) # verify the required parameter 'rule_id' is set if ('rule_id' not in local_var_params or local_var_params['rule_id'] is None): raise ValueError("Missing the required parameter `rule_id` when calling `get_notification_rules_id_labels`") # noqa: E501 - collection_formats = {} - path_params = {} if 'rule_id' in local_var_params: path_params['ruleID'] = local_var_params['rule_id'] # noqa: E501 @@ -655,38 +756,12 @@ def get_notification_rules_id_labels_with_http_info(self, rule_id, **kwargs): # if 'zap_trace_span' in local_var_params: header_params['Zap-Trace-Span'] = local_var_params['zap_trace_span'] # noqa: E501 - form_params = [] - local_var_files = {} - body_params = None # HTTP header `Accept` header_params['Accept'] = self.api_client.select_header_accept( ['application/json']) # noqa: E501 - # Authentication setting - auth_settings = [] # noqa: E501 - - # urlopen optional setting - urlopen_kw = None - if 'urlopen_kw' in kwargs: - urlopen_kw = kwargs['urlopen_kw'] - - return self.api_client.call_api( - '/api/v2/notificationRules/{ruleID}/labels', 'GET', - path_params, - query_params, - header_params, - body=body_params, - post_params=form_params, - files=local_var_files, - response_type='LabelsResponse', # noqa: E501 - auth_settings=auth_settings, - async_req=local_var_params.get('async_req'), - _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 - _preload_content=local_var_params.get('_preload_content', True), - _request_timeout=local_var_params.get('_request_timeout'), - collection_formats=collection_formats, - urlopen_kw=urlopen_kw) + return local_var_params, path_params, query_params, header_params, body_params def patch_notification_rules_id(self, rule_id, notification_rule_update, **kwargs): # noqa: E501,D401,D403 """Update a notification rule. @@ -727,23 +802,64 @@ def patch_notification_rules_id_with_http_info(self, rule_id, notification_rule_ If the method is called asynchronously, returns the request thread. """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._patch_notification_rules_id_prepare(rule_id, notification_rule_update, **kwargs) + + return self.api_client.call_api( + '/api/v2/notificationRules/{ruleID}', 'PATCH', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='NotificationRule', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + async def patch_notification_rules_id_async(self, rule_id, notification_rule_update, **kwargs): # noqa: E501,D401,D403 + """Update a notification rule. + + This method makes an asynchronous HTTP request. + + :param async_req bool + :param str rule_id: The notification rule ID. (required) + :param NotificationRuleUpdate notification_rule_update: Notification rule update to apply (required) + :param str zap_trace_span: OpenTracing span context + :return: NotificationRule + If the method is called asynchronously, + returns the request thread. + """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._patch_notification_rules_id_prepare(rule_id, notification_rule_update, **kwargs) + + return await self.api_client.call_api( + '/api/v2/notificationRules/{ruleID}', 'PATCH', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='NotificationRule', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + def _patch_notification_rules_id_prepare(self, rule_id, notification_rule_update, **kwargs): # noqa: E501,D401,D403 local_var_params = locals() all_params = ['rule_id', 'notification_rule_update', 'zap_trace_span'] # noqa: E501 - all_params.append('async_req') - all_params.append('_return_http_data_only') - all_params.append('_preload_content') - all_params.append('_request_timeout') - all_params.append('urlopen_kw') - - for key, val in six.iteritems(local_var_params['kwargs']): - if key not in all_params: - raise TypeError( - "Got an unexpected keyword argument '%s'" - " to method patch_notification_rules_id" % key - ) - local_var_params[key] = val - del local_var_params['kwargs'] + self._check_operation_params('patch_notification_rules_id', all_params, local_var_params) # verify the required parameter 'rule_id' is set if ('rule_id' not in local_var_params or local_var_params['rule_id'] is None): @@ -753,8 +869,6 @@ def patch_notification_rules_id_with_http_info(self, rule_id, notification_rule_ local_var_params['notification_rule_update'] is None): raise ValueError("Missing the required parameter `notification_rule_update` when calling `patch_notification_rules_id`") # noqa: E501 - collection_formats = {} - path_params = {} if 'rule_id' in local_var_params: path_params['ruleID'] = local_var_params['rule_id'] # noqa: E501 @@ -765,9 +879,6 @@ def patch_notification_rules_id_with_http_info(self, rule_id, notification_rule_ if 'zap_trace_span' in local_var_params: header_params['Zap-Trace-Span'] = local_var_params['zap_trace_span'] # noqa: E501 - form_params = [] - local_var_files = {} - body_params = None if 'notification_rule_update' in local_var_params: body_params = local_var_params['notification_rule_update'] @@ -779,30 +890,7 @@ def patch_notification_rules_id_with_http_info(self, rule_id, notification_rule_ header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501 ['application/json']) # noqa: E501 - # Authentication setting - auth_settings = [] # noqa: E501 - - # urlopen optional setting - urlopen_kw = None - if 'urlopen_kw' in kwargs: - urlopen_kw = kwargs['urlopen_kw'] - - return self.api_client.call_api( - '/api/v2/notificationRules/{ruleID}', 'PATCH', - path_params, - query_params, - header_params, - body=body_params, - post_params=form_params, - files=local_var_files, - response_type='NotificationRule', # noqa: E501 - auth_settings=auth_settings, - async_req=local_var_params.get('async_req'), - _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 - _preload_content=local_var_params.get('_preload_content', True), - _request_timeout=local_var_params.get('_request_timeout'), - collection_formats=collection_formats, - urlopen_kw=urlopen_kw) + return local_var_params, path_params, query_params, header_params, body_params def post_notification_rule_id_labels(self, rule_id, label_mapping, **kwargs): # noqa: E501,D401,D403 """Add a label to a notification rule. @@ -843,23 +931,64 @@ def post_notification_rule_id_labels_with_http_info(self, rule_id, label_mapping If the method is called asynchronously, returns the request thread. """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._post_notification_rule_id_labels_prepare(rule_id, label_mapping, **kwargs) + + return self.api_client.call_api( + '/api/v2/notificationRules/{ruleID}/labels', 'POST', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='LabelResponse', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + async def post_notification_rule_id_labels_async(self, rule_id, label_mapping, **kwargs): # noqa: E501,D401,D403 + """Add a label to a notification rule. + + This method makes an asynchronous HTTP request. + + :param async_req bool + :param str rule_id: The notification rule ID. (required) + :param LabelMapping label_mapping: Label to add (required) + :param str zap_trace_span: OpenTracing span context + :return: LabelResponse + If the method is called asynchronously, + returns the request thread. + """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._post_notification_rule_id_labels_prepare(rule_id, label_mapping, **kwargs) + + return await self.api_client.call_api( + '/api/v2/notificationRules/{ruleID}/labels', 'POST', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='LabelResponse', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + def _post_notification_rule_id_labels_prepare(self, rule_id, label_mapping, **kwargs): # noqa: E501,D401,D403 local_var_params = locals() all_params = ['rule_id', 'label_mapping', 'zap_trace_span'] # noqa: E501 - all_params.append('async_req') - all_params.append('_return_http_data_only') - all_params.append('_preload_content') - all_params.append('_request_timeout') - all_params.append('urlopen_kw') - - for key, val in six.iteritems(local_var_params['kwargs']): - if key not in all_params: - raise TypeError( - "Got an unexpected keyword argument '%s'" - " to method post_notification_rule_id_labels" % key - ) - local_var_params[key] = val - del local_var_params['kwargs'] + self._check_operation_params('post_notification_rule_id_labels', all_params, local_var_params) # verify the required parameter 'rule_id' is set if ('rule_id' not in local_var_params or local_var_params['rule_id'] is None): @@ -869,8 +998,6 @@ def post_notification_rule_id_labels_with_http_info(self, rule_id, label_mapping local_var_params['label_mapping'] is None): raise ValueError("Missing the required parameter `label_mapping` when calling `post_notification_rule_id_labels`") # noqa: E501 - collection_formats = {} - path_params = {} if 'rule_id' in local_var_params: path_params['ruleID'] = local_var_params['rule_id'] # noqa: E501 @@ -881,9 +1008,6 @@ def post_notification_rule_id_labels_with_http_info(self, rule_id, label_mapping if 'zap_trace_span' in local_var_params: header_params['Zap-Trace-Span'] = local_var_params['zap_trace_span'] # noqa: E501 - form_params = [] - local_var_files = {} - body_params = None if 'label_mapping' in local_var_params: body_params = local_var_params['label_mapping'] @@ -895,30 +1019,7 @@ def post_notification_rule_id_labels_with_http_info(self, rule_id, label_mapping header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501 ['application/json']) # noqa: E501 - # Authentication setting - auth_settings = [] # noqa: E501 - - # urlopen optional setting - urlopen_kw = None - if 'urlopen_kw' in kwargs: - urlopen_kw = kwargs['urlopen_kw'] - - return self.api_client.call_api( - '/api/v2/notificationRules/{ruleID}/labels', 'POST', - path_params, - query_params, - header_params, - body=body_params, - post_params=form_params, - files=local_var_files, - response_type='LabelResponse', # noqa: E501 - auth_settings=auth_settings, - async_req=local_var_params.get('async_req'), - _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 - _preload_content=local_var_params.get('_preload_content', True), - _request_timeout=local_var_params.get('_request_timeout'), - collection_formats=collection_formats, - urlopen_kw=urlopen_kw) + return local_var_params, path_params, query_params, header_params, body_params def put_notification_rules_id(self, rule_id, notification_rule, **kwargs): # noqa: E501,D401,D403 """Update a notification rule. @@ -959,23 +1060,64 @@ def put_notification_rules_id_with_http_info(self, rule_id, notification_rule, * If the method is called asynchronously, returns the request thread. """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._put_notification_rules_id_prepare(rule_id, notification_rule, **kwargs) + + return self.api_client.call_api( + '/api/v2/notificationRules/{ruleID}', 'PUT', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='NotificationRule', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + async def put_notification_rules_id_async(self, rule_id, notification_rule, **kwargs): # noqa: E501,D401,D403 + """Update a notification rule. + + This method makes an asynchronous HTTP request. + + :param async_req bool + :param str rule_id: The notification rule ID. (required) + :param NotificationRule notification_rule: Notification rule update to apply (required) + :param str zap_trace_span: OpenTracing span context + :return: NotificationRule + If the method is called asynchronously, + returns the request thread. + """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._put_notification_rules_id_prepare(rule_id, notification_rule, **kwargs) + + return await self.api_client.call_api( + '/api/v2/notificationRules/{ruleID}', 'PUT', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='NotificationRule', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + def _put_notification_rules_id_prepare(self, rule_id, notification_rule, **kwargs): # noqa: E501,D401,D403 local_var_params = locals() all_params = ['rule_id', 'notification_rule', 'zap_trace_span'] # noqa: E501 - all_params.append('async_req') - all_params.append('_return_http_data_only') - all_params.append('_preload_content') - all_params.append('_request_timeout') - all_params.append('urlopen_kw') - - for key, val in six.iteritems(local_var_params['kwargs']): - if key not in all_params: - raise TypeError( - "Got an unexpected keyword argument '%s'" - " to method put_notification_rules_id" % key - ) - local_var_params[key] = val - del local_var_params['kwargs'] + self._check_operation_params('put_notification_rules_id', all_params, local_var_params) # verify the required parameter 'rule_id' is set if ('rule_id' not in local_var_params or local_var_params['rule_id'] is None): @@ -985,8 +1127,6 @@ def put_notification_rules_id_with_http_info(self, rule_id, notification_rule, * local_var_params['notification_rule'] is None): raise ValueError("Missing the required parameter `notification_rule` when calling `put_notification_rules_id`") # noqa: E501 - collection_formats = {} - path_params = {} if 'rule_id' in local_var_params: path_params['ruleID'] = local_var_params['rule_id'] # noqa: E501 @@ -997,9 +1137,6 @@ def put_notification_rules_id_with_http_info(self, rule_id, notification_rule, * if 'zap_trace_span' in local_var_params: header_params['Zap-Trace-Span'] = local_var_params['zap_trace_span'] # noqa: E501 - form_params = [] - local_var_files = {} - body_params = None if 'notification_rule' in local_var_params: body_params = local_var_params['notification_rule'] @@ -1011,27 +1148,4 @@ def put_notification_rules_id_with_http_info(self, rule_id, notification_rule, * header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501 ['application/json']) # noqa: E501 - # Authentication setting - auth_settings = [] # noqa: E501 - - # urlopen optional setting - urlopen_kw = None - if 'urlopen_kw' in kwargs: - urlopen_kw = kwargs['urlopen_kw'] - - return self.api_client.call_api( - '/api/v2/notificationRules/{ruleID}', 'PUT', - path_params, - query_params, - header_params, - body=body_params, - post_params=form_params, - files=local_var_files, - response_type='NotificationRule', # noqa: E501 - auth_settings=auth_settings, - async_req=local_var_params.get('async_req'), - _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 - _preload_content=local_var_params.get('_preload_content', True), - _request_timeout=local_var_params.get('_request_timeout'), - collection_formats=collection_formats, - urlopen_kw=urlopen_kw) + return local_var_params, path_params, query_params, header_params, body_params diff --git a/influxdb_client/service/organizations_service.py b/influxdb_client/service/organizations_service.py index 8d7a2654..9be1693f 100644 --- a/influxdb_client/service/organizations_service.py +++ b/influxdb_client/service/organizations_service.py @@ -14,11 +14,10 @@ import re # noqa: F401 -# python 2 and python 3 compatibility library -import six +from influxdb_client.service._base_service import _BaseService -class OrganizationsService(object): +class OrganizationsService(_BaseService): """NOTE: This class is auto generated by OpenAPI Generator. Ref: https://openapi-generator.tech @@ -69,30 +68,68 @@ def delete_orgs_id_with_http_info(self, org_id, **kwargs): # noqa: E501,D401,D4 If the method is called asynchronously, returns the request thread. """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._delete_orgs_id_prepare(org_id, **kwargs) + + return self.api_client.call_api( + '/api/v2/orgs/{orgID}', 'DELETE', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type=None, # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + async def delete_orgs_id_async(self, org_id, **kwargs): # noqa: E501,D401,D403 + """Delete an organization. + + This method makes an asynchronous HTTP request. + + :param async_req bool + :param str org_id: The ID of the organization to delete. (required) + :param str zap_trace_span: OpenTracing span context + :return: None + If the method is called asynchronously, + returns the request thread. + """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._delete_orgs_id_prepare(org_id, **kwargs) + + return await self.api_client.call_api( + '/api/v2/orgs/{orgID}', 'DELETE', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type=None, # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + def _delete_orgs_id_prepare(self, org_id, **kwargs): # noqa: E501,D401,D403 local_var_params = locals() all_params = ['org_id', 'zap_trace_span'] # noqa: E501 - all_params.append('async_req') - all_params.append('_return_http_data_only') - all_params.append('_preload_content') - all_params.append('_request_timeout') - all_params.append('urlopen_kw') - - for key, val in six.iteritems(local_var_params['kwargs']): - if key not in all_params: - raise TypeError( - "Got an unexpected keyword argument '%s'" - " to method delete_orgs_id" % key - ) - local_var_params[key] = val - del local_var_params['kwargs'] + self._check_operation_params('delete_orgs_id', all_params, local_var_params) # verify the required parameter 'org_id' is set if ('org_id' not in local_var_params or local_var_params['org_id'] is None): raise ValueError("Missing the required parameter `org_id` when calling `delete_orgs_id`") # noqa: E501 - collection_formats = {} - path_params = {} if 'org_id' in local_var_params: path_params['orgID'] = local_var_params['org_id'] # noqa: E501 @@ -103,38 +140,12 @@ def delete_orgs_id_with_http_info(self, org_id, **kwargs): # noqa: E501,D401,D4 if 'zap_trace_span' in local_var_params: header_params['Zap-Trace-Span'] = local_var_params['zap_trace_span'] # noqa: E501 - form_params = [] - local_var_files = {} - body_params = None # HTTP header `Accept` header_params['Accept'] = self.api_client.select_header_accept( ['application/json']) # noqa: E501 - # Authentication setting - auth_settings = [] # noqa: E501 - - # urlopen optional setting - urlopen_kw = None - if 'urlopen_kw' in kwargs: - urlopen_kw = kwargs['urlopen_kw'] - - return self.api_client.call_api( - '/api/v2/orgs/{orgID}', 'DELETE', - path_params, - query_params, - header_params, - body=body_params, - post_params=form_params, - files=local_var_files, - response_type=None, # noqa: E501 - auth_settings=auth_settings, - async_req=local_var_params.get('async_req'), - _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 - _preload_content=local_var_params.get('_preload_content', True), - _request_timeout=local_var_params.get('_request_timeout'), - collection_formats=collection_formats, - urlopen_kw=urlopen_kw) + return local_var_params, path_params, query_params, header_params, body_params def delete_orgs_id_members_id(self, user_id, org_id, **kwargs): # noqa: E501,D401,D403 """Remove a member from an organization. @@ -175,23 +186,64 @@ def delete_orgs_id_members_id_with_http_info(self, user_id, org_id, **kwargs): If the method is called asynchronously, returns the request thread. """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._delete_orgs_id_members_id_prepare(user_id, org_id, **kwargs) + + return self.api_client.call_api( + '/api/v2/orgs/{orgID}/members/{userID}', 'DELETE', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type=None, # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + async def delete_orgs_id_members_id_async(self, user_id, org_id, **kwargs): # noqa: E501,D401,D403 + """Remove a member from an organization. + + This method makes an asynchronous HTTP request. + + :param async_req bool + :param str user_id: The ID of the member to remove. (required) + :param str org_id: The organization ID. (required) + :param str zap_trace_span: OpenTracing span context + :return: None + If the method is called asynchronously, + returns the request thread. + """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._delete_orgs_id_members_id_prepare(user_id, org_id, **kwargs) + + return await self.api_client.call_api( + '/api/v2/orgs/{orgID}/members/{userID}', 'DELETE', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type=None, # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + def _delete_orgs_id_members_id_prepare(self, user_id, org_id, **kwargs): # noqa: E501,D401,D403 local_var_params = locals() all_params = ['user_id', 'org_id', 'zap_trace_span'] # noqa: E501 - all_params.append('async_req') - all_params.append('_return_http_data_only') - all_params.append('_preload_content') - all_params.append('_request_timeout') - all_params.append('urlopen_kw') - - for key, val in six.iteritems(local_var_params['kwargs']): - if key not in all_params: - raise TypeError( - "Got an unexpected keyword argument '%s'" - " to method delete_orgs_id_members_id" % key - ) - local_var_params[key] = val - del local_var_params['kwargs'] + self._check_operation_params('delete_orgs_id_members_id', all_params, local_var_params) # verify the required parameter 'user_id' is set if ('user_id' not in local_var_params or local_var_params['user_id'] is None): @@ -201,8 +253,6 @@ def delete_orgs_id_members_id_with_http_info(self, user_id, org_id, **kwargs): local_var_params['org_id'] is None): raise ValueError("Missing the required parameter `org_id` when calling `delete_orgs_id_members_id`") # noqa: E501 - collection_formats = {} - path_params = {} if 'user_id' in local_var_params: path_params['userID'] = local_var_params['user_id'] # noqa: E501 @@ -215,38 +265,12 @@ def delete_orgs_id_members_id_with_http_info(self, user_id, org_id, **kwargs): if 'zap_trace_span' in local_var_params: header_params['Zap-Trace-Span'] = local_var_params['zap_trace_span'] # noqa: E501 - form_params = [] - local_var_files = {} - body_params = None # HTTP header `Accept` header_params['Accept'] = self.api_client.select_header_accept( ['application/json']) # noqa: E501 - # Authentication setting - auth_settings = [] # noqa: E501 - - # urlopen optional setting - urlopen_kw = None - if 'urlopen_kw' in kwargs: - urlopen_kw = kwargs['urlopen_kw'] - - return self.api_client.call_api( - '/api/v2/orgs/{orgID}/members/{userID}', 'DELETE', - path_params, - query_params, - header_params, - body=body_params, - post_params=form_params, - files=local_var_files, - response_type=None, # noqa: E501 - auth_settings=auth_settings, - async_req=local_var_params.get('async_req'), - _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 - _preload_content=local_var_params.get('_preload_content', True), - _request_timeout=local_var_params.get('_request_timeout'), - collection_formats=collection_formats, - urlopen_kw=urlopen_kw) + return local_var_params, path_params, query_params, header_params, body_params def delete_orgs_id_owners_id(self, user_id, org_id, **kwargs): # noqa: E501,D401,D403 """Remove an owner from an organization. @@ -287,23 +311,64 @@ def delete_orgs_id_owners_id_with_http_info(self, user_id, org_id, **kwargs): # If the method is called asynchronously, returns the request thread. """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._delete_orgs_id_owners_id_prepare(user_id, org_id, **kwargs) + + return self.api_client.call_api( + '/api/v2/orgs/{orgID}/owners/{userID}', 'DELETE', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type=None, # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + async def delete_orgs_id_owners_id_async(self, user_id, org_id, **kwargs): # noqa: E501,D401,D403 + """Remove an owner from an organization. + + This method makes an asynchronous HTTP request. + + :param async_req bool + :param str user_id: The ID of the owner to remove. (required) + :param str org_id: The organization ID. (required) + :param str zap_trace_span: OpenTracing span context + :return: None + If the method is called asynchronously, + returns the request thread. + """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._delete_orgs_id_owners_id_prepare(user_id, org_id, **kwargs) + + return await self.api_client.call_api( + '/api/v2/orgs/{orgID}/owners/{userID}', 'DELETE', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type=None, # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + def _delete_orgs_id_owners_id_prepare(self, user_id, org_id, **kwargs): # noqa: E501,D401,D403 local_var_params = locals() all_params = ['user_id', 'org_id', 'zap_trace_span'] # noqa: E501 - all_params.append('async_req') - all_params.append('_return_http_data_only') - all_params.append('_preload_content') - all_params.append('_request_timeout') - all_params.append('urlopen_kw') - - for key, val in six.iteritems(local_var_params['kwargs']): - if key not in all_params: - raise TypeError( - "Got an unexpected keyword argument '%s'" - " to method delete_orgs_id_owners_id" % key - ) - local_var_params[key] = val - del local_var_params['kwargs'] + self._check_operation_params('delete_orgs_id_owners_id', all_params, local_var_params) # verify the required parameter 'user_id' is set if ('user_id' not in local_var_params or local_var_params['user_id'] is None): @@ -313,8 +378,6 @@ def delete_orgs_id_owners_id_with_http_info(self, user_id, org_id, **kwargs): # local_var_params['org_id'] is None): raise ValueError("Missing the required parameter `org_id` when calling `delete_orgs_id_owners_id`") # noqa: E501 - collection_formats = {} - path_params = {} if 'user_id' in local_var_params: path_params['userID'] = local_var_params['user_id'] # noqa: E501 @@ -327,38 +390,12 @@ def delete_orgs_id_owners_id_with_http_info(self, user_id, org_id, **kwargs): # if 'zap_trace_span' in local_var_params: header_params['Zap-Trace-Span'] = local_var_params['zap_trace_span'] # noqa: E501 - form_params = [] - local_var_files = {} - body_params = None # HTTP header `Accept` header_params['Accept'] = self.api_client.select_header_accept( ['application/json']) # noqa: E501 - # Authentication setting - auth_settings = [] # noqa: E501 - - # urlopen optional setting - urlopen_kw = None - if 'urlopen_kw' in kwargs: - urlopen_kw = kwargs['urlopen_kw'] - - return self.api_client.call_api( - '/api/v2/orgs/{orgID}/owners/{userID}', 'DELETE', - path_params, - query_params, - header_params, - body=body_params, - post_params=form_params, - files=local_var_files, - response_type=None, # noqa: E501 - auth_settings=auth_settings, - async_req=local_var_params.get('async_req'), - _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 - _preload_content=local_var_params.get('_preload_content', True), - _request_timeout=local_var_params.get('_request_timeout'), - collection_formats=collection_formats, - urlopen_kw=urlopen_kw) + return local_var_params, path_params, query_params, header_params, body_params def get_orgs(self, **kwargs): # noqa: E501,D401,D403 """List all organizations. @@ -407,23 +444,68 @@ def get_orgs_with_http_info(self, **kwargs): # noqa: E501,D401,D403 If the method is called asynchronously, returns the request thread. """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._get_orgs_prepare(**kwargs) + + return self.api_client.call_api( + '/api/v2/orgs', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='Organizations', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + async def get_orgs_async(self, **kwargs): # noqa: E501,D401,D403 + """List all organizations. + + This method makes an asynchronous HTTP request. + + :param async_req bool + :param str zap_trace_span: OpenTracing span context + :param int offset: + :param int limit: + :param bool descending: + :param str org: Filter organizations to a specific organization name. + :param str org_id: Filter organizations to a specific organization ID. + :param str user_id: Filter organizations to a specific user ID. + :return: Organizations + If the method is called asynchronously, + returns the request thread. + """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._get_orgs_prepare(**kwargs) + + return await self.api_client.call_api( + '/api/v2/orgs', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='Organizations', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + def _get_orgs_prepare(self, **kwargs): # noqa: E501,D401,D403 local_var_params = locals() all_params = ['zap_trace_span', 'offset', 'limit', 'descending', 'org', 'org_id', 'user_id'] # noqa: E501 - all_params.append('async_req') - all_params.append('_return_http_data_only') - all_params.append('_preload_content') - all_params.append('_request_timeout') - all_params.append('urlopen_kw') - - for key, val in six.iteritems(local_var_params['kwargs']): - if key not in all_params: - raise TypeError( - "Got an unexpected keyword argument '%s'" - " to method get_orgs" % key - ) - local_var_params[key] = val - del local_var_params['kwargs'] + self._check_operation_params('get_orgs', all_params, local_var_params) if 'offset' in local_var_params and local_var_params['offset'] < 0: # noqa: E501 raise ValueError("Invalid value for parameter `offset` when calling `get_orgs`, must be a value greater than or equal to `0`") # noqa: E501 @@ -431,8 +513,6 @@ def get_orgs_with_http_info(self, **kwargs): # noqa: E501,D401,D403 raise ValueError("Invalid value for parameter `limit` when calling `get_orgs`, must be a value less than or equal to `100`") # noqa: E501 if 'limit' in local_var_params and local_var_params['limit'] < 1: # noqa: E501 raise ValueError("Invalid value for parameter `limit` when calling `get_orgs`, must be a value greater than or equal to `1`") # noqa: E501 - collection_formats = {} - path_params = {} query_params = [] @@ -453,38 +533,12 @@ def get_orgs_with_http_info(self, **kwargs): # noqa: E501,D401,D403 if 'zap_trace_span' in local_var_params: header_params['Zap-Trace-Span'] = local_var_params['zap_trace_span'] # noqa: E501 - form_params = [] - local_var_files = {} - body_params = None # HTTP header `Accept` header_params['Accept'] = self.api_client.select_header_accept( ['application/json']) # noqa: E501 - # Authentication setting - auth_settings = [] # noqa: E501 - - # urlopen optional setting - urlopen_kw = None - if 'urlopen_kw' in kwargs: - urlopen_kw = kwargs['urlopen_kw'] - - return self.api_client.call_api( - '/api/v2/orgs', 'GET', - path_params, - query_params, - header_params, - body=body_params, - post_params=form_params, - files=local_var_files, - response_type='Organizations', # noqa: E501 - auth_settings=auth_settings, - async_req=local_var_params.get('async_req'), - _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 - _preload_content=local_var_params.get('_preload_content', True), - _request_timeout=local_var_params.get('_request_timeout'), - collection_formats=collection_formats, - urlopen_kw=urlopen_kw) + return local_var_params, path_params, query_params, header_params, body_params def get_orgs_id(self, org_id, **kwargs): # noqa: E501,D401,D403 """Retrieve an organization. @@ -523,30 +577,68 @@ def get_orgs_id_with_http_info(self, org_id, **kwargs): # noqa: E501,D401,D403 If the method is called asynchronously, returns the request thread. """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._get_orgs_id_prepare(org_id, **kwargs) + + return self.api_client.call_api( + '/api/v2/orgs/{orgID}', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='Organization', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + async def get_orgs_id_async(self, org_id, **kwargs): # noqa: E501,D401,D403 + """Retrieve an organization. + + This method makes an asynchronous HTTP request. + + :param async_req bool + :param str org_id: The ID of the organization to get. (required) + :param str zap_trace_span: OpenTracing span context + :return: Organization + If the method is called asynchronously, + returns the request thread. + """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._get_orgs_id_prepare(org_id, **kwargs) + + return await self.api_client.call_api( + '/api/v2/orgs/{orgID}', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='Organization', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + def _get_orgs_id_prepare(self, org_id, **kwargs): # noqa: E501,D401,D403 local_var_params = locals() all_params = ['org_id', 'zap_trace_span'] # noqa: E501 - all_params.append('async_req') - all_params.append('_return_http_data_only') - all_params.append('_preload_content') - all_params.append('_request_timeout') - all_params.append('urlopen_kw') - - for key, val in six.iteritems(local_var_params['kwargs']): - if key not in all_params: - raise TypeError( - "Got an unexpected keyword argument '%s'" - " to method get_orgs_id" % key - ) - local_var_params[key] = val - del local_var_params['kwargs'] + self._check_operation_params('get_orgs_id', all_params, local_var_params) # verify the required parameter 'org_id' is set if ('org_id' not in local_var_params or local_var_params['org_id'] is None): raise ValueError("Missing the required parameter `org_id` when calling `get_orgs_id`") # noqa: E501 - collection_formats = {} - path_params = {} if 'org_id' in local_var_params: path_params['orgID'] = local_var_params['org_id'] # noqa: E501 @@ -557,38 +649,12 @@ def get_orgs_id_with_http_info(self, org_id, **kwargs): # noqa: E501,D401,D403 if 'zap_trace_span' in local_var_params: header_params['Zap-Trace-Span'] = local_var_params['zap_trace_span'] # noqa: E501 - form_params = [] - local_var_files = {} - body_params = None # HTTP header `Accept` header_params['Accept'] = self.api_client.select_header_accept( ['application/json']) # noqa: E501 - # Authentication setting - auth_settings = [] # noqa: E501 - - # urlopen optional setting - urlopen_kw = None - if 'urlopen_kw' in kwargs: - urlopen_kw = kwargs['urlopen_kw'] - - return self.api_client.call_api( - '/api/v2/orgs/{orgID}', 'GET', - path_params, - query_params, - header_params, - body=body_params, - post_params=form_params, - files=local_var_files, - response_type='Organization', # noqa: E501 - auth_settings=auth_settings, - async_req=local_var_params.get('async_req'), - _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 - _preload_content=local_var_params.get('_preload_content', True), - _request_timeout=local_var_params.get('_request_timeout'), - collection_formats=collection_formats, - urlopen_kw=urlopen_kw) + return local_var_params, path_params, query_params, header_params, body_params def get_orgs_id_members(self, org_id, **kwargs): # noqa: E501,D401,D403 """List all members of an organization. @@ -627,30 +693,68 @@ def get_orgs_id_members_with_http_info(self, org_id, **kwargs): # noqa: E501,D4 If the method is called asynchronously, returns the request thread. """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._get_orgs_id_members_prepare(org_id, **kwargs) + + return self.api_client.call_api( + '/api/v2/orgs/{orgID}/members', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='ResourceMembers', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + async def get_orgs_id_members_async(self, org_id, **kwargs): # noqa: E501,D401,D403 + """List all members of an organization. + + This method makes an asynchronous HTTP request. + + :param async_req bool + :param str org_id: The organization ID. (required) + :param str zap_trace_span: OpenTracing span context + :return: ResourceMembers + If the method is called asynchronously, + returns the request thread. + """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._get_orgs_id_members_prepare(org_id, **kwargs) + + return await self.api_client.call_api( + '/api/v2/orgs/{orgID}/members', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='ResourceMembers', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + def _get_orgs_id_members_prepare(self, org_id, **kwargs): # noqa: E501,D401,D403 local_var_params = locals() all_params = ['org_id', 'zap_trace_span'] # noqa: E501 - all_params.append('async_req') - all_params.append('_return_http_data_only') - all_params.append('_preload_content') - all_params.append('_request_timeout') - all_params.append('urlopen_kw') - - for key, val in six.iteritems(local_var_params['kwargs']): - if key not in all_params: - raise TypeError( - "Got an unexpected keyword argument '%s'" - " to method get_orgs_id_members" % key - ) - local_var_params[key] = val - del local_var_params['kwargs'] + self._check_operation_params('get_orgs_id_members', all_params, local_var_params) # verify the required parameter 'org_id' is set if ('org_id' not in local_var_params or local_var_params['org_id'] is None): raise ValueError("Missing the required parameter `org_id` when calling `get_orgs_id_members`") # noqa: E501 - collection_formats = {} - path_params = {} if 'org_id' in local_var_params: path_params['orgID'] = local_var_params['org_id'] # noqa: E501 @@ -661,38 +765,12 @@ def get_orgs_id_members_with_http_info(self, org_id, **kwargs): # noqa: E501,D4 if 'zap_trace_span' in local_var_params: header_params['Zap-Trace-Span'] = local_var_params['zap_trace_span'] # noqa: E501 - form_params = [] - local_var_files = {} - body_params = None # HTTP header `Accept` - header_params['Accept'] = self.api_client.select_header_accept( - ['application/json']) # noqa: E501 - - # Authentication setting - auth_settings = [] # noqa: E501 - - # urlopen optional setting - urlopen_kw = None - if 'urlopen_kw' in kwargs: - urlopen_kw = kwargs['urlopen_kw'] - - return self.api_client.call_api( - '/api/v2/orgs/{orgID}/members', 'GET', - path_params, - query_params, - header_params, - body=body_params, - post_params=form_params, - files=local_var_files, - response_type='ResourceMembers', # noqa: E501 - auth_settings=auth_settings, - async_req=local_var_params.get('async_req'), - _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 - _preload_content=local_var_params.get('_preload_content', True), - _request_timeout=local_var_params.get('_request_timeout'), - collection_formats=collection_formats, - urlopen_kw=urlopen_kw) + header_params['Accept'] = self.api_client.select_header_accept( + ['application/json']) # noqa: E501 + + return local_var_params, path_params, query_params, header_params, body_params def get_orgs_id_owners(self, org_id, **kwargs): # noqa: E501,D401,D403 """List all owners of an organization. @@ -731,30 +809,68 @@ def get_orgs_id_owners_with_http_info(self, org_id, **kwargs): # noqa: E501,D40 If the method is called asynchronously, returns the request thread. """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._get_orgs_id_owners_prepare(org_id, **kwargs) + + return self.api_client.call_api( + '/api/v2/orgs/{orgID}/owners', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='ResourceOwners', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + async def get_orgs_id_owners_async(self, org_id, **kwargs): # noqa: E501,D401,D403 + """List all owners of an organization. + + This method makes an asynchronous HTTP request. + + :param async_req bool + :param str org_id: The organization ID. (required) + :param str zap_trace_span: OpenTracing span context + :return: ResourceOwners + If the method is called asynchronously, + returns the request thread. + """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._get_orgs_id_owners_prepare(org_id, **kwargs) + + return await self.api_client.call_api( + '/api/v2/orgs/{orgID}/owners', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='ResourceOwners', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + def _get_orgs_id_owners_prepare(self, org_id, **kwargs): # noqa: E501,D401,D403 local_var_params = locals() all_params = ['org_id', 'zap_trace_span'] # noqa: E501 - all_params.append('async_req') - all_params.append('_return_http_data_only') - all_params.append('_preload_content') - all_params.append('_request_timeout') - all_params.append('urlopen_kw') - - for key, val in six.iteritems(local_var_params['kwargs']): - if key not in all_params: - raise TypeError( - "Got an unexpected keyword argument '%s'" - " to method get_orgs_id_owners" % key - ) - local_var_params[key] = val - del local_var_params['kwargs'] + self._check_operation_params('get_orgs_id_owners', all_params, local_var_params) # verify the required parameter 'org_id' is set if ('org_id' not in local_var_params or local_var_params['org_id'] is None): raise ValueError("Missing the required parameter `org_id` when calling `get_orgs_id_owners`") # noqa: E501 - collection_formats = {} - path_params = {} if 'org_id' in local_var_params: path_params['orgID'] = local_var_params['org_id'] # noqa: E501 @@ -765,38 +881,12 @@ def get_orgs_id_owners_with_http_info(self, org_id, **kwargs): # noqa: E501,D40 if 'zap_trace_span' in local_var_params: header_params['Zap-Trace-Span'] = local_var_params['zap_trace_span'] # noqa: E501 - form_params = [] - local_var_files = {} - body_params = None # HTTP header `Accept` header_params['Accept'] = self.api_client.select_header_accept( ['application/json']) # noqa: E501 - # Authentication setting - auth_settings = [] # noqa: E501 - - # urlopen optional setting - urlopen_kw = None - if 'urlopen_kw' in kwargs: - urlopen_kw = kwargs['urlopen_kw'] - - return self.api_client.call_api( - '/api/v2/orgs/{orgID}/owners', 'GET', - path_params, - query_params, - header_params, - body=body_params, - post_params=form_params, - files=local_var_files, - response_type='ResourceOwners', # noqa: E501 - auth_settings=auth_settings, - async_req=local_var_params.get('async_req'), - _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 - _preload_content=local_var_params.get('_preload_content', True), - _request_timeout=local_var_params.get('_request_timeout'), - collection_formats=collection_formats, - urlopen_kw=urlopen_kw) + return local_var_params, path_params, query_params, header_params, body_params def patch_orgs_id(self, org_id, patch_organization_request, **kwargs): # noqa: E501,D401,D403 """Update an organization. @@ -837,23 +927,64 @@ def patch_orgs_id_with_http_info(self, org_id, patch_organization_request, **kwa If the method is called asynchronously, returns the request thread. """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._patch_orgs_id_prepare(org_id, patch_organization_request, **kwargs) + + return self.api_client.call_api( + '/api/v2/orgs/{orgID}', 'PATCH', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='Organization', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + async def patch_orgs_id_async(self, org_id, patch_organization_request, **kwargs): # noqa: E501,D401,D403 + """Update an organization. + + This method makes an asynchronous HTTP request. + + :param async_req bool + :param str org_id: The ID of the organization to get. (required) + :param PatchOrganizationRequest patch_organization_request: Organization update to apply (required) + :param str zap_trace_span: OpenTracing span context + :return: Organization + If the method is called asynchronously, + returns the request thread. + """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._patch_orgs_id_prepare(org_id, patch_organization_request, **kwargs) + + return await self.api_client.call_api( + '/api/v2/orgs/{orgID}', 'PATCH', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='Organization', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + def _patch_orgs_id_prepare(self, org_id, patch_organization_request, **kwargs): # noqa: E501,D401,D403 local_var_params = locals() all_params = ['org_id', 'patch_organization_request', 'zap_trace_span'] # noqa: E501 - all_params.append('async_req') - all_params.append('_return_http_data_only') - all_params.append('_preload_content') - all_params.append('_request_timeout') - all_params.append('urlopen_kw') - - for key, val in six.iteritems(local_var_params['kwargs']): - if key not in all_params: - raise TypeError( - "Got an unexpected keyword argument '%s'" - " to method patch_orgs_id" % key - ) - local_var_params[key] = val - del local_var_params['kwargs'] + self._check_operation_params('patch_orgs_id', all_params, local_var_params) # verify the required parameter 'org_id' is set if ('org_id' not in local_var_params or local_var_params['org_id'] is None): @@ -863,8 +994,6 @@ def patch_orgs_id_with_http_info(self, org_id, patch_organization_request, **kwa local_var_params['patch_organization_request'] is None): raise ValueError("Missing the required parameter `patch_organization_request` when calling `patch_orgs_id`") # noqa: E501 - collection_formats = {} - path_params = {} if 'org_id' in local_var_params: path_params['orgID'] = local_var_params['org_id'] # noqa: E501 @@ -875,9 +1004,6 @@ def patch_orgs_id_with_http_info(self, org_id, patch_organization_request, **kwa if 'zap_trace_span' in local_var_params: header_params['Zap-Trace-Span'] = local_var_params['zap_trace_span'] # noqa: E501 - form_params = [] - local_var_files = {} - body_params = None if 'patch_organization_request' in local_var_params: body_params = local_var_params['patch_organization_request'] @@ -889,30 +1015,7 @@ def patch_orgs_id_with_http_info(self, org_id, patch_organization_request, **kwa header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501 ['application/json']) # noqa: E501 - # Authentication setting - auth_settings = [] # noqa: E501 - - # urlopen optional setting - urlopen_kw = None - if 'urlopen_kw' in kwargs: - urlopen_kw = kwargs['urlopen_kw'] - - return self.api_client.call_api( - '/api/v2/orgs/{orgID}', 'PATCH', - path_params, - query_params, - header_params, - body=body_params, - post_params=form_params, - files=local_var_files, - response_type='Organization', # noqa: E501 - auth_settings=auth_settings, - async_req=local_var_params.get('async_req'), - _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 - _preload_content=local_var_params.get('_preload_content', True), - _request_timeout=local_var_params.get('_request_timeout'), - collection_formats=collection_formats, - urlopen_kw=urlopen_kw) + return local_var_params, path_params, query_params, header_params, body_params def post_orgs(self, post_organization_request, **kwargs): # noqa: E501,D401,D403 """Create an organization. @@ -951,30 +1054,68 @@ def post_orgs_with_http_info(self, post_organization_request, **kwargs): # noqa If the method is called asynchronously, returns the request thread. """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._post_orgs_prepare(post_organization_request, **kwargs) + + return self.api_client.call_api( + '/api/v2/orgs', 'POST', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='Organization', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + async def post_orgs_async(self, post_organization_request, **kwargs): # noqa: E501,D401,D403 + """Create an organization. + + This method makes an asynchronous HTTP request. + + :param async_req bool + :param PostOrganizationRequest post_organization_request: Organization to create (required) + :param str zap_trace_span: OpenTracing span context + :return: Organization + If the method is called asynchronously, + returns the request thread. + """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._post_orgs_prepare(post_organization_request, **kwargs) + + return await self.api_client.call_api( + '/api/v2/orgs', 'POST', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='Organization', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + def _post_orgs_prepare(self, post_organization_request, **kwargs): # noqa: E501,D401,D403 local_var_params = locals() all_params = ['post_organization_request', 'zap_trace_span'] # noqa: E501 - all_params.append('async_req') - all_params.append('_return_http_data_only') - all_params.append('_preload_content') - all_params.append('_request_timeout') - all_params.append('urlopen_kw') - - for key, val in six.iteritems(local_var_params['kwargs']): - if key not in all_params: - raise TypeError( - "Got an unexpected keyword argument '%s'" - " to method post_orgs" % key - ) - local_var_params[key] = val - del local_var_params['kwargs'] + self._check_operation_params('post_orgs', all_params, local_var_params) # verify the required parameter 'post_organization_request' is set if ('post_organization_request' not in local_var_params or local_var_params['post_organization_request'] is None): raise ValueError("Missing the required parameter `post_organization_request` when calling `post_orgs`") # noqa: E501 - collection_formats = {} - path_params = {} query_params = [] @@ -983,9 +1124,6 @@ def post_orgs_with_http_info(self, post_organization_request, **kwargs): # noqa if 'zap_trace_span' in local_var_params: header_params['Zap-Trace-Span'] = local_var_params['zap_trace_span'] # noqa: E501 - form_params = [] - local_var_files = {} - body_params = None if 'post_organization_request' in local_var_params: body_params = local_var_params['post_organization_request'] @@ -997,30 +1135,7 @@ def post_orgs_with_http_info(self, post_organization_request, **kwargs): # noqa header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501 ['application/json']) # noqa: E501 - # Authentication setting - auth_settings = [] # noqa: E501 - - # urlopen optional setting - urlopen_kw = None - if 'urlopen_kw' in kwargs: - urlopen_kw = kwargs['urlopen_kw'] - - return self.api_client.call_api( - '/api/v2/orgs', 'POST', - path_params, - query_params, - header_params, - body=body_params, - post_params=form_params, - files=local_var_files, - response_type='Organization', # noqa: E501 - auth_settings=auth_settings, - async_req=local_var_params.get('async_req'), - _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 - _preload_content=local_var_params.get('_preload_content', True), - _request_timeout=local_var_params.get('_request_timeout'), - collection_formats=collection_formats, - urlopen_kw=urlopen_kw) + return local_var_params, path_params, query_params, header_params, body_params def post_orgs_id_members(self, org_id, add_resource_member_request_body, **kwargs): # noqa: E501,D401,D403 """Add a member to an organization. @@ -1061,23 +1176,64 @@ def post_orgs_id_members_with_http_info(self, org_id, add_resource_member_reques If the method is called asynchronously, returns the request thread. """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._post_orgs_id_members_prepare(org_id, add_resource_member_request_body, **kwargs) + + return self.api_client.call_api( + '/api/v2/orgs/{orgID}/members', 'POST', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='ResourceMember', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + async def post_orgs_id_members_async(self, org_id, add_resource_member_request_body, **kwargs): # noqa: E501,D401,D403 + """Add a member to an organization. + + This method makes an asynchronous HTTP request. + + :param async_req bool + :param str org_id: The organization ID. (required) + :param AddResourceMemberRequestBody add_resource_member_request_body: User to add as member (required) + :param str zap_trace_span: OpenTracing span context + :return: ResourceMember + If the method is called asynchronously, + returns the request thread. + """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._post_orgs_id_members_prepare(org_id, add_resource_member_request_body, **kwargs) + + return await self.api_client.call_api( + '/api/v2/orgs/{orgID}/members', 'POST', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='ResourceMember', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + def _post_orgs_id_members_prepare(self, org_id, add_resource_member_request_body, **kwargs): # noqa: E501,D401,D403 local_var_params = locals() all_params = ['org_id', 'add_resource_member_request_body', 'zap_trace_span'] # noqa: E501 - all_params.append('async_req') - all_params.append('_return_http_data_only') - all_params.append('_preload_content') - all_params.append('_request_timeout') - all_params.append('urlopen_kw') - - for key, val in six.iteritems(local_var_params['kwargs']): - if key not in all_params: - raise TypeError( - "Got an unexpected keyword argument '%s'" - " to method post_orgs_id_members" % key - ) - local_var_params[key] = val - del local_var_params['kwargs'] + self._check_operation_params('post_orgs_id_members', all_params, local_var_params) # verify the required parameter 'org_id' is set if ('org_id' not in local_var_params or local_var_params['org_id'] is None): @@ -1087,8 +1243,6 @@ def post_orgs_id_members_with_http_info(self, org_id, add_resource_member_reques local_var_params['add_resource_member_request_body'] is None): raise ValueError("Missing the required parameter `add_resource_member_request_body` when calling `post_orgs_id_members`") # noqa: E501 - collection_formats = {} - path_params = {} if 'org_id' in local_var_params: path_params['orgID'] = local_var_params['org_id'] # noqa: E501 @@ -1099,9 +1253,6 @@ def post_orgs_id_members_with_http_info(self, org_id, add_resource_member_reques if 'zap_trace_span' in local_var_params: header_params['Zap-Trace-Span'] = local_var_params['zap_trace_span'] # noqa: E501 - form_params = [] - local_var_files = {} - body_params = None if 'add_resource_member_request_body' in local_var_params: body_params = local_var_params['add_resource_member_request_body'] @@ -1113,30 +1264,7 @@ def post_orgs_id_members_with_http_info(self, org_id, add_resource_member_reques header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501 ['application/json']) # noqa: E501 - # Authentication setting - auth_settings = [] # noqa: E501 - - # urlopen optional setting - urlopen_kw = None - if 'urlopen_kw' in kwargs: - urlopen_kw = kwargs['urlopen_kw'] - - return self.api_client.call_api( - '/api/v2/orgs/{orgID}/members', 'POST', - path_params, - query_params, - header_params, - body=body_params, - post_params=form_params, - files=local_var_files, - response_type='ResourceMember', # noqa: E501 - auth_settings=auth_settings, - async_req=local_var_params.get('async_req'), - _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 - _preload_content=local_var_params.get('_preload_content', True), - _request_timeout=local_var_params.get('_request_timeout'), - collection_formats=collection_formats, - urlopen_kw=urlopen_kw) + return local_var_params, path_params, query_params, header_params, body_params def post_orgs_id_owners(self, org_id, add_resource_member_request_body, **kwargs): # noqa: E501,D401,D403 """Add an owner to an organization. @@ -1177,23 +1305,64 @@ def post_orgs_id_owners_with_http_info(self, org_id, add_resource_member_request If the method is called asynchronously, returns the request thread. """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._post_orgs_id_owners_prepare(org_id, add_resource_member_request_body, **kwargs) + + return self.api_client.call_api( + '/api/v2/orgs/{orgID}/owners', 'POST', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='ResourceOwner', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + async def post_orgs_id_owners_async(self, org_id, add_resource_member_request_body, **kwargs): # noqa: E501,D401,D403 + """Add an owner to an organization. + + This method makes an asynchronous HTTP request. + + :param async_req bool + :param str org_id: The organization ID. (required) + :param AddResourceMemberRequestBody add_resource_member_request_body: User to add as owner (required) + :param str zap_trace_span: OpenTracing span context + :return: ResourceOwner + If the method is called asynchronously, + returns the request thread. + """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._post_orgs_id_owners_prepare(org_id, add_resource_member_request_body, **kwargs) + + return await self.api_client.call_api( + '/api/v2/orgs/{orgID}/owners', 'POST', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='ResourceOwner', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + def _post_orgs_id_owners_prepare(self, org_id, add_resource_member_request_body, **kwargs): # noqa: E501,D401,D403 local_var_params = locals() all_params = ['org_id', 'add_resource_member_request_body', 'zap_trace_span'] # noqa: E501 - all_params.append('async_req') - all_params.append('_return_http_data_only') - all_params.append('_preload_content') - all_params.append('_request_timeout') - all_params.append('urlopen_kw') - - for key, val in six.iteritems(local_var_params['kwargs']): - if key not in all_params: - raise TypeError( - "Got an unexpected keyword argument '%s'" - " to method post_orgs_id_owners" % key - ) - local_var_params[key] = val - del local_var_params['kwargs'] + self._check_operation_params('post_orgs_id_owners', all_params, local_var_params) # verify the required parameter 'org_id' is set if ('org_id' not in local_var_params or local_var_params['org_id'] is None): @@ -1203,8 +1372,6 @@ def post_orgs_id_owners_with_http_info(self, org_id, add_resource_member_request local_var_params['add_resource_member_request_body'] is None): raise ValueError("Missing the required parameter `add_resource_member_request_body` when calling `post_orgs_id_owners`") # noqa: E501 - collection_formats = {} - path_params = {} if 'org_id' in local_var_params: path_params['orgID'] = local_var_params['org_id'] # noqa: E501 @@ -1215,9 +1382,6 @@ def post_orgs_id_owners_with_http_info(self, org_id, add_resource_member_request if 'zap_trace_span' in local_var_params: header_params['Zap-Trace-Span'] = local_var_params['zap_trace_span'] # noqa: E501 - form_params = [] - local_var_files = {} - body_params = None if 'add_resource_member_request_body' in local_var_params: body_params = local_var_params['add_resource_member_request_body'] @@ -1229,27 +1393,4 @@ def post_orgs_id_owners_with_http_info(self, org_id, add_resource_member_request header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501 ['application/json']) # noqa: E501 - # Authentication setting - auth_settings = [] # noqa: E501 - - # urlopen optional setting - urlopen_kw = None - if 'urlopen_kw' in kwargs: - urlopen_kw = kwargs['urlopen_kw'] - - return self.api_client.call_api( - '/api/v2/orgs/{orgID}/owners', 'POST', - path_params, - query_params, - header_params, - body=body_params, - post_params=form_params, - files=local_var_files, - response_type='ResourceOwner', # noqa: E501 - auth_settings=auth_settings, - async_req=local_var_params.get('async_req'), - _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 - _preload_content=local_var_params.get('_preload_content', True), - _request_timeout=local_var_params.get('_request_timeout'), - collection_formats=collection_formats, - urlopen_kw=urlopen_kw) + return local_var_params, path_params, query_params, header_params, body_params diff --git a/influxdb_client/service/ping_service.py b/influxdb_client/service/ping_service.py index 41e74e2a..05b5b9a1 100644 --- a/influxdb_client/service/ping_service.py +++ b/influxdb_client/service/ping_service.py @@ -14,11 +14,10 @@ import re # noqa: F401 -# python 2 and python 3 compatibility library -import six +from influxdb_client.service._base_service import _BaseService -class PingService(object): +class PingService(_BaseService): """NOTE: This class is auto generated by OpenAPI Generator. Ref: https://openapi-generator.tech @@ -65,43 +64,8 @@ def get_ping_with_http_info(self, **kwargs): # noqa: E501,D401,D403 If the method is called asynchronously, returns the request thread. """ # noqa: E501 - local_var_params = locals() - - all_params = [] # noqa: E501 - all_params.append('async_req') - all_params.append('_return_http_data_only') - all_params.append('_preload_content') - all_params.append('_request_timeout') - all_params.append('urlopen_kw') - - for key, val in six.iteritems(local_var_params['kwargs']): - if key not in all_params: - raise TypeError( - "Got an unexpected keyword argument '%s'" - " to method get_ping" % key - ) - local_var_params[key] = val - del local_var_params['kwargs'] - - collection_formats = {} - - path_params = {} - - query_params = [] - - header_params = {} - - form_params = [] - local_var_files = {} - - body_params = None - # Authentication setting - auth_settings = [] # noqa: E501 - - # urlopen optional setting - urlopen_kw = None - if 'urlopen_kw' in kwargs: - urlopen_kw = kwargs['urlopen_kw'] + local_var_params, path_params, query_params, header_params, body_params = \ + self._get_ping_prepare(**kwargs) return self.api_client.call_api( '/ping', 'GET', @@ -109,67 +73,29 @@ def get_ping_with_http_info(self, **kwargs): # noqa: E501,D401,D403 query_params, header_params, body=body_params, - post_params=form_params, - files=local_var_files, + post_params=[], + files={}, response_type=None, # noqa: E501 - auth_settings=auth_settings, + auth_settings=[], async_req=local_var_params.get('async_req'), _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 _preload_content=local_var_params.get('_preload_content', True), _request_timeout=local_var_params.get('_request_timeout'), - collection_formats=collection_formats, - urlopen_kw=urlopen_kw) + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) async def get_ping_async(self, **kwargs): # noqa: E501,D401,D403 """Checks the status of InfluxDB instance and version of InfluxDB.. - This method makes a synchronous HTTP request by default. To make an - asynchronous HTTP request, please pass async_req=True - >>> thread = api.get_ping_with_http_info(async_req=True) - >>> result = thread.get() + This method makes an asynchronous HTTP request. :param async_req bool :return: None If the method is called asynchronously, returns the request thread. """ # noqa: E501 - local_var_params = locals() - - all_params = [] # noqa: E501 - all_params.append('async_req') - all_params.append('_return_http_data_only') - all_params.append('_preload_content') - all_params.append('_request_timeout') - all_params.append('urlopen_kw') - - for key, val in six.iteritems(local_var_params['kwargs']): - if key not in all_params: - raise TypeError( - "Got an unexpected keyword argument '%s'" - " to method get_ping" % key - ) - local_var_params[key] = val - del local_var_params['kwargs'] - - collection_formats = {} - - path_params = {} - - query_params = [] - - header_params = {} - - form_params = [] - local_var_files = {} - - body_params = None - # Authentication setting - auth_settings = [] # noqa: E501 - - # urlopen optional setting - urlopen_kw = None - if 'urlopen_kw' in kwargs: - urlopen_kw = kwargs['urlopen_kw'] + local_var_params, path_params, query_params, header_params, body_params = \ + self._get_ping_prepare(**kwargs) return await self.api_client.call_api( '/ping', 'GET', @@ -177,16 +103,31 @@ async def get_ping_async(self, **kwargs): # noqa: E501,D401,D403 query_params, header_params, body=body_params, - post_params=form_params, - files=local_var_files, + post_params=[], + files={}, response_type=None, # noqa: E501 - auth_settings=auth_settings, + auth_settings=[], async_req=local_var_params.get('async_req'), _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 _preload_content=local_var_params.get('_preload_content', True), _request_timeout=local_var_params.get('_request_timeout'), - collection_formats=collection_formats, - urlopen_kw=urlopen_kw) + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + def _get_ping_prepare(self, **kwargs): # noqa: E501,D401,D403 + local_var_params = locals() + + all_params = [] # noqa: E501 + self._check_operation_params('get_ping', all_params, local_var_params) + + path_params = {} + + query_params = [] + + header_params = {} + + body_params = None + return local_var_params, path_params, query_params, header_params, body_params def head_ping(self, **kwargs): # noqa: E501,D401,D403 """Checks the status of InfluxDB instance and version of InfluxDB.. @@ -221,57 +162,67 @@ def head_ping_with_http_info(self, **kwargs): # noqa: E501,D401,D403 If the method is called asynchronously, returns the request thread. """ # noqa: E501 - local_var_params = locals() - - all_params = [] # noqa: E501 - all_params.append('async_req') - all_params.append('_return_http_data_only') - all_params.append('_preload_content') - all_params.append('_request_timeout') - all_params.append('urlopen_kw') - - for key, val in six.iteritems(local_var_params['kwargs']): - if key not in all_params: - raise TypeError( - "Got an unexpected keyword argument '%s'" - " to method head_ping" % key - ) - local_var_params[key] = val - del local_var_params['kwargs'] - - collection_formats = {} - - path_params = {} + local_var_params, path_params, query_params, header_params, body_params = \ + self._head_ping_prepare(**kwargs) - query_params = [] + return self.api_client.call_api( + '/ping', 'HEAD', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type=None, # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) - header_params = {} + async def head_ping_async(self, **kwargs): # noqa: E501,D401,D403 + """Checks the status of InfluxDB instance and version of InfluxDB.. - form_params = [] - local_var_files = {} + This method makes an asynchronous HTTP request. - body_params = None - # Authentication setting - auth_settings = [] # noqa: E501 - - # urlopen optional setting - urlopen_kw = None - if 'urlopen_kw' in kwargs: - urlopen_kw = kwargs['urlopen_kw'] + :param async_req bool + :return: None + If the method is called asynchronously, + returns the request thread. + """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._head_ping_prepare(**kwargs) - return self.api_client.call_api( + return await self.api_client.call_api( '/ping', 'HEAD', path_params, query_params, header_params, body=body_params, - post_params=form_params, - files=local_var_files, + post_params=[], + files={}, response_type=None, # noqa: E501 - auth_settings=auth_settings, + auth_settings=[], async_req=local_var_params.get('async_req'), _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 _preload_content=local_var_params.get('_preload_content', True), _request_timeout=local_var_params.get('_request_timeout'), - collection_formats=collection_formats, - urlopen_kw=urlopen_kw) + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + def _head_ping_prepare(self, **kwargs): # noqa: E501,D401,D403 + local_var_params = locals() + + all_params = [] # noqa: E501 + self._check_operation_params('head_ping', all_params, local_var_params) + + path_params = {} + + query_params = [] + + header_params = {} + + body_params = None + return local_var_params, path_params, query_params, header_params, body_params diff --git a/influxdb_client/service/query_service.py b/influxdb_client/service/query_service.py index b5632473..c55170b4 100644 --- a/influxdb_client/service/query_service.py +++ b/influxdb_client/service/query_service.py @@ -14,11 +14,10 @@ import re # noqa: F401 -# python 2 and python 3 compatibility library -import six +from influxdb_client.service._base_service import _BaseService -class QueryService(object): +class QueryService(_BaseService): """NOTE: This class is auto generated by OpenAPI Generator. Ref: https://openapi-generator.tech @@ -67,25 +66,62 @@ def get_query_suggestions_with_http_info(self, **kwargs): # noqa: E501,D401,D40 If the method is called asynchronously, returns the request thread. """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._get_query_suggestions_prepare(**kwargs) + + return self.api_client.call_api( + '/api/v2/query/suggestions', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='FluxSuggestions', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + async def get_query_suggestions_async(self, **kwargs): # noqa: E501,D401,D403 + """Retrieve query suggestions. + + This method makes an asynchronous HTTP request. + + :param async_req bool + :param str zap_trace_span: OpenTracing span context + :return: FluxSuggestions + If the method is called asynchronously, + returns the request thread. + """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._get_query_suggestions_prepare(**kwargs) + + return await self.api_client.call_api( + '/api/v2/query/suggestions', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='FluxSuggestions', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + def _get_query_suggestions_prepare(self, **kwargs): # noqa: E501,D401,D403 local_var_params = locals() all_params = ['zap_trace_span'] # noqa: E501 - all_params.append('async_req') - all_params.append('_return_http_data_only') - all_params.append('_preload_content') - all_params.append('_request_timeout') - all_params.append('urlopen_kw') - - for key, val in six.iteritems(local_var_params['kwargs']): - if key not in all_params: - raise TypeError( - "Got an unexpected keyword argument '%s'" - " to method get_query_suggestions" % key - ) - local_var_params[key] = val - del local_var_params['kwargs'] - - collection_formats = {} + self._check_operation_params('get_query_suggestions', all_params, local_var_params) path_params = {} @@ -95,38 +131,12 @@ def get_query_suggestions_with_http_info(self, **kwargs): # noqa: E501,D401,D40 if 'zap_trace_span' in local_var_params: header_params['Zap-Trace-Span'] = local_var_params['zap_trace_span'] # noqa: E501 - form_params = [] - local_var_files = {} - body_params = None # HTTP header `Accept` header_params['Accept'] = self.api_client.select_header_accept( ['application/json']) # noqa: E501 - # Authentication setting - auth_settings = [] # noqa: E501 - - # urlopen optional setting - urlopen_kw = None - if 'urlopen_kw' in kwargs: - urlopen_kw = kwargs['urlopen_kw'] - - return self.api_client.call_api( - '/api/v2/query/suggestions', 'GET', - path_params, - query_params, - header_params, - body=body_params, - post_params=form_params, - files=local_var_files, - response_type='FluxSuggestions', # noqa: E501 - auth_settings=auth_settings, - async_req=local_var_params.get('async_req'), - _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 - _preload_content=local_var_params.get('_preload_content', True), - _request_timeout=local_var_params.get('_request_timeout'), - collection_formats=collection_formats, - urlopen_kw=urlopen_kw) + return local_var_params, path_params, query_params, header_params, body_params def get_query_suggestions_name(self, name, **kwargs): # noqa: E501,D401,D403 """Retrieve query suggestions for a branching suggestion. @@ -165,30 +175,68 @@ def get_query_suggestions_name_with_http_info(self, name, **kwargs): # noqa: E5 If the method is called asynchronously, returns the request thread. """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._get_query_suggestions_name_prepare(name, **kwargs) + + return self.api_client.call_api( + '/api/v2/query/suggestions/{name}', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='FluxSuggestion', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + async def get_query_suggestions_name_async(self, name, **kwargs): # noqa: E501,D401,D403 + """Retrieve query suggestions for a branching suggestion. + + This method makes an asynchronous HTTP request. + + :param async_req bool + :param str name: The name of the branching suggestion. (required) + :param str zap_trace_span: OpenTracing span context + :return: FluxSuggestion + If the method is called asynchronously, + returns the request thread. + """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._get_query_suggestions_name_prepare(name, **kwargs) + + return await self.api_client.call_api( + '/api/v2/query/suggestions/{name}', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='FluxSuggestion', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + def _get_query_suggestions_name_prepare(self, name, **kwargs): # noqa: E501,D401,D403 local_var_params = locals() all_params = ['name', 'zap_trace_span'] # noqa: E501 - all_params.append('async_req') - all_params.append('_return_http_data_only') - all_params.append('_preload_content') - all_params.append('_request_timeout') - all_params.append('urlopen_kw') - - for key, val in six.iteritems(local_var_params['kwargs']): - if key not in all_params: - raise TypeError( - "Got an unexpected keyword argument '%s'" - " to method get_query_suggestions_name" % key - ) - local_var_params[key] = val - del local_var_params['kwargs'] + self._check_operation_params('get_query_suggestions_name', all_params, local_var_params) # verify the required parameter 'name' is set if ('name' not in local_var_params or local_var_params['name'] is None): raise ValueError("Missing the required parameter `name` when calling `get_query_suggestions_name`") # noqa: E501 - collection_formats = {} - path_params = {} if 'name' in local_var_params: path_params['name'] = local_var_params['name'] # noqa: E501 @@ -199,38 +247,12 @@ def get_query_suggestions_name_with_http_info(self, name, **kwargs): # noqa: E5 if 'zap_trace_span' in local_var_params: header_params['Zap-Trace-Span'] = local_var_params['zap_trace_span'] # noqa: E501 - form_params = [] - local_var_files = {} - body_params = None # HTTP header `Accept` header_params['Accept'] = self.api_client.select_header_accept( ['application/json']) # noqa: E501 - # Authentication setting - auth_settings = [] # noqa: E501 - - # urlopen optional setting - urlopen_kw = None - if 'urlopen_kw' in kwargs: - urlopen_kw = kwargs['urlopen_kw'] - - return self.api_client.call_api( - '/api/v2/query/suggestions/{name}', 'GET', - path_params, - query_params, - header_params, - body=body_params, - post_params=form_params, - files=local_var_files, - response_type='FluxSuggestion', # noqa: E501 - auth_settings=auth_settings, - async_req=local_var_params.get('async_req'), - _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 - _preload_content=local_var_params.get('_preload_content', True), - _request_timeout=local_var_params.get('_request_timeout'), - collection_formats=collection_formats, - urlopen_kw=urlopen_kw) + return local_var_params, path_params, query_params, header_params, body_params def post_query(self, **kwargs): # noqa: E501,D401,D403 """Query data. @@ -279,63 +301,8 @@ def post_query_with_http_info(self, **kwargs): # noqa: E501,D401,D403 If the method is called asynchronously, returns the request thread. """ # noqa: E501 - local_var_params = locals() - - all_params = ['zap_trace_span', 'accept_encoding', 'content_type', 'org', 'org_id', 'query'] # noqa: E501 - all_params.append('async_req') - all_params.append('_return_http_data_only') - all_params.append('_preload_content') - all_params.append('_request_timeout') - all_params.append('urlopen_kw') - - for key, val in six.iteritems(local_var_params['kwargs']): - if key not in all_params: - raise TypeError( - "Got an unexpected keyword argument '%s'" - " to method post_query" % key - ) - local_var_params[key] = val - del local_var_params['kwargs'] - - collection_formats = {} - - path_params = {} - - query_params = [] - if 'org' in local_var_params: - query_params.append(('org', local_var_params['org'])) # noqa: E501 - if 'org_id' in local_var_params: - query_params.append(('orgID', local_var_params['org_id'])) # noqa: E501 - - header_params = {} - if 'zap_trace_span' in local_var_params: - header_params['Zap-Trace-Span'] = local_var_params['zap_trace_span'] # noqa: E501 - if 'accept_encoding' in local_var_params: - header_params['Accept-Encoding'] = local_var_params['accept_encoding'] # noqa: E501 - if 'content_type' in local_var_params: - header_params['Content-Type'] = local_var_params['content_type'] # noqa: E501 - - form_params = [] - local_var_files = {} - - body_params = None - if 'query' in local_var_params: - body_params = local_var_params['query'] - # HTTP header `Accept` - header_params['Accept'] = self.api_client.select_header_accept( - ['text/csv', 'application/vnd.influx.arrow', 'application/json']) # noqa: E501 - - # HTTP header `Content-Type` - header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501 - ['application/json', 'application/vnd.flux']) # noqa: E501 - - # Authentication setting - auth_settings = [] # noqa: E501 - - # urlopen optional setting - urlopen_kw = None - if 'urlopen_kw' in kwargs: - urlopen_kw = kwargs['urlopen_kw'] + local_var_params, path_params, query_params, header_params, body_params = \ + self._post_query_prepare(**kwargs) return self.api_client.call_api( '/api/v2/query', 'POST', @@ -343,25 +310,22 @@ def post_query_with_http_info(self, **kwargs): # noqa: E501,D401,D403 query_params, header_params, body=body_params, - post_params=form_params, - files=local_var_files, + post_params=[], + files={}, response_type='str', # noqa: E501 - auth_settings=auth_settings, + auth_settings=[], async_req=local_var_params.get('async_req'), _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 _preload_content=local_var_params.get('_preload_content', True), _request_timeout=local_var_params.get('_request_timeout'), - collection_formats=collection_formats, - urlopen_kw=urlopen_kw) + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) async def post_query_async(self, **kwargs): # noqa: E501,D401,D403 """Query data. Retrieves data from InfluxDB buckets. To query data, you need the following: - **organization** – _See [View organizations](https://docs.influxdata.com/influxdb/v2.1/organizations/view-orgs/#view-your-organization-id) for instructions on viewing your organization ID._ - **API token** – _See [View tokens](https://docs.influxdata.com/influxdb/v2.1/security/tokens/view-tokens/) for instructions on viewing your API token._ - **InfluxDB URL** – _See [InfluxDB URLs](https://docs.influxdata.com/influxdb/v2.1/reference/urls/)_. - **Flux query** – _See [Flux](https://docs.influxdata.com/flux/v0.x/)._ For more information and examples, see [Query with the InfluxDB API](https://docs.influxdata.com/influxdb/v2.1/query-data/execute-queries/influx-api/). - This method makes a synchronous HTTP request by default. To make an - asynchronous HTTP request, please pass async_req=True - >>> thread = api.post_query_with_http_info(async_req=True) - >>> result = thread.get() + This method makes an asynchronous HTTP request. :param async_req bool :param str zap_trace_span: OpenTracing span context @@ -374,25 +338,31 @@ async def post_query_async(self, **kwargs): # noqa: E501,D401,D403 If the method is called asynchronously, returns the request thread. """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._post_query_prepare(**kwargs) + + return await self.api_client.call_api( + '/api/v2/query', 'POST', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='str', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + def _post_query_prepare(self, **kwargs): # noqa: E501,D401,D403 local_var_params = locals() all_params = ['zap_trace_span', 'accept_encoding', 'content_type', 'org', 'org_id', 'query'] # noqa: E501 - all_params.append('async_req') - all_params.append('_return_http_data_only') - all_params.append('_preload_content') - all_params.append('_request_timeout') - all_params.append('urlopen_kw') - - for key, val in six.iteritems(local_var_params['kwargs']): - if key not in all_params: - raise TypeError( - "Got an unexpected keyword argument '%s'" - " to method post_query" % key - ) - local_var_params[key] = val - del local_var_params['kwargs'] - - collection_formats = {} + self._check_operation_params('post_query', all_params, local_var_params) path_params = {} @@ -410,9 +380,6 @@ async def post_query_async(self, **kwargs): # noqa: E501,D401,D403 if 'content_type' in local_var_params: header_params['Content-Type'] = local_var_params['content_type'] # noqa: E501 - form_params = [] - local_var_files = {} - body_params = None if 'query' in local_var_params: body_params = local_var_params['query'] @@ -424,30 +391,7 @@ async def post_query_async(self, **kwargs): # noqa: E501,D401,D403 header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501 ['application/json', 'application/vnd.flux']) # noqa: E501 - # Authentication setting - auth_settings = [] # noqa: E501 - - # urlopen optional setting - urlopen_kw = None - if 'urlopen_kw' in kwargs: - urlopen_kw = kwargs['urlopen_kw'] - - return await self.api_client.call_api( - '/api/v2/query', 'POST', - path_params, - query_params, - header_params, - body=body_params, - post_params=form_params, - files=local_var_files, - response_type='str', # noqa: E501 - auth_settings=auth_settings, - async_req=local_var_params.get('async_req'), - _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 - _preload_content=local_var_params.get('_preload_content', True), - _request_timeout=local_var_params.get('_request_timeout'), - collection_formats=collection_formats, - urlopen_kw=urlopen_kw) + return local_var_params, path_params, query_params, header_params, body_params def post_query_analyze(self, **kwargs): # noqa: E501,D401,D403 """Analyze a Flux query. @@ -488,25 +432,64 @@ def post_query_analyze_with_http_info(self, **kwargs): # noqa: E501,D401,D403 If the method is called asynchronously, returns the request thread. """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._post_query_analyze_prepare(**kwargs) + + return self.api_client.call_api( + '/api/v2/query/analyze', 'POST', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='AnalyzeQueryResponse', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + async def post_query_analyze_async(self, **kwargs): # noqa: E501,D401,D403 + """Analyze a Flux query. + + This method makes an asynchronous HTTP request. + + :param async_req bool + :param str zap_trace_span: OpenTracing span context + :param str content_type: + :param Query query: Flux query to analyze + :return: AnalyzeQueryResponse + If the method is called asynchronously, + returns the request thread. + """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._post_query_analyze_prepare(**kwargs) + + return await self.api_client.call_api( + '/api/v2/query/analyze', 'POST', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='AnalyzeQueryResponse', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + def _post_query_analyze_prepare(self, **kwargs): # noqa: E501,D401,D403 local_var_params = locals() all_params = ['zap_trace_span', 'content_type', 'query'] # noqa: E501 - all_params.append('async_req') - all_params.append('_return_http_data_only') - all_params.append('_preload_content') - all_params.append('_request_timeout') - all_params.append('urlopen_kw') - - for key, val in six.iteritems(local_var_params['kwargs']): - if key not in all_params: - raise TypeError( - "Got an unexpected keyword argument '%s'" - " to method post_query_analyze" % key - ) - local_var_params[key] = val - del local_var_params['kwargs'] - - collection_formats = {} + self._check_operation_params('post_query_analyze', all_params, local_var_params) path_params = {} @@ -518,9 +501,6 @@ def post_query_analyze_with_http_info(self, **kwargs): # noqa: E501,D401,D403 if 'content_type' in local_var_params: header_params['Content-Type'] = local_var_params['content_type'] # noqa: E501 - form_params = [] - local_var_files = {} - body_params = None if 'query' in local_var_params: body_params = local_var_params['query'] @@ -532,30 +512,7 @@ def post_query_analyze_with_http_info(self, **kwargs): # noqa: E501,D401,D403 header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501 ['application/json']) # noqa: E501 - # Authentication setting - auth_settings = [] # noqa: E501 - - # urlopen optional setting - urlopen_kw = None - if 'urlopen_kw' in kwargs: - urlopen_kw = kwargs['urlopen_kw'] - - return self.api_client.call_api( - '/api/v2/query/analyze', 'POST', - path_params, - query_params, - header_params, - body=body_params, - post_params=form_params, - files=local_var_files, - response_type='AnalyzeQueryResponse', # noqa: E501 - auth_settings=auth_settings, - async_req=local_var_params.get('async_req'), - _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 - _preload_content=local_var_params.get('_preload_content', True), - _request_timeout=local_var_params.get('_request_timeout'), - collection_formats=collection_formats, - urlopen_kw=urlopen_kw) + return local_var_params, path_params, query_params, header_params, body_params def post_query_ast(self, **kwargs): # noqa: E501,D401,D403 """Generate an Abstract Syntax Tree (AST) from a query. @@ -598,25 +555,65 @@ def post_query_ast_with_http_info(self, **kwargs): # noqa: E501,D401,D403 If the method is called asynchronously, returns the request thread. """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._post_query_ast_prepare(**kwargs) + + return self.api_client.call_api( + '/api/v2/query/ast', 'POST', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='ASTResponse', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + async def post_query_ast_async(self, **kwargs): # noqa: E501,D401,D403 + """Generate an Abstract Syntax Tree (AST) from a query. + + Analyzes flux query and generates a query specification. + This method makes an asynchronous HTTP request. + + :param async_req bool + :param str zap_trace_span: OpenTracing span context + :param str content_type: + :param LanguageRequest language_request: Analyzed Flux query to generate abstract syntax tree. + :return: ASTResponse + If the method is called asynchronously, + returns the request thread. + """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._post_query_ast_prepare(**kwargs) + + return await self.api_client.call_api( + '/api/v2/query/ast', 'POST', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='ASTResponse', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + def _post_query_ast_prepare(self, **kwargs): # noqa: E501,D401,D403 local_var_params = locals() all_params = ['zap_trace_span', 'content_type', 'language_request'] # noqa: E501 - all_params.append('async_req') - all_params.append('_return_http_data_only') - all_params.append('_preload_content') - all_params.append('_request_timeout') - all_params.append('urlopen_kw') - - for key, val in six.iteritems(local_var_params['kwargs']): - if key not in all_params: - raise TypeError( - "Got an unexpected keyword argument '%s'" - " to method post_query_ast" % key - ) - local_var_params[key] = val - del local_var_params['kwargs'] - - collection_formats = {} + self._check_operation_params('post_query_ast', all_params, local_var_params) path_params = {} @@ -628,9 +625,6 @@ def post_query_ast_with_http_info(self, **kwargs): # noqa: E501,D401,D403 if 'content_type' in local_var_params: header_params['Content-Type'] = local_var_params['content_type'] # noqa: E501 - form_params = [] - local_var_files = {} - body_params = None if 'language_request' in local_var_params: body_params = local_var_params['language_request'] @@ -642,27 +636,4 @@ def post_query_ast_with_http_info(self, **kwargs): # noqa: E501,D401,D403 header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501 ['application/json']) # noqa: E501 - # Authentication setting - auth_settings = [] # noqa: E501 - - # urlopen optional setting - urlopen_kw = None - if 'urlopen_kw' in kwargs: - urlopen_kw = kwargs['urlopen_kw'] - - return self.api_client.call_api( - '/api/v2/query/ast', 'POST', - path_params, - query_params, - header_params, - body=body_params, - post_params=form_params, - files=local_var_files, - response_type='ASTResponse', # noqa: E501 - auth_settings=auth_settings, - async_req=local_var_params.get('async_req'), - _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 - _preload_content=local_var_params.get('_preload_content', True), - _request_timeout=local_var_params.get('_request_timeout'), - collection_formats=collection_formats, - urlopen_kw=urlopen_kw) + return local_var_params, path_params, query_params, header_params, body_params diff --git a/influxdb_client/service/ready_service.py b/influxdb_client/service/ready_service.py index cb013867..4d2a778e 100644 --- a/influxdb_client/service/ready_service.py +++ b/influxdb_client/service/ready_service.py @@ -14,11 +14,10 @@ import re # noqa: F401 -# python 2 and python 3 compatibility library -import six +from influxdb_client.service._base_service import _BaseService -class ReadyService(object): +class ReadyService(_BaseService): """NOTE: This class is auto generated by OpenAPI Generator. Ref: https://openapi-generator.tech @@ -67,25 +66,62 @@ def get_ready_with_http_info(self, **kwargs): # noqa: E501,D401,D403 If the method is called asynchronously, returns the request thread. """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._get_ready_prepare(**kwargs) + + return self.api_client.call_api( + '/ready', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='Ready', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + async def get_ready_async(self, **kwargs): # noqa: E501,D401,D403 + """Get the readiness of an instance at startup. + + This method makes an asynchronous HTTP request. + + :param async_req bool + :param str zap_trace_span: OpenTracing span context + :return: Ready + If the method is called asynchronously, + returns the request thread. + """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._get_ready_prepare(**kwargs) + + return await self.api_client.call_api( + '/ready', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='Ready', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + def _get_ready_prepare(self, **kwargs): # noqa: E501,D401,D403 local_var_params = locals() all_params = ['zap_trace_span'] # noqa: E501 - all_params.append('async_req') - all_params.append('_return_http_data_only') - all_params.append('_preload_content') - all_params.append('_request_timeout') - all_params.append('urlopen_kw') - - for key, val in six.iteritems(local_var_params['kwargs']): - if key not in all_params: - raise TypeError( - "Got an unexpected keyword argument '%s'" - " to method get_ready" % key - ) - local_var_params[key] = val - del local_var_params['kwargs'] - - collection_formats = {} + self._check_operation_params('get_ready', all_params, local_var_params) path_params = {} @@ -95,35 +131,9 @@ def get_ready_with_http_info(self, **kwargs): # noqa: E501,D401,D403 if 'zap_trace_span' in local_var_params: header_params['Zap-Trace-Span'] = local_var_params['zap_trace_span'] # noqa: E501 - form_params = [] - local_var_files = {} - body_params = None # HTTP header `Accept` header_params['Accept'] = self.api_client.select_header_accept( ['application/json']) # noqa: E501 - # Authentication setting - auth_settings = [] # noqa: E501 - - # urlopen optional setting - urlopen_kw = None - if 'urlopen_kw' in kwargs: - urlopen_kw = kwargs['urlopen_kw'] - - return self.api_client.call_api( - '/ready', 'GET', - path_params, - query_params, - header_params, - body=body_params, - post_params=form_params, - files=local_var_files, - response_type='Ready', # noqa: E501 - auth_settings=auth_settings, - async_req=local_var_params.get('async_req'), - _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 - _preload_content=local_var_params.get('_preload_content', True), - _request_timeout=local_var_params.get('_request_timeout'), - collection_formats=collection_formats, - urlopen_kw=urlopen_kw) + return local_var_params, path_params, query_params, header_params, body_params diff --git a/influxdb_client/service/remote_connections_service.py b/influxdb_client/service/remote_connections_service.py index b6503de2..912b5b81 100644 --- a/influxdb_client/service/remote_connections_service.py +++ b/influxdb_client/service/remote_connections_service.py @@ -14,11 +14,10 @@ import re # noqa: F401 -# python 2 and python 3 compatibility library -import six +from influxdb_client.service._base_service import _BaseService -class RemoteConnectionsService(object): +class RemoteConnectionsService(_BaseService): """NOTE: This class is auto generated by OpenAPI Generator. Ref: https://openapi-generator.tech @@ -69,30 +68,68 @@ def delete_remote_connection_by_id_with_http_info(self, remote_id, **kwargs): # If the method is called asynchronously, returns the request thread. """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._delete_remote_connection_by_id_prepare(remote_id, **kwargs) + + return self.api_client.call_api( + '/api/v2/remotes/{remoteID}', 'DELETE', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type=None, # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + async def delete_remote_connection_by_id_async(self, remote_id, **kwargs): # noqa: E501,D401,D403 + """Delete a remote connection. + + This method makes an asynchronous HTTP request. + + :param async_req bool + :param str remote_id: (required) + :param str zap_trace_span: OpenTracing span context + :return: None + If the method is called asynchronously, + returns the request thread. + """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._delete_remote_connection_by_id_prepare(remote_id, **kwargs) + + return await self.api_client.call_api( + '/api/v2/remotes/{remoteID}', 'DELETE', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type=None, # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + def _delete_remote_connection_by_id_prepare(self, remote_id, **kwargs): # noqa: E501,D401,D403 local_var_params = locals() all_params = ['remote_id', 'zap_trace_span'] # noqa: E501 - all_params.append('async_req') - all_params.append('_return_http_data_only') - all_params.append('_preload_content') - all_params.append('_request_timeout') - all_params.append('urlopen_kw') - - for key, val in six.iteritems(local_var_params['kwargs']): - if key not in all_params: - raise TypeError( - "Got an unexpected keyword argument '%s'" - " to method delete_remote_connection_by_id" % key - ) - local_var_params[key] = val - del local_var_params['kwargs'] + self._check_operation_params('delete_remote_connection_by_id', all_params, local_var_params) # verify the required parameter 'remote_id' is set if ('remote_id' not in local_var_params or local_var_params['remote_id'] is None): raise ValueError("Missing the required parameter `remote_id` when calling `delete_remote_connection_by_id`") # noqa: E501 - collection_formats = {} - path_params = {} if 'remote_id' in local_var_params: path_params['remoteID'] = local_var_params['remote_id'] # noqa: E501 @@ -103,38 +140,12 @@ def delete_remote_connection_by_id_with_http_info(self, remote_id, **kwargs): # if 'zap_trace_span' in local_var_params: header_params['Zap-Trace-Span'] = local_var_params['zap_trace_span'] # noqa: E501 - form_params = [] - local_var_files = {} - body_params = None # HTTP header `Accept` header_params['Accept'] = self.api_client.select_header_accept( ['application/json']) # noqa: E501 - # Authentication setting - auth_settings = [] # noqa: E501 - - # urlopen optional setting - urlopen_kw = None - if 'urlopen_kw' in kwargs: - urlopen_kw = kwargs['urlopen_kw'] - - return self.api_client.call_api( - '/api/v2/remotes/{remoteID}', 'DELETE', - path_params, - query_params, - header_params, - body=body_params, - post_params=form_params, - files=local_var_files, - response_type=None, # noqa: E501 - auth_settings=auth_settings, - async_req=local_var_params.get('async_req'), - _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 - _preload_content=local_var_params.get('_preload_content', True), - _request_timeout=local_var_params.get('_request_timeout'), - collection_formats=collection_formats, - urlopen_kw=urlopen_kw) + return local_var_params, path_params, query_params, header_params, body_params def get_remote_connection_by_id(self, remote_id, **kwargs): # noqa: E501,D401,D403 """Retrieve a remote connection. @@ -173,30 +184,68 @@ def get_remote_connection_by_id_with_http_info(self, remote_id, **kwargs): # no If the method is called asynchronously, returns the request thread. """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._get_remote_connection_by_id_prepare(remote_id, **kwargs) + + return self.api_client.call_api( + '/api/v2/remotes/{remoteID}', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='RemoteConnection', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + async def get_remote_connection_by_id_async(self, remote_id, **kwargs): # noqa: E501,D401,D403 + """Retrieve a remote connection. + + This method makes an asynchronous HTTP request. + + :param async_req bool + :param str remote_id: (required) + :param str zap_trace_span: OpenTracing span context + :return: RemoteConnection + If the method is called asynchronously, + returns the request thread. + """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._get_remote_connection_by_id_prepare(remote_id, **kwargs) + + return await self.api_client.call_api( + '/api/v2/remotes/{remoteID}', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='RemoteConnection', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + def _get_remote_connection_by_id_prepare(self, remote_id, **kwargs): # noqa: E501,D401,D403 local_var_params = locals() all_params = ['remote_id', 'zap_trace_span'] # noqa: E501 - all_params.append('async_req') - all_params.append('_return_http_data_only') - all_params.append('_preload_content') - all_params.append('_request_timeout') - all_params.append('urlopen_kw') - - for key, val in six.iteritems(local_var_params['kwargs']): - if key not in all_params: - raise TypeError( - "Got an unexpected keyword argument '%s'" - " to method get_remote_connection_by_id" % key - ) - local_var_params[key] = val - del local_var_params['kwargs'] + self._check_operation_params('get_remote_connection_by_id', all_params, local_var_params) # verify the required parameter 'remote_id' is set if ('remote_id' not in local_var_params or local_var_params['remote_id'] is None): raise ValueError("Missing the required parameter `remote_id` when calling `get_remote_connection_by_id`") # noqa: E501 - collection_formats = {} - path_params = {} if 'remote_id' in local_var_params: path_params['remoteID'] = local_var_params['remote_id'] # noqa: E501 @@ -207,38 +256,12 @@ def get_remote_connection_by_id_with_http_info(self, remote_id, **kwargs): # no if 'zap_trace_span' in local_var_params: header_params['Zap-Trace-Span'] = local_var_params['zap_trace_span'] # noqa: E501 - form_params = [] - local_var_files = {} - body_params = None # HTTP header `Accept` header_params['Accept'] = self.api_client.select_header_accept( ['application/json']) # noqa: E501 - # Authentication setting - auth_settings = [] # noqa: E501 - - # urlopen optional setting - urlopen_kw = None - if 'urlopen_kw' in kwargs: - urlopen_kw = kwargs['urlopen_kw'] - - return self.api_client.call_api( - '/api/v2/remotes/{remoteID}', 'GET', - path_params, - query_params, - header_params, - body=body_params, - post_params=form_params, - files=local_var_files, - response_type='RemoteConnection', # noqa: E501 - auth_settings=auth_settings, - async_req=local_var_params.get('async_req'), - _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 - _preload_content=local_var_params.get('_preload_content', True), - _request_timeout=local_var_params.get('_request_timeout'), - collection_formats=collection_formats, - urlopen_kw=urlopen_kw) + return local_var_params, path_params, query_params, header_params, body_params def get_remote_connections(self, org_id, **kwargs): # noqa: E501,D401,D403 """List all remote connections. @@ -281,30 +304,70 @@ def get_remote_connections_with_http_info(self, org_id, **kwargs): # noqa: E501 If the method is called asynchronously, returns the request thread. """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._get_remote_connections_prepare(org_id, **kwargs) + + return self.api_client.call_api( + '/api/v2/remotes', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='RemoteConnections', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + async def get_remote_connections_async(self, org_id, **kwargs): # noqa: E501,D401,D403 + """List all remote connections. + + This method makes an asynchronous HTTP request. + + :param async_req bool + :param str org_id: The organization ID. (required) + :param str zap_trace_span: OpenTracing span context + :param str name: + :param str remote_url: + :return: RemoteConnections + If the method is called asynchronously, + returns the request thread. + """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._get_remote_connections_prepare(org_id, **kwargs) + + return await self.api_client.call_api( + '/api/v2/remotes', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='RemoteConnections', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + def _get_remote_connections_prepare(self, org_id, **kwargs): # noqa: E501,D401,D403 local_var_params = locals() all_params = ['org_id', 'zap_trace_span', 'name', 'remote_url'] # noqa: E501 - all_params.append('async_req') - all_params.append('_return_http_data_only') - all_params.append('_preload_content') - all_params.append('_request_timeout') - all_params.append('urlopen_kw') - - for key, val in six.iteritems(local_var_params['kwargs']): - if key not in all_params: - raise TypeError( - "Got an unexpected keyword argument '%s'" - " to method get_remote_connections" % key - ) - local_var_params[key] = val - del local_var_params['kwargs'] + self._check_operation_params('get_remote_connections', all_params, local_var_params) # verify the required parameter 'org_id' is set if ('org_id' not in local_var_params or local_var_params['org_id'] is None): raise ValueError("Missing the required parameter `org_id` when calling `get_remote_connections`") # noqa: E501 - collection_formats = {} - path_params = {} query_params = [] @@ -319,38 +382,12 @@ def get_remote_connections_with_http_info(self, org_id, **kwargs): # noqa: E501 if 'zap_trace_span' in local_var_params: header_params['Zap-Trace-Span'] = local_var_params['zap_trace_span'] # noqa: E501 - form_params = [] - local_var_files = {} - body_params = None # HTTP header `Accept` header_params['Accept'] = self.api_client.select_header_accept( ['application/json']) # noqa: E501 - # Authentication setting - auth_settings = [] # noqa: E501 - - # urlopen optional setting - urlopen_kw = None - if 'urlopen_kw' in kwargs: - urlopen_kw = kwargs['urlopen_kw'] - - return self.api_client.call_api( - '/api/v2/remotes', 'GET', - path_params, - query_params, - header_params, - body=body_params, - post_params=form_params, - files=local_var_files, - response_type='RemoteConnections', # noqa: E501 - auth_settings=auth_settings, - async_req=local_var_params.get('async_req'), - _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 - _preload_content=local_var_params.get('_preload_content', True), - _request_timeout=local_var_params.get('_request_timeout'), - collection_formats=collection_formats, - urlopen_kw=urlopen_kw) + return local_var_params, path_params, query_params, header_params, body_params def patch_remote_connection_by_id(self, remote_id, remote_connection_update_request, **kwargs): # noqa: E501,D401,D403 """Update a remote connection. @@ -391,23 +428,64 @@ def patch_remote_connection_by_id_with_http_info(self, remote_id, remote_connect If the method is called asynchronously, returns the request thread. """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._patch_remote_connection_by_id_prepare(remote_id, remote_connection_update_request, **kwargs) + + return self.api_client.call_api( + '/api/v2/remotes/{remoteID}', 'PATCH', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='RemoteConnection', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + async def patch_remote_connection_by_id_async(self, remote_id, remote_connection_update_request, **kwargs): # noqa: E501,D401,D403 + """Update a remote connection. + + This method makes an asynchronous HTTP request. + + :param async_req bool + :param str remote_id: (required) + :param RemoteConnectionUpdateRequest remote_connection_update_request: (required) + :param str zap_trace_span: OpenTracing span context + :return: RemoteConnection + If the method is called asynchronously, + returns the request thread. + """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._patch_remote_connection_by_id_prepare(remote_id, remote_connection_update_request, **kwargs) + + return await self.api_client.call_api( + '/api/v2/remotes/{remoteID}', 'PATCH', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='RemoteConnection', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + def _patch_remote_connection_by_id_prepare(self, remote_id, remote_connection_update_request, **kwargs): # noqa: E501,D401,D403 local_var_params = locals() all_params = ['remote_id', 'remote_connection_update_request', 'zap_trace_span'] # noqa: E501 - all_params.append('async_req') - all_params.append('_return_http_data_only') - all_params.append('_preload_content') - all_params.append('_request_timeout') - all_params.append('urlopen_kw') - - for key, val in six.iteritems(local_var_params['kwargs']): - if key not in all_params: - raise TypeError( - "Got an unexpected keyword argument '%s'" - " to method patch_remote_connection_by_id" % key - ) - local_var_params[key] = val - del local_var_params['kwargs'] + self._check_operation_params('patch_remote_connection_by_id', all_params, local_var_params) # verify the required parameter 'remote_id' is set if ('remote_id' not in local_var_params or local_var_params['remote_id'] is None): @@ -417,8 +495,6 @@ def patch_remote_connection_by_id_with_http_info(self, remote_id, remote_connect local_var_params['remote_connection_update_request'] is None): raise ValueError("Missing the required parameter `remote_connection_update_request` when calling `patch_remote_connection_by_id`") # noqa: E501 - collection_formats = {} - path_params = {} if 'remote_id' in local_var_params: path_params['remoteID'] = local_var_params['remote_id'] # noqa: E501 @@ -429,9 +505,6 @@ def patch_remote_connection_by_id_with_http_info(self, remote_id, remote_connect if 'zap_trace_span' in local_var_params: header_params['Zap-Trace-Span'] = local_var_params['zap_trace_span'] # noqa: E501 - form_params = [] - local_var_files = {} - body_params = None if 'remote_connection_update_request' in local_var_params: body_params = local_var_params['remote_connection_update_request'] @@ -443,30 +516,7 @@ def patch_remote_connection_by_id_with_http_info(self, remote_id, remote_connect header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501 ['application/json']) # noqa: E501 - # Authentication setting - auth_settings = [] # noqa: E501 - - # urlopen optional setting - urlopen_kw = None - if 'urlopen_kw' in kwargs: - urlopen_kw = kwargs['urlopen_kw'] - - return self.api_client.call_api( - '/api/v2/remotes/{remoteID}', 'PATCH', - path_params, - query_params, - header_params, - body=body_params, - post_params=form_params, - files=local_var_files, - response_type='RemoteConnection', # noqa: E501 - auth_settings=auth_settings, - async_req=local_var_params.get('async_req'), - _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 - _preload_content=local_var_params.get('_preload_content', True), - _request_timeout=local_var_params.get('_request_timeout'), - collection_formats=collection_formats, - urlopen_kw=urlopen_kw) + return local_var_params, path_params, query_params, header_params, body_params def post_remote_connection(self, remote_connection_creation_request, **kwargs): # noqa: E501,D401,D403 """Register a new remote connection. @@ -503,39 +553,73 @@ def post_remote_connection_with_http_info(self, remote_connection_creation_reque If the method is called asynchronously, returns the request thread. """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._post_remote_connection_prepare(remote_connection_creation_request, **kwargs) + + return self.api_client.call_api( + '/api/v2/remotes', 'POST', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='RemoteConnection', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + async def post_remote_connection_async(self, remote_connection_creation_request, **kwargs): # noqa: E501,D401,D403 + """Register a new remote connection. + + This method makes an asynchronous HTTP request. + + :param async_req bool + :param RemoteConnectionCreationRequest remote_connection_creation_request: (required) + :return: RemoteConnection + If the method is called asynchronously, + returns the request thread. + """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._post_remote_connection_prepare(remote_connection_creation_request, **kwargs) + + return await self.api_client.call_api( + '/api/v2/remotes', 'POST', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='RemoteConnection', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + def _post_remote_connection_prepare(self, remote_connection_creation_request, **kwargs): # noqa: E501,D401,D403 local_var_params = locals() all_params = ['remote_connection_creation_request'] # noqa: E501 - all_params.append('async_req') - all_params.append('_return_http_data_only') - all_params.append('_preload_content') - all_params.append('_request_timeout') - all_params.append('urlopen_kw') - - for key, val in six.iteritems(local_var_params['kwargs']): - if key not in all_params: - raise TypeError( - "Got an unexpected keyword argument '%s'" - " to method post_remote_connection" % key - ) - local_var_params[key] = val - del local_var_params['kwargs'] + self._check_operation_params('post_remote_connection', all_params, local_var_params) # verify the required parameter 'remote_connection_creation_request' is set if ('remote_connection_creation_request' not in local_var_params or local_var_params['remote_connection_creation_request'] is None): raise ValueError("Missing the required parameter `remote_connection_creation_request` when calling `post_remote_connection`") # noqa: E501 - collection_formats = {} - path_params = {} query_params = [] header_params = {} - form_params = [] - local_var_files = {} - body_params = None if 'remote_connection_creation_request' in local_var_params: body_params = local_var_params['remote_connection_creation_request'] @@ -547,27 +631,4 @@ def post_remote_connection_with_http_info(self, remote_connection_creation_reque header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501 ['application/json']) # noqa: E501 - # Authentication setting - auth_settings = [] # noqa: E501 - - # urlopen optional setting - urlopen_kw = None - if 'urlopen_kw' in kwargs: - urlopen_kw = kwargs['urlopen_kw'] - - return self.api_client.call_api( - '/api/v2/remotes', 'POST', - path_params, - query_params, - header_params, - body=body_params, - post_params=form_params, - files=local_var_files, - response_type='RemoteConnection', # noqa: E501 - auth_settings=auth_settings, - async_req=local_var_params.get('async_req'), - _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 - _preload_content=local_var_params.get('_preload_content', True), - _request_timeout=local_var_params.get('_request_timeout'), - collection_formats=collection_formats, - urlopen_kw=urlopen_kw) + return local_var_params, path_params, query_params, header_params, body_params diff --git a/influxdb_client/service/replications_service.py b/influxdb_client/service/replications_service.py index dd6c9557..58bd13f5 100644 --- a/influxdb_client/service/replications_service.py +++ b/influxdb_client/service/replications_service.py @@ -14,11 +14,10 @@ import re # noqa: F401 -# python 2 and python 3 compatibility library -import six +from influxdb_client.service._base_service import _BaseService -class ReplicationsService(object): +class ReplicationsService(_BaseService): """NOTE: This class is auto generated by OpenAPI Generator. Ref: https://openapi-generator.tech @@ -69,30 +68,68 @@ def delete_replication_by_id_with_http_info(self, replication_id, **kwargs): # If the method is called asynchronously, returns the request thread. """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._delete_replication_by_id_prepare(replication_id, **kwargs) + + return self.api_client.call_api( + '/api/v2/replications/{replicationID}', 'DELETE', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type=None, # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + async def delete_replication_by_id_async(self, replication_id, **kwargs): # noqa: E501,D401,D403 + """Delete a replication. + + This method makes an asynchronous HTTP request. + + :param async_req bool + :param str replication_id: (required) + :param str zap_trace_span: OpenTracing span context + :return: None + If the method is called asynchronously, + returns the request thread. + """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._delete_replication_by_id_prepare(replication_id, **kwargs) + + return await self.api_client.call_api( + '/api/v2/replications/{replicationID}', 'DELETE', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type=None, # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + def _delete_replication_by_id_prepare(self, replication_id, **kwargs): # noqa: E501,D401,D403 local_var_params = locals() all_params = ['replication_id', 'zap_trace_span'] # noqa: E501 - all_params.append('async_req') - all_params.append('_return_http_data_only') - all_params.append('_preload_content') - all_params.append('_request_timeout') - all_params.append('urlopen_kw') - - for key, val in six.iteritems(local_var_params['kwargs']): - if key not in all_params: - raise TypeError( - "Got an unexpected keyword argument '%s'" - " to method delete_replication_by_id" % key - ) - local_var_params[key] = val - del local_var_params['kwargs'] + self._check_operation_params('delete_replication_by_id', all_params, local_var_params) # verify the required parameter 'replication_id' is set if ('replication_id' not in local_var_params or local_var_params['replication_id'] is None): raise ValueError("Missing the required parameter `replication_id` when calling `delete_replication_by_id`") # noqa: E501 - collection_formats = {} - path_params = {} if 'replication_id' in local_var_params: path_params['replicationID'] = local_var_params['replication_id'] # noqa: E501 @@ -103,38 +140,12 @@ def delete_replication_by_id_with_http_info(self, replication_id, **kwargs): # if 'zap_trace_span' in local_var_params: header_params['Zap-Trace-Span'] = local_var_params['zap_trace_span'] # noqa: E501 - form_params = [] - local_var_files = {} - body_params = None # HTTP header `Accept` header_params['Accept'] = self.api_client.select_header_accept( ['application/json']) # noqa: E501 - # Authentication setting - auth_settings = [] # noqa: E501 - - # urlopen optional setting - urlopen_kw = None - if 'urlopen_kw' in kwargs: - urlopen_kw = kwargs['urlopen_kw'] - - return self.api_client.call_api( - '/api/v2/replications/{replicationID}', 'DELETE', - path_params, - query_params, - header_params, - body=body_params, - post_params=form_params, - files=local_var_files, - response_type=None, # noqa: E501 - auth_settings=auth_settings, - async_req=local_var_params.get('async_req'), - _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 - _preload_content=local_var_params.get('_preload_content', True), - _request_timeout=local_var_params.get('_request_timeout'), - collection_formats=collection_formats, - urlopen_kw=urlopen_kw) + return local_var_params, path_params, query_params, header_params, body_params def get_replication_by_id(self, replication_id, **kwargs): # noqa: E501,D401,D403 """Retrieve a replication. @@ -173,30 +184,68 @@ def get_replication_by_id_with_http_info(self, replication_id, **kwargs): # noq If the method is called asynchronously, returns the request thread. """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._get_replication_by_id_prepare(replication_id, **kwargs) + + return self.api_client.call_api( + '/api/v2/replications/{replicationID}', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='Replication', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + async def get_replication_by_id_async(self, replication_id, **kwargs): # noqa: E501,D401,D403 + """Retrieve a replication. + + This method makes an asynchronous HTTP request. + + :param async_req bool + :param str replication_id: (required) + :param str zap_trace_span: OpenTracing span context + :return: Replication + If the method is called asynchronously, + returns the request thread. + """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._get_replication_by_id_prepare(replication_id, **kwargs) + + return await self.api_client.call_api( + '/api/v2/replications/{replicationID}', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='Replication', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + def _get_replication_by_id_prepare(self, replication_id, **kwargs): # noqa: E501,D401,D403 local_var_params = locals() all_params = ['replication_id', 'zap_trace_span'] # noqa: E501 - all_params.append('async_req') - all_params.append('_return_http_data_only') - all_params.append('_preload_content') - all_params.append('_request_timeout') - all_params.append('urlopen_kw') - - for key, val in six.iteritems(local_var_params['kwargs']): - if key not in all_params: - raise TypeError( - "Got an unexpected keyword argument '%s'" - " to method get_replication_by_id" % key - ) - local_var_params[key] = val - del local_var_params['kwargs'] + self._check_operation_params('get_replication_by_id', all_params, local_var_params) # verify the required parameter 'replication_id' is set if ('replication_id' not in local_var_params or local_var_params['replication_id'] is None): raise ValueError("Missing the required parameter `replication_id` when calling `get_replication_by_id`") # noqa: E501 - collection_formats = {} - path_params = {} if 'replication_id' in local_var_params: path_params['replicationID'] = local_var_params['replication_id'] # noqa: E501 @@ -207,38 +256,12 @@ def get_replication_by_id_with_http_info(self, replication_id, **kwargs): # noq if 'zap_trace_span' in local_var_params: header_params['Zap-Trace-Span'] = local_var_params['zap_trace_span'] # noqa: E501 - form_params = [] - local_var_files = {} - body_params = None # HTTP header `Accept` header_params['Accept'] = self.api_client.select_header_accept( ['application/json']) # noqa: E501 - # Authentication setting - auth_settings = [] # noqa: E501 - - # urlopen optional setting - urlopen_kw = None - if 'urlopen_kw' in kwargs: - urlopen_kw = kwargs['urlopen_kw'] - - return self.api_client.call_api( - '/api/v2/replications/{replicationID}', 'GET', - path_params, - query_params, - header_params, - body=body_params, - post_params=form_params, - files=local_var_files, - response_type='Replication', # noqa: E501 - auth_settings=auth_settings, - async_req=local_var_params.get('async_req'), - _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 - _preload_content=local_var_params.get('_preload_content', True), - _request_timeout=local_var_params.get('_request_timeout'), - collection_formats=collection_formats, - urlopen_kw=urlopen_kw) + return local_var_params, path_params, query_params, header_params, body_params def get_replications(self, org_id, **kwargs): # noqa: E501,D401,D403 """List all replications. @@ -283,30 +306,71 @@ def get_replications_with_http_info(self, org_id, **kwargs): # noqa: E501,D401, If the method is called asynchronously, returns the request thread. """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._get_replications_prepare(org_id, **kwargs) + + return self.api_client.call_api( + '/api/v2/replications', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='Replications', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + async def get_replications_async(self, org_id, **kwargs): # noqa: E501,D401,D403 + """List all replications. + + This method makes an asynchronous HTTP request. + + :param async_req bool + :param str org_id: The organization ID. (required) + :param str zap_trace_span: OpenTracing span context + :param str name: + :param str remote_id: + :param str local_bucket_id: + :return: Replications + If the method is called asynchronously, + returns the request thread. + """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._get_replications_prepare(org_id, **kwargs) + + return await self.api_client.call_api( + '/api/v2/replications', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='Replications', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + def _get_replications_prepare(self, org_id, **kwargs): # noqa: E501,D401,D403 local_var_params = locals() all_params = ['org_id', 'zap_trace_span', 'name', 'remote_id', 'local_bucket_id'] # noqa: E501 - all_params.append('async_req') - all_params.append('_return_http_data_only') - all_params.append('_preload_content') - all_params.append('_request_timeout') - all_params.append('urlopen_kw') - - for key, val in six.iteritems(local_var_params['kwargs']): - if key not in all_params: - raise TypeError( - "Got an unexpected keyword argument '%s'" - " to method get_replications" % key - ) - local_var_params[key] = val - del local_var_params['kwargs'] + self._check_operation_params('get_replications', all_params, local_var_params) # verify the required parameter 'org_id' is set if ('org_id' not in local_var_params or local_var_params['org_id'] is None): raise ValueError("Missing the required parameter `org_id` when calling `get_replications`") # noqa: E501 - collection_formats = {} - path_params = {} query_params = [] @@ -323,38 +387,12 @@ def get_replications_with_http_info(self, org_id, **kwargs): # noqa: E501,D401, if 'zap_trace_span' in local_var_params: header_params['Zap-Trace-Span'] = local_var_params['zap_trace_span'] # noqa: E501 - form_params = [] - local_var_files = {} - body_params = None # HTTP header `Accept` header_params['Accept'] = self.api_client.select_header_accept( ['application/json']) # noqa: E501 - # Authentication setting - auth_settings = [] # noqa: E501 - - # urlopen optional setting - urlopen_kw = None - if 'urlopen_kw' in kwargs: - urlopen_kw = kwargs['urlopen_kw'] - - return self.api_client.call_api( - '/api/v2/replications', 'GET', - path_params, - query_params, - header_params, - body=body_params, - post_params=form_params, - files=local_var_files, - response_type='Replications', # noqa: E501 - auth_settings=auth_settings, - async_req=local_var_params.get('async_req'), - _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 - _preload_content=local_var_params.get('_preload_content', True), - _request_timeout=local_var_params.get('_request_timeout'), - collection_formats=collection_formats, - urlopen_kw=urlopen_kw) + return local_var_params, path_params, query_params, header_params, body_params def patch_replication_by_id(self, replication_id, replication_update_request, **kwargs): # noqa: E501,D401,D403 """Update a replication. @@ -397,23 +435,65 @@ def patch_replication_by_id_with_http_info(self, replication_id, replication_upd If the method is called asynchronously, returns the request thread. """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._patch_replication_by_id_prepare(replication_id, replication_update_request, **kwargs) + + return self.api_client.call_api( + '/api/v2/replications/{replicationID}', 'PATCH', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='Replication', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + async def patch_replication_by_id_async(self, replication_id, replication_update_request, **kwargs): # noqa: E501,D401,D403 + """Update a replication. + + This method makes an asynchronous HTTP request. + + :param async_req bool + :param str replication_id: (required) + :param ReplicationUpdateRequest replication_update_request: (required) + :param str zap_trace_span: OpenTracing span context + :param bool validate: If true, validate the updated information, but don't save it. + :return: Replication + If the method is called asynchronously, + returns the request thread. + """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._patch_replication_by_id_prepare(replication_id, replication_update_request, **kwargs) + + return await self.api_client.call_api( + '/api/v2/replications/{replicationID}', 'PATCH', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='Replication', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + def _patch_replication_by_id_prepare(self, replication_id, replication_update_request, **kwargs): # noqa: E501,D401,D403 local_var_params = locals() all_params = ['replication_id', 'replication_update_request', 'zap_trace_span', 'validate'] # noqa: E501 - all_params.append('async_req') - all_params.append('_return_http_data_only') - all_params.append('_preload_content') - all_params.append('_request_timeout') - all_params.append('urlopen_kw') - - for key, val in six.iteritems(local_var_params['kwargs']): - if key not in all_params: - raise TypeError( - "Got an unexpected keyword argument '%s'" - " to method patch_replication_by_id" % key - ) - local_var_params[key] = val - del local_var_params['kwargs'] + self._check_operation_params('patch_replication_by_id', all_params, local_var_params) # verify the required parameter 'replication_id' is set if ('replication_id' not in local_var_params or local_var_params['replication_id'] is None): @@ -423,8 +503,6 @@ def patch_replication_by_id_with_http_info(self, replication_id, replication_upd local_var_params['replication_update_request'] is None): raise ValueError("Missing the required parameter `replication_update_request` when calling `patch_replication_by_id`") # noqa: E501 - collection_formats = {} - path_params = {} if 'replication_id' in local_var_params: path_params['replicationID'] = local_var_params['replication_id'] # noqa: E501 @@ -437,9 +515,6 @@ def patch_replication_by_id_with_http_info(self, replication_id, replication_upd if 'zap_trace_span' in local_var_params: header_params['Zap-Trace-Span'] = local_var_params['zap_trace_span'] # noqa: E501 - form_params = [] - local_var_files = {} - body_params = None if 'replication_update_request' in local_var_params: body_params = local_var_params['replication_update_request'] @@ -451,30 +526,7 @@ def patch_replication_by_id_with_http_info(self, replication_id, replication_upd header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501 ['application/json']) # noqa: E501 - # Authentication setting - auth_settings = [] # noqa: E501 - - # urlopen optional setting - urlopen_kw = None - if 'urlopen_kw' in kwargs: - urlopen_kw = kwargs['urlopen_kw'] - - return self.api_client.call_api( - '/api/v2/replications/{replicationID}', 'PATCH', - path_params, - query_params, - header_params, - body=body_params, - post_params=form_params, - files=local_var_files, - response_type='Replication', # noqa: E501 - auth_settings=auth_settings, - async_req=local_var_params.get('async_req'), - _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 - _preload_content=local_var_params.get('_preload_content', True), - _request_timeout=local_var_params.get('_request_timeout'), - collection_formats=collection_formats, - urlopen_kw=urlopen_kw) + return local_var_params, path_params, query_params, header_params, body_params def post_replication(self, replication_creation_request, **kwargs): # noqa: E501,D401,D403 """Register a new replication. @@ -515,30 +567,69 @@ def post_replication_with_http_info(self, replication_creation_request, **kwargs If the method is called asynchronously, returns the request thread. """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._post_replication_prepare(replication_creation_request, **kwargs) + + return self.api_client.call_api( + '/api/v2/replications', 'POST', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='Replication', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + async def post_replication_async(self, replication_creation_request, **kwargs): # noqa: E501,D401,D403 + """Register a new replication. + + This method makes an asynchronous HTTP request. + + :param async_req bool + :param ReplicationCreationRequest replication_creation_request: (required) + :param str zap_trace_span: OpenTracing span context + :param bool validate: If true, validate the replication, but don't save it. + :return: Replication + If the method is called asynchronously, + returns the request thread. + """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._post_replication_prepare(replication_creation_request, **kwargs) + + return await self.api_client.call_api( + '/api/v2/replications', 'POST', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='Replication', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + def _post_replication_prepare(self, replication_creation_request, **kwargs): # noqa: E501,D401,D403 local_var_params = locals() all_params = ['replication_creation_request', 'zap_trace_span', 'validate'] # noqa: E501 - all_params.append('async_req') - all_params.append('_return_http_data_only') - all_params.append('_preload_content') - all_params.append('_request_timeout') - all_params.append('urlopen_kw') - - for key, val in six.iteritems(local_var_params['kwargs']): - if key not in all_params: - raise TypeError( - "Got an unexpected keyword argument '%s'" - " to method post_replication" % key - ) - local_var_params[key] = val - del local_var_params['kwargs'] + self._check_operation_params('post_replication', all_params, local_var_params) # verify the required parameter 'replication_creation_request' is set if ('replication_creation_request' not in local_var_params or local_var_params['replication_creation_request'] is None): raise ValueError("Missing the required parameter `replication_creation_request` when calling `post_replication`") # noqa: E501 - collection_formats = {} - path_params = {} query_params = [] @@ -549,9 +640,6 @@ def post_replication_with_http_info(self, replication_creation_request, **kwargs if 'zap_trace_span' in local_var_params: header_params['Zap-Trace-Span'] = local_var_params['zap_trace_span'] # noqa: E501 - form_params = [] - local_var_files = {} - body_params = None if 'replication_creation_request' in local_var_params: body_params = local_var_params['replication_creation_request'] @@ -563,30 +651,7 @@ def post_replication_with_http_info(self, replication_creation_request, **kwargs header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501 ['application/json']) # noqa: E501 - # Authentication setting - auth_settings = [] # noqa: E501 - - # urlopen optional setting - urlopen_kw = None - if 'urlopen_kw' in kwargs: - urlopen_kw = kwargs['urlopen_kw'] - - return self.api_client.call_api( - '/api/v2/replications', 'POST', - path_params, - query_params, - header_params, - body=body_params, - post_params=form_params, - files=local_var_files, - response_type='Replication', # noqa: E501 - auth_settings=auth_settings, - async_req=local_var_params.get('async_req'), - _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 - _preload_content=local_var_params.get('_preload_content', True), - _request_timeout=local_var_params.get('_request_timeout'), - collection_formats=collection_formats, - urlopen_kw=urlopen_kw) + return local_var_params, path_params, query_params, header_params, body_params def post_validate_replication_by_id(self, replication_id, **kwargs): # noqa: E501,D401,D403 """Validate a replication. @@ -625,30 +690,68 @@ def post_validate_replication_by_id_with_http_info(self, replication_id, **kwarg If the method is called asynchronously, returns the request thread. """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._post_validate_replication_by_id_prepare(replication_id, **kwargs) + + return self.api_client.call_api( + '/api/v2/replications/{replicationID}/validate', 'POST', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type=None, # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + async def post_validate_replication_by_id_async(self, replication_id, **kwargs): # noqa: E501,D401,D403 + """Validate a replication. + + This method makes an asynchronous HTTP request. + + :param async_req bool + :param str replication_id: (required) + :param str zap_trace_span: OpenTracing span context + :return: None + If the method is called asynchronously, + returns the request thread. + """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._post_validate_replication_by_id_prepare(replication_id, **kwargs) + + return await self.api_client.call_api( + '/api/v2/replications/{replicationID}/validate', 'POST', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type=None, # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + def _post_validate_replication_by_id_prepare(self, replication_id, **kwargs): # noqa: E501,D401,D403 local_var_params = locals() all_params = ['replication_id', 'zap_trace_span'] # noqa: E501 - all_params.append('async_req') - all_params.append('_return_http_data_only') - all_params.append('_preload_content') - all_params.append('_request_timeout') - all_params.append('urlopen_kw') - - for key, val in six.iteritems(local_var_params['kwargs']): - if key not in all_params: - raise TypeError( - "Got an unexpected keyword argument '%s'" - " to method post_validate_replication_by_id" % key - ) - local_var_params[key] = val - del local_var_params['kwargs'] + self._check_operation_params('post_validate_replication_by_id', all_params, local_var_params) # verify the required parameter 'replication_id' is set if ('replication_id' not in local_var_params or local_var_params['replication_id'] is None): raise ValueError("Missing the required parameter `replication_id` when calling `post_validate_replication_by_id`") # noqa: E501 - collection_formats = {} - path_params = {} if 'replication_id' in local_var_params: path_params['replicationID'] = local_var_params['replication_id'] # noqa: E501 @@ -659,35 +762,9 @@ def post_validate_replication_by_id_with_http_info(self, replication_id, **kwarg if 'zap_trace_span' in local_var_params: header_params['Zap-Trace-Span'] = local_var_params['zap_trace_span'] # noqa: E501 - form_params = [] - local_var_files = {} - body_params = None # HTTP header `Accept` header_params['Accept'] = self.api_client.select_header_accept( ['application/json']) # noqa: E501 - # Authentication setting - auth_settings = [] # noqa: E501 - - # urlopen optional setting - urlopen_kw = None - if 'urlopen_kw' in kwargs: - urlopen_kw = kwargs['urlopen_kw'] - - return self.api_client.call_api( - '/api/v2/replications/{replicationID}/validate', 'POST', - path_params, - query_params, - header_params, - body=body_params, - post_params=form_params, - files=local_var_files, - response_type=None, # noqa: E501 - auth_settings=auth_settings, - async_req=local_var_params.get('async_req'), - _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 - _preload_content=local_var_params.get('_preload_content', True), - _request_timeout=local_var_params.get('_request_timeout'), - collection_formats=collection_formats, - urlopen_kw=urlopen_kw) + return local_var_params, path_params, query_params, header_params, body_params diff --git a/influxdb_client/service/resources_service.py b/influxdb_client/service/resources_service.py index 0cdc0ee5..496976cb 100644 --- a/influxdb_client/service/resources_service.py +++ b/influxdb_client/service/resources_service.py @@ -14,11 +14,10 @@ import re # noqa: F401 -# python 2 and python 3 compatibility library -import six +from influxdb_client.service._base_service import _BaseService -class ResourcesService(object): +class ResourcesService(_BaseService): """NOTE: This class is auto generated by OpenAPI Generator. Ref: https://openapi-generator.tech @@ -67,25 +66,62 @@ def get_resources_with_http_info(self, **kwargs): # noqa: E501,D401,D403 If the method is called asynchronously, returns the request thread. """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._get_resources_prepare(**kwargs) + + return self.api_client.call_api( + '/api/v2/resources', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='list[str]', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + async def get_resources_async(self, **kwargs): # noqa: E501,D401,D403 + """List all known resources. + + This method makes an asynchronous HTTP request. + + :param async_req bool + :param str zap_trace_span: OpenTracing span context + :return: list[str] + If the method is called asynchronously, + returns the request thread. + """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._get_resources_prepare(**kwargs) + + return await self.api_client.call_api( + '/api/v2/resources', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='list[str]', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + def _get_resources_prepare(self, **kwargs): # noqa: E501,D401,D403 local_var_params = locals() all_params = ['zap_trace_span'] # noqa: E501 - all_params.append('async_req') - all_params.append('_return_http_data_only') - all_params.append('_preload_content') - all_params.append('_request_timeout') - all_params.append('urlopen_kw') - - for key, val in six.iteritems(local_var_params['kwargs']): - if key not in all_params: - raise TypeError( - "Got an unexpected keyword argument '%s'" - " to method get_resources" % key - ) - local_var_params[key] = val - del local_var_params['kwargs'] - - collection_formats = {} + self._check_operation_params('get_resources', all_params, local_var_params) path_params = {} @@ -95,35 +131,9 @@ def get_resources_with_http_info(self, **kwargs): # noqa: E501,D401,D403 if 'zap_trace_span' in local_var_params: header_params['Zap-Trace-Span'] = local_var_params['zap_trace_span'] # noqa: E501 - form_params = [] - local_var_files = {} - body_params = None # HTTP header `Accept` header_params['Accept'] = self.api_client.select_header_accept( ['application/json']) # noqa: E501 - # Authentication setting - auth_settings = [] # noqa: E501 - - # urlopen optional setting - urlopen_kw = None - if 'urlopen_kw' in kwargs: - urlopen_kw = kwargs['urlopen_kw'] - - return self.api_client.call_api( - '/api/v2/resources', 'GET', - path_params, - query_params, - header_params, - body=body_params, - post_params=form_params, - files=local_var_files, - response_type='list[str]', # noqa: E501 - auth_settings=auth_settings, - async_req=local_var_params.get('async_req'), - _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 - _preload_content=local_var_params.get('_preload_content', True), - _request_timeout=local_var_params.get('_request_timeout'), - collection_formats=collection_formats, - urlopen_kw=urlopen_kw) + return local_var_params, path_params, query_params, header_params, body_params diff --git a/influxdb_client/service/restore_service.py b/influxdb_client/service/restore_service.py index 5196f3e6..ff8ed65f 100644 --- a/influxdb_client/service/restore_service.py +++ b/influxdb_client/service/restore_service.py @@ -14,11 +14,10 @@ import re # noqa: F401 -# python 2 and python 3 compatibility library -import six +from influxdb_client.service._base_service import _BaseService -class RestoreService(object): +class RestoreService(_BaseService): """NOTE: This class is auto generated by OpenAPI Generator. Ref: https://openapi-generator.tech @@ -73,23 +72,65 @@ def post_restore_bucket_id_with_http_info(self, bucket_id, body, **kwargs): # n If the method is called asynchronously, returns the request thread. """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._post_restore_bucket_id_prepare(bucket_id, body, **kwargs) + + return self.api_client.call_api( + '/api/v2/restore/bucket/{bucketID}', 'POST', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='str', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + async def post_restore_bucket_id_async(self, bucket_id, body, **kwargs): # noqa: E501,D401,D403 + """Overwrite storage metadata for a bucket with shard info from a backup.. + + This method makes an asynchronous HTTP request. + + :param async_req bool + :param str bucket_id: The bucket ID. (required) + :param str body: Database info serialized as protobuf. (required) + :param str zap_trace_span: OpenTracing span context + :param str content_type: + :return: str + If the method is called asynchronously, + returns the request thread. + """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._post_restore_bucket_id_prepare(bucket_id, body, **kwargs) + + return await self.api_client.call_api( + '/api/v2/restore/bucket/{bucketID}', 'POST', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='str', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + def _post_restore_bucket_id_prepare(self, bucket_id, body, **kwargs): # noqa: E501,D401,D403 local_var_params = locals() all_params = ['bucket_id', 'body', 'zap_trace_span', 'content_type'] # noqa: E501 - all_params.append('async_req') - all_params.append('_return_http_data_only') - all_params.append('_preload_content') - all_params.append('_request_timeout') - all_params.append('urlopen_kw') - - for key, val in six.iteritems(local_var_params['kwargs']): - if key not in all_params: - raise TypeError( - "Got an unexpected keyword argument '%s'" - " to method post_restore_bucket_id" % key - ) - local_var_params[key] = val - del local_var_params['kwargs'] + self._check_operation_params('post_restore_bucket_id', all_params, local_var_params) # verify the required parameter 'bucket_id' is set if ('bucket_id' not in local_var_params or local_var_params['bucket_id'] is None): @@ -99,8 +140,6 @@ def post_restore_bucket_id_with_http_info(self, bucket_id, body, **kwargs): # n local_var_params['body'] is None): raise ValueError("Missing the required parameter `body` when calling `post_restore_bucket_id`") # noqa: E501 - collection_formats = {} - path_params = {} if 'bucket_id' in local_var_params: path_params['bucketID'] = local_var_params['bucket_id'] # noqa: E501 @@ -113,9 +152,6 @@ def post_restore_bucket_id_with_http_info(self, bucket_id, body, **kwargs): # n if 'content_type' in local_var_params: header_params['Content-Type'] = local_var_params['content_type'] # noqa: E501 - form_params = [] - local_var_files = {} - body_params = None if 'body' in local_var_params: body_params = local_var_params['body'] @@ -127,30 +163,7 @@ def post_restore_bucket_id_with_http_info(self, bucket_id, body, **kwargs): # n header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501 ['text/plain']) # noqa: E501 - # Authentication setting - auth_settings = [] # noqa: E501 - - # urlopen optional setting - urlopen_kw = None - if 'urlopen_kw' in kwargs: - urlopen_kw = kwargs['urlopen_kw'] - - return self.api_client.call_api( - '/api/v2/restore/bucket/{bucketID}', 'POST', - path_params, - query_params, - header_params, - body=body_params, - post_params=form_params, - files=local_var_files, - response_type='str', # noqa: E501 - auth_settings=auth_settings, - async_req=local_var_params.get('async_req'), - _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 - _preload_content=local_var_params.get('_preload_content', True), - _request_timeout=local_var_params.get('_request_timeout'), - collection_formats=collection_formats, - urlopen_kw=urlopen_kw) + return local_var_params, path_params, query_params, header_params, body_params def post_restore_bucket_metadata(self, bucket_metadata_manifest, **kwargs): # noqa: E501,D401,D403 """Create a new bucket pre-seeded with shard info from a backup.. @@ -189,30 +202,68 @@ def post_restore_bucket_metadata_with_http_info(self, bucket_metadata_manifest, If the method is called asynchronously, returns the request thread. """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._post_restore_bucket_metadata_prepare(bucket_metadata_manifest, **kwargs) + + return self.api_client.call_api( + '/api/v2/restore/bucketMetadata', 'POST', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='RestoredBucketMappings', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + async def post_restore_bucket_metadata_async(self, bucket_metadata_manifest, **kwargs): # noqa: E501,D401,D403 + """Create a new bucket pre-seeded with shard info from a backup.. + + This method makes an asynchronous HTTP request. + + :param async_req bool + :param BucketMetadataManifest bucket_metadata_manifest: Metadata manifest for a bucket. (required) + :param str zap_trace_span: OpenTracing span context + :return: RestoredBucketMappings + If the method is called asynchronously, + returns the request thread. + """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._post_restore_bucket_metadata_prepare(bucket_metadata_manifest, **kwargs) + + return await self.api_client.call_api( + '/api/v2/restore/bucketMetadata', 'POST', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='RestoredBucketMappings', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + def _post_restore_bucket_metadata_prepare(self, bucket_metadata_manifest, **kwargs): # noqa: E501,D401,D403 local_var_params = locals() all_params = ['bucket_metadata_manifest', 'zap_trace_span'] # noqa: E501 - all_params.append('async_req') - all_params.append('_return_http_data_only') - all_params.append('_preload_content') - all_params.append('_request_timeout') - all_params.append('urlopen_kw') - - for key, val in six.iteritems(local_var_params['kwargs']): - if key not in all_params: - raise TypeError( - "Got an unexpected keyword argument '%s'" - " to method post_restore_bucket_metadata" % key - ) - local_var_params[key] = val - del local_var_params['kwargs'] + self._check_operation_params('post_restore_bucket_metadata', all_params, local_var_params) # verify the required parameter 'bucket_metadata_manifest' is set if ('bucket_metadata_manifest' not in local_var_params or local_var_params['bucket_metadata_manifest'] is None): raise ValueError("Missing the required parameter `bucket_metadata_manifest` when calling `post_restore_bucket_metadata`") # noqa: E501 - collection_formats = {} - path_params = {} query_params = [] @@ -221,9 +272,6 @@ def post_restore_bucket_metadata_with_http_info(self, bucket_metadata_manifest, if 'zap_trace_span' in local_var_params: header_params['Zap-Trace-Span'] = local_var_params['zap_trace_span'] # noqa: E501 - form_params = [] - local_var_files = {} - body_params = None if 'bucket_metadata_manifest' in local_var_params: body_params = local_var_params['bucket_metadata_manifest'] @@ -235,30 +283,7 @@ def post_restore_bucket_metadata_with_http_info(self, bucket_metadata_manifest, header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501 ['application/json']) # noqa: E501 - # Authentication setting - auth_settings = [] # noqa: E501 - - # urlopen optional setting - urlopen_kw = None - if 'urlopen_kw' in kwargs: - urlopen_kw = kwargs['urlopen_kw'] - - return self.api_client.call_api( - '/api/v2/restore/bucketMetadata', 'POST', - path_params, - query_params, - header_params, - body=body_params, - post_params=form_params, - files=local_var_files, - response_type='RestoredBucketMappings', # noqa: E501 - auth_settings=auth_settings, - async_req=local_var_params.get('async_req'), - _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 - _preload_content=local_var_params.get('_preload_content', True), - _request_timeout=local_var_params.get('_request_timeout'), - collection_formats=collection_formats, - urlopen_kw=urlopen_kw) + return local_var_params, path_params, query_params, header_params, body_params def post_restore_kv(self, body, **kwargs): # noqa: E501,D401,D403 """Overwrite the embedded KV store on the server with a backed-up snapshot.. @@ -301,30 +326,70 @@ def post_restore_kv_with_http_info(self, body, **kwargs): # noqa: E501,D401,D40 If the method is called asynchronously, returns the request thread. """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._post_restore_kv_prepare(body, **kwargs) + + return self.api_client.call_api( + '/api/v2/restore/kv', 'POST', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='PostRestoreKVResponse', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + async def post_restore_kv_async(self, body, **kwargs): # noqa: E501,D401,D403 + """Overwrite the embedded KV store on the server with a backed-up snapshot.. + + This method makes an asynchronous HTTP request. + + :param async_req bool + :param file body: Full KV snapshot. (required) + :param str zap_trace_span: OpenTracing span context + :param str content_encoding: The value tells InfluxDB what compression is applied to the line protocol in the request payload. To make an API request with a GZIP payload, send `Content-Encoding: gzip` as a request header. + :param str content_type: + :return: PostRestoreKVResponse + If the method is called asynchronously, + returns the request thread. + """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._post_restore_kv_prepare(body, **kwargs) + + return await self.api_client.call_api( + '/api/v2/restore/kv', 'POST', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='PostRestoreKVResponse', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + def _post_restore_kv_prepare(self, body, **kwargs): # noqa: E501,D401,D403 local_var_params = locals() all_params = ['body', 'zap_trace_span', 'content_encoding', 'content_type'] # noqa: E501 - all_params.append('async_req') - all_params.append('_return_http_data_only') - all_params.append('_preload_content') - all_params.append('_request_timeout') - all_params.append('urlopen_kw') - - for key, val in six.iteritems(local_var_params['kwargs']): - if key not in all_params: - raise TypeError( - "Got an unexpected keyword argument '%s'" - " to method post_restore_kv" % key - ) - local_var_params[key] = val - del local_var_params['kwargs'] + self._check_operation_params('post_restore_kv', all_params, local_var_params) # verify the required parameter 'body' is set if ('body' not in local_var_params or local_var_params['body'] is None): raise ValueError("Missing the required parameter `body` when calling `post_restore_kv`") # noqa: E501 - collection_formats = {} - path_params = {} query_params = [] @@ -337,9 +402,6 @@ def post_restore_kv_with_http_info(self, body, **kwargs): # noqa: E501,D401,D40 if 'content_type' in local_var_params: header_params['Content-Type'] = local_var_params['content_type'] # noqa: E501 - form_params = [] - local_var_files = {} - body_params = None if 'body' in local_var_params: body_params = local_var_params['body'] @@ -351,30 +413,7 @@ def post_restore_kv_with_http_info(self, body, **kwargs): # noqa: E501,D401,D40 header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501 ['text/plain']) # noqa: E501 - # Authentication setting - auth_settings = [] # noqa: E501 - - # urlopen optional setting - urlopen_kw = None - if 'urlopen_kw' in kwargs: - urlopen_kw = kwargs['urlopen_kw'] - - return self.api_client.call_api( - '/api/v2/restore/kv', 'POST', - path_params, - query_params, - header_params, - body=body_params, - post_params=form_params, - files=local_var_files, - response_type='PostRestoreKVResponse', # noqa: E501 - auth_settings=auth_settings, - async_req=local_var_params.get('async_req'), - _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 - _preload_content=local_var_params.get('_preload_content', True), - _request_timeout=local_var_params.get('_request_timeout'), - collection_formats=collection_formats, - urlopen_kw=urlopen_kw) + return local_var_params, path_params, query_params, header_params, body_params def post_restore_shard_id(self, shard_id, body, **kwargs): # noqa: E501,D401,D403 """Restore a TSM snapshot into a shard.. @@ -419,23 +458,66 @@ def post_restore_shard_id_with_http_info(self, shard_id, body, **kwargs): # noq If the method is called asynchronously, returns the request thread. """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._post_restore_shard_id_prepare(shard_id, body, **kwargs) + + return self.api_client.call_api( + '/api/v2/restore/shards/{shardID}', 'POST', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type=None, # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + async def post_restore_shard_id_async(self, shard_id, body, **kwargs): # noqa: E501,D401,D403 + """Restore a TSM snapshot into a shard.. + + This method makes an asynchronous HTTP request. + + :param async_req bool + :param str shard_id: The shard ID. (required) + :param file body: TSM snapshot. (required) + :param str zap_trace_span: OpenTracing span context + :param str content_encoding: The value tells InfluxDB what compression is applied to the line protocol in the request payload. To make an API request with a GZIP payload, send `Content-Encoding: gzip` as a request header. + :param str content_type: + :return: None + If the method is called asynchronously, + returns the request thread. + """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._post_restore_shard_id_prepare(shard_id, body, **kwargs) + + return await self.api_client.call_api( + '/api/v2/restore/shards/{shardID}', 'POST', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type=None, # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + def _post_restore_shard_id_prepare(self, shard_id, body, **kwargs): # noqa: E501,D401,D403 local_var_params = locals() all_params = ['shard_id', 'body', 'zap_trace_span', 'content_encoding', 'content_type'] # noqa: E501 - all_params.append('async_req') - all_params.append('_return_http_data_only') - all_params.append('_preload_content') - all_params.append('_request_timeout') - all_params.append('urlopen_kw') - - for key, val in six.iteritems(local_var_params['kwargs']): - if key not in all_params: - raise TypeError( - "Got an unexpected keyword argument '%s'" - " to method post_restore_shard_id" % key - ) - local_var_params[key] = val - del local_var_params['kwargs'] + self._check_operation_params('post_restore_shard_id', all_params, local_var_params) # verify the required parameter 'shard_id' is set if ('shard_id' not in local_var_params or local_var_params['shard_id'] is None): @@ -445,8 +527,6 @@ def post_restore_shard_id_with_http_info(self, shard_id, body, **kwargs): # noq local_var_params['body'] is None): raise ValueError("Missing the required parameter `body` when calling `post_restore_shard_id`") # noqa: E501 - collection_formats = {} - path_params = {} if 'shard_id' in local_var_params: path_params['shardID'] = local_var_params['shard_id'] # noqa: E501 @@ -461,9 +541,6 @@ def post_restore_shard_id_with_http_info(self, shard_id, body, **kwargs): # noq if 'content_type' in local_var_params: header_params['Content-Type'] = local_var_params['content_type'] # noqa: E501 - form_params = [] - local_var_files = {} - body_params = None if 'body' in local_var_params: body_params = local_var_params['body'] @@ -475,30 +552,7 @@ def post_restore_shard_id_with_http_info(self, shard_id, body, **kwargs): # noq header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501 ['text/plain']) # noqa: E501 - # Authentication setting - auth_settings = [] # noqa: E501 - - # urlopen optional setting - urlopen_kw = None - if 'urlopen_kw' in kwargs: - urlopen_kw = kwargs['urlopen_kw'] - - return self.api_client.call_api( - '/api/v2/restore/shards/{shardID}', 'POST', - path_params, - query_params, - header_params, - body=body_params, - post_params=form_params, - files=local_var_files, - response_type=None, # noqa: E501 - auth_settings=auth_settings, - async_req=local_var_params.get('async_req'), - _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 - _preload_content=local_var_params.get('_preload_content', True), - _request_timeout=local_var_params.get('_request_timeout'), - collection_formats=collection_formats, - urlopen_kw=urlopen_kw) + return local_var_params, path_params, query_params, header_params, body_params def post_restore_sql(self, body, **kwargs): # noqa: E501,D401,D403 """Overwrite the embedded SQL store on the server with a backed-up snapshot.. @@ -541,30 +595,70 @@ def post_restore_sql_with_http_info(self, body, **kwargs): # noqa: E501,D401,D4 If the method is called asynchronously, returns the request thread. """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._post_restore_sql_prepare(body, **kwargs) + + return self.api_client.call_api( + '/api/v2/restore/sql', 'POST', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type=None, # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + async def post_restore_sql_async(self, body, **kwargs): # noqa: E501,D401,D403 + """Overwrite the embedded SQL store on the server with a backed-up snapshot.. + + This method makes an asynchronous HTTP request. + + :param async_req bool + :param file body: Full SQL snapshot. (required) + :param str zap_trace_span: OpenTracing span context + :param str content_encoding: The value tells InfluxDB what compression is applied to the line protocol in the request payload. To make an API request with a GZIP payload, send `Content-Encoding: gzip` as a request header. + :param str content_type: + :return: None + If the method is called asynchronously, + returns the request thread. + """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._post_restore_sql_prepare(body, **kwargs) + + return await self.api_client.call_api( + '/api/v2/restore/sql', 'POST', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type=None, # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + def _post_restore_sql_prepare(self, body, **kwargs): # noqa: E501,D401,D403 local_var_params = locals() all_params = ['body', 'zap_trace_span', 'content_encoding', 'content_type'] # noqa: E501 - all_params.append('async_req') - all_params.append('_return_http_data_only') - all_params.append('_preload_content') - all_params.append('_request_timeout') - all_params.append('urlopen_kw') - - for key, val in six.iteritems(local_var_params['kwargs']): - if key not in all_params: - raise TypeError( - "Got an unexpected keyword argument '%s'" - " to method post_restore_sql" % key - ) - local_var_params[key] = val - del local_var_params['kwargs'] + self._check_operation_params('post_restore_sql', all_params, local_var_params) # verify the required parameter 'body' is set if ('body' not in local_var_params or local_var_params['body'] is None): raise ValueError("Missing the required parameter `body` when calling `post_restore_sql`") # noqa: E501 - collection_formats = {} - path_params = {} query_params = [] @@ -577,9 +671,6 @@ def post_restore_sql_with_http_info(self, body, **kwargs): # noqa: E501,D401,D4 if 'content_type' in local_var_params: header_params['Content-Type'] = local_var_params['content_type'] # noqa: E501 - form_params = [] - local_var_files = {} - body_params = None if 'body' in local_var_params: body_params = local_var_params['body'] @@ -591,27 +682,4 @@ def post_restore_sql_with_http_info(self, body, **kwargs): # noqa: E501,D401,D4 header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501 ['text/plain']) # noqa: E501 - # Authentication setting - auth_settings = [] # noqa: E501 - - # urlopen optional setting - urlopen_kw = None - if 'urlopen_kw' in kwargs: - urlopen_kw = kwargs['urlopen_kw'] - - return self.api_client.call_api( - '/api/v2/restore/sql', 'POST', - path_params, - query_params, - header_params, - body=body_params, - post_params=form_params, - files=local_var_files, - response_type=None, # noqa: E501 - auth_settings=auth_settings, - async_req=local_var_params.get('async_req'), - _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 - _preload_content=local_var_params.get('_preload_content', True), - _request_timeout=local_var_params.get('_request_timeout'), - collection_formats=collection_formats, - urlopen_kw=urlopen_kw) + return local_var_params, path_params, query_params, header_params, body_params diff --git a/influxdb_client/service/routes_service.py b/influxdb_client/service/routes_service.py index 9a3935c0..6ca7ac39 100644 --- a/influxdb_client/service/routes_service.py +++ b/influxdb_client/service/routes_service.py @@ -14,11 +14,10 @@ import re # noqa: F401 -# python 2 and python 3 compatibility library -import six +from influxdb_client.service._base_service import _BaseService -class RoutesService(object): +class RoutesService(_BaseService): """NOTE: This class is auto generated by OpenAPI Generator. Ref: https://openapi-generator.tech @@ -67,25 +66,62 @@ def get_routes_with_http_info(self, **kwargs): # noqa: E501,D401,D403 If the method is called asynchronously, returns the request thread. """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._get_routes_prepare(**kwargs) + + return self.api_client.call_api( + '/api/v2/', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='Routes', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + async def get_routes_async(self, **kwargs): # noqa: E501,D401,D403 + """List all top level routes. + + This method makes an asynchronous HTTP request. + + :param async_req bool + :param str zap_trace_span: OpenTracing span context + :return: Routes + If the method is called asynchronously, + returns the request thread. + """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._get_routes_prepare(**kwargs) + + return await self.api_client.call_api( + '/api/v2/', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='Routes', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + def _get_routes_prepare(self, **kwargs): # noqa: E501,D401,D403 local_var_params = locals() all_params = ['zap_trace_span'] # noqa: E501 - all_params.append('async_req') - all_params.append('_return_http_data_only') - all_params.append('_preload_content') - all_params.append('_request_timeout') - all_params.append('urlopen_kw') - - for key, val in six.iteritems(local_var_params['kwargs']): - if key not in all_params: - raise TypeError( - "Got an unexpected keyword argument '%s'" - " to method get_routes" % key - ) - local_var_params[key] = val - del local_var_params['kwargs'] - - collection_formats = {} + self._check_operation_params('get_routes', all_params, local_var_params) path_params = {} @@ -95,35 +131,9 @@ def get_routes_with_http_info(self, **kwargs): # noqa: E501,D401,D403 if 'zap_trace_span' in local_var_params: header_params['Zap-Trace-Span'] = local_var_params['zap_trace_span'] # noqa: E501 - form_params = [] - local_var_files = {} - body_params = None # HTTP header `Accept` header_params['Accept'] = self.api_client.select_header_accept( ['application/json']) # noqa: E501 - # Authentication setting - auth_settings = [] # noqa: E501 - - # urlopen optional setting - urlopen_kw = None - if 'urlopen_kw' in kwargs: - urlopen_kw = kwargs['urlopen_kw'] - - return self.api_client.call_api( - '/api/v2/', 'GET', - path_params, - query_params, - header_params, - body=body_params, - post_params=form_params, - files=local_var_files, - response_type='Routes', # noqa: E501 - auth_settings=auth_settings, - async_req=local_var_params.get('async_req'), - _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 - _preload_content=local_var_params.get('_preload_content', True), - _request_timeout=local_var_params.get('_request_timeout'), - collection_formats=collection_formats, - urlopen_kw=urlopen_kw) + return local_var_params, path_params, query_params, header_params, body_params diff --git a/influxdb_client/service/rules_service.py b/influxdb_client/service/rules_service.py index b6e3eb7e..4678d8f9 100644 --- a/influxdb_client/service/rules_service.py +++ b/influxdb_client/service/rules_service.py @@ -14,11 +14,10 @@ import re # noqa: F401 -# python 2 and python 3 compatibility library -import six +from influxdb_client.service._base_service import _BaseService -class RulesService(object): +class RulesService(_BaseService): """NOTE: This class is auto generated by OpenAPI Generator. Ref: https://openapi-generator.tech @@ -69,30 +68,68 @@ def get_notification_rules_id_query_with_http_info(self, rule_id, **kwargs): # If the method is called asynchronously, returns the request thread. """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._get_notification_rules_id_query_prepare(rule_id, **kwargs) + + return self.api_client.call_api( + '/api/v2/notificationRules/{ruleID}/query', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='FluxResponse', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + async def get_notification_rules_id_query_async(self, rule_id, **kwargs): # noqa: E501,D401,D403 + """Retrieve a notification rule query. + + This method makes an asynchronous HTTP request. + + :param async_req bool + :param str rule_id: The notification rule ID. (required) + :param str zap_trace_span: OpenTracing span context + :return: FluxResponse + If the method is called asynchronously, + returns the request thread. + """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._get_notification_rules_id_query_prepare(rule_id, **kwargs) + + return await self.api_client.call_api( + '/api/v2/notificationRules/{ruleID}/query', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='FluxResponse', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + def _get_notification_rules_id_query_prepare(self, rule_id, **kwargs): # noqa: E501,D401,D403 local_var_params = locals() all_params = ['rule_id', 'zap_trace_span'] # noqa: E501 - all_params.append('async_req') - all_params.append('_return_http_data_only') - all_params.append('_preload_content') - all_params.append('_request_timeout') - all_params.append('urlopen_kw') - - for key, val in six.iteritems(local_var_params['kwargs']): - if key not in all_params: - raise TypeError( - "Got an unexpected keyword argument '%s'" - " to method get_notification_rules_id_query" % key - ) - local_var_params[key] = val - del local_var_params['kwargs'] + self._check_operation_params('get_notification_rules_id_query', all_params, local_var_params) # verify the required parameter 'rule_id' is set if ('rule_id' not in local_var_params or local_var_params['rule_id'] is None): raise ValueError("Missing the required parameter `rule_id` when calling `get_notification_rules_id_query`") # noqa: E501 - collection_formats = {} - path_params = {} if 'rule_id' in local_var_params: path_params['ruleID'] = local_var_params['rule_id'] # noqa: E501 @@ -103,35 +140,9 @@ def get_notification_rules_id_query_with_http_info(self, rule_id, **kwargs): # if 'zap_trace_span' in local_var_params: header_params['Zap-Trace-Span'] = local_var_params['zap_trace_span'] # noqa: E501 - form_params = [] - local_var_files = {} - body_params = None # HTTP header `Accept` header_params['Accept'] = self.api_client.select_header_accept( ['application/json']) # noqa: E501 - # Authentication setting - auth_settings = [] # noqa: E501 - - # urlopen optional setting - urlopen_kw = None - if 'urlopen_kw' in kwargs: - urlopen_kw = kwargs['urlopen_kw'] - - return self.api_client.call_api( - '/api/v2/notificationRules/{ruleID}/query', 'GET', - path_params, - query_params, - header_params, - body=body_params, - post_params=form_params, - files=local_var_files, - response_type='FluxResponse', # noqa: E501 - auth_settings=auth_settings, - async_req=local_var_params.get('async_req'), - _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 - _preload_content=local_var_params.get('_preload_content', True), - _request_timeout=local_var_params.get('_request_timeout'), - collection_formats=collection_formats, - urlopen_kw=urlopen_kw) + return local_var_params, path_params, query_params, header_params, body_params diff --git a/influxdb_client/service/scraper_targets_service.py b/influxdb_client/service/scraper_targets_service.py index 922e7b35..1dd2add5 100644 --- a/influxdb_client/service/scraper_targets_service.py +++ b/influxdb_client/service/scraper_targets_service.py @@ -14,11 +14,10 @@ import re # noqa: F401 -# python 2 and python 3 compatibility library -import six +from influxdb_client.service._base_service import _BaseService -class ScraperTargetsService(object): +class ScraperTargetsService(_BaseService): """NOTE: This class is auto generated by OpenAPI Generator. Ref: https://openapi-generator.tech @@ -69,30 +68,68 @@ def delete_scrapers_id_with_http_info(self, scraper_target_id, **kwargs): # noq If the method is called asynchronously, returns the request thread. """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._delete_scrapers_id_prepare(scraper_target_id, **kwargs) + + return self.api_client.call_api( + '/api/v2/scrapers/{scraperTargetID}', 'DELETE', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type=None, # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + async def delete_scrapers_id_async(self, scraper_target_id, **kwargs): # noqa: E501,D401,D403 + """Delete a scraper target. + + This method makes an asynchronous HTTP request. + + :param async_req bool + :param str scraper_target_id: The identifier of the scraper target. (required) + :param str zap_trace_span: OpenTracing span context + :return: None + If the method is called asynchronously, + returns the request thread. + """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._delete_scrapers_id_prepare(scraper_target_id, **kwargs) + + return await self.api_client.call_api( + '/api/v2/scrapers/{scraperTargetID}', 'DELETE', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type=None, # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + def _delete_scrapers_id_prepare(self, scraper_target_id, **kwargs): # noqa: E501,D401,D403 local_var_params = locals() all_params = ['scraper_target_id', 'zap_trace_span'] # noqa: E501 - all_params.append('async_req') - all_params.append('_return_http_data_only') - all_params.append('_preload_content') - all_params.append('_request_timeout') - all_params.append('urlopen_kw') - - for key, val in six.iteritems(local_var_params['kwargs']): - if key not in all_params: - raise TypeError( - "Got an unexpected keyword argument '%s'" - " to method delete_scrapers_id" % key - ) - local_var_params[key] = val - del local_var_params['kwargs'] + self._check_operation_params('delete_scrapers_id', all_params, local_var_params) # verify the required parameter 'scraper_target_id' is set if ('scraper_target_id' not in local_var_params or local_var_params['scraper_target_id'] is None): raise ValueError("Missing the required parameter `scraper_target_id` when calling `delete_scrapers_id`") # noqa: E501 - collection_formats = {} - path_params = {} if 'scraper_target_id' in local_var_params: path_params['scraperTargetID'] = local_var_params['scraper_target_id'] # noqa: E501 @@ -103,38 +140,12 @@ def delete_scrapers_id_with_http_info(self, scraper_target_id, **kwargs): # noq if 'zap_trace_span' in local_var_params: header_params['Zap-Trace-Span'] = local_var_params['zap_trace_span'] # noqa: E501 - form_params = [] - local_var_files = {} - body_params = None # HTTP header `Accept` header_params['Accept'] = self.api_client.select_header_accept( ['application/json']) # noqa: E501 - # Authentication setting - auth_settings = [] # noqa: E501 - - # urlopen optional setting - urlopen_kw = None - if 'urlopen_kw' in kwargs: - urlopen_kw = kwargs['urlopen_kw'] - - return self.api_client.call_api( - '/api/v2/scrapers/{scraperTargetID}', 'DELETE', - path_params, - query_params, - header_params, - body=body_params, - post_params=form_params, - files=local_var_files, - response_type=None, # noqa: E501 - auth_settings=auth_settings, - async_req=local_var_params.get('async_req'), - _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 - _preload_content=local_var_params.get('_preload_content', True), - _request_timeout=local_var_params.get('_request_timeout'), - collection_formats=collection_formats, - urlopen_kw=urlopen_kw) + return local_var_params, path_params, query_params, header_params, body_params def delete_scrapers_id_labels_id(self, scraper_target_id, label_id, **kwargs): # noqa: E501,D401,D403 """Delete a label from a scraper target. @@ -175,23 +186,64 @@ def delete_scrapers_id_labels_id_with_http_info(self, scraper_target_id, label_i If the method is called asynchronously, returns the request thread. """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._delete_scrapers_id_labels_id_prepare(scraper_target_id, label_id, **kwargs) + + return self.api_client.call_api( + '/api/v2/scrapers/{scraperTargetID}/labels/{labelID}', 'DELETE', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type=None, # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + async def delete_scrapers_id_labels_id_async(self, scraper_target_id, label_id, **kwargs): # noqa: E501,D401,D403 + """Delete a label from a scraper target. + + This method makes an asynchronous HTTP request. + + :param async_req bool + :param str scraper_target_id: The scraper target ID. (required) + :param str label_id: The label ID. (required) + :param str zap_trace_span: OpenTracing span context + :return: None + If the method is called asynchronously, + returns the request thread. + """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._delete_scrapers_id_labels_id_prepare(scraper_target_id, label_id, **kwargs) + + return await self.api_client.call_api( + '/api/v2/scrapers/{scraperTargetID}/labels/{labelID}', 'DELETE', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type=None, # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + def _delete_scrapers_id_labels_id_prepare(self, scraper_target_id, label_id, **kwargs): # noqa: E501,D401,D403 local_var_params = locals() all_params = ['scraper_target_id', 'label_id', 'zap_trace_span'] # noqa: E501 - all_params.append('async_req') - all_params.append('_return_http_data_only') - all_params.append('_preload_content') - all_params.append('_request_timeout') - all_params.append('urlopen_kw') - - for key, val in six.iteritems(local_var_params['kwargs']): - if key not in all_params: - raise TypeError( - "Got an unexpected keyword argument '%s'" - " to method delete_scrapers_id_labels_id" % key - ) - local_var_params[key] = val - del local_var_params['kwargs'] + self._check_operation_params('delete_scrapers_id_labels_id', all_params, local_var_params) # verify the required parameter 'scraper_target_id' is set if ('scraper_target_id' not in local_var_params or local_var_params['scraper_target_id'] is None): @@ -201,8 +253,6 @@ def delete_scrapers_id_labels_id_with_http_info(self, scraper_target_id, label_i local_var_params['label_id'] is None): raise ValueError("Missing the required parameter `label_id` when calling `delete_scrapers_id_labels_id`") # noqa: E501 - collection_formats = {} - path_params = {} if 'scraper_target_id' in local_var_params: path_params['scraperTargetID'] = local_var_params['scraper_target_id'] # noqa: E501 @@ -215,38 +265,12 @@ def delete_scrapers_id_labels_id_with_http_info(self, scraper_target_id, label_i if 'zap_trace_span' in local_var_params: header_params['Zap-Trace-Span'] = local_var_params['zap_trace_span'] # noqa: E501 - form_params = [] - local_var_files = {} - body_params = None # HTTP header `Accept` header_params['Accept'] = self.api_client.select_header_accept( ['application/json']) # noqa: E501 - # Authentication setting - auth_settings = [] # noqa: E501 - - # urlopen optional setting - urlopen_kw = None - if 'urlopen_kw' in kwargs: - urlopen_kw = kwargs['urlopen_kw'] - - return self.api_client.call_api( - '/api/v2/scrapers/{scraperTargetID}/labels/{labelID}', 'DELETE', - path_params, - query_params, - header_params, - body=body_params, - post_params=form_params, - files=local_var_files, - response_type=None, # noqa: E501 - auth_settings=auth_settings, - async_req=local_var_params.get('async_req'), - _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 - _preload_content=local_var_params.get('_preload_content', True), - _request_timeout=local_var_params.get('_request_timeout'), - collection_formats=collection_formats, - urlopen_kw=urlopen_kw) + return local_var_params, path_params, query_params, header_params, body_params def delete_scrapers_id_members_id(self, user_id, scraper_target_id, **kwargs): # noqa: E501,D401,D403 """Remove a member from a scraper target. @@ -287,23 +311,64 @@ def delete_scrapers_id_members_id_with_http_info(self, user_id, scraper_target_i If the method is called asynchronously, returns the request thread. """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._delete_scrapers_id_members_id_prepare(user_id, scraper_target_id, **kwargs) + + return self.api_client.call_api( + '/api/v2/scrapers/{scraperTargetID}/members/{userID}', 'DELETE', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type=None, # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + async def delete_scrapers_id_members_id_async(self, user_id, scraper_target_id, **kwargs): # noqa: E501,D401,D403 + """Remove a member from a scraper target. + + This method makes an asynchronous HTTP request. + + :param async_req bool + :param str user_id: The ID of member to remove. (required) + :param str scraper_target_id: The scraper target ID. (required) + :param str zap_trace_span: OpenTracing span context + :return: None + If the method is called asynchronously, + returns the request thread. + """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._delete_scrapers_id_members_id_prepare(user_id, scraper_target_id, **kwargs) + + return await self.api_client.call_api( + '/api/v2/scrapers/{scraperTargetID}/members/{userID}', 'DELETE', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type=None, # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + def _delete_scrapers_id_members_id_prepare(self, user_id, scraper_target_id, **kwargs): # noqa: E501,D401,D403 local_var_params = locals() all_params = ['user_id', 'scraper_target_id', 'zap_trace_span'] # noqa: E501 - all_params.append('async_req') - all_params.append('_return_http_data_only') - all_params.append('_preload_content') - all_params.append('_request_timeout') - all_params.append('urlopen_kw') - - for key, val in six.iteritems(local_var_params['kwargs']): - if key not in all_params: - raise TypeError( - "Got an unexpected keyword argument '%s'" - " to method delete_scrapers_id_members_id" % key - ) - local_var_params[key] = val - del local_var_params['kwargs'] + self._check_operation_params('delete_scrapers_id_members_id', all_params, local_var_params) # verify the required parameter 'user_id' is set if ('user_id' not in local_var_params or local_var_params['user_id'] is None): @@ -313,8 +378,6 @@ def delete_scrapers_id_members_id_with_http_info(self, user_id, scraper_target_i local_var_params['scraper_target_id'] is None): raise ValueError("Missing the required parameter `scraper_target_id` when calling `delete_scrapers_id_members_id`") # noqa: E501 - collection_formats = {} - path_params = {} if 'user_id' in local_var_params: path_params['userID'] = local_var_params['user_id'] # noqa: E501 @@ -327,38 +390,12 @@ def delete_scrapers_id_members_id_with_http_info(self, user_id, scraper_target_i if 'zap_trace_span' in local_var_params: header_params['Zap-Trace-Span'] = local_var_params['zap_trace_span'] # noqa: E501 - form_params = [] - local_var_files = {} - body_params = None # HTTP header `Accept` header_params['Accept'] = self.api_client.select_header_accept( ['application/json']) # noqa: E501 - # Authentication setting - auth_settings = [] # noqa: E501 - - # urlopen optional setting - urlopen_kw = None - if 'urlopen_kw' in kwargs: - urlopen_kw = kwargs['urlopen_kw'] - - return self.api_client.call_api( - '/api/v2/scrapers/{scraperTargetID}/members/{userID}', 'DELETE', - path_params, - query_params, - header_params, - body=body_params, - post_params=form_params, - files=local_var_files, - response_type=None, # noqa: E501 - auth_settings=auth_settings, - async_req=local_var_params.get('async_req'), - _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 - _preload_content=local_var_params.get('_preload_content', True), - _request_timeout=local_var_params.get('_request_timeout'), - collection_formats=collection_formats, - urlopen_kw=urlopen_kw) + return local_var_params, path_params, query_params, header_params, body_params def delete_scrapers_id_owners_id(self, user_id, scraper_target_id, **kwargs): # noqa: E501,D401,D403 """Remove an owner from a scraper target. @@ -399,23 +436,64 @@ def delete_scrapers_id_owners_id_with_http_info(self, user_id, scraper_target_id If the method is called asynchronously, returns the request thread. """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._delete_scrapers_id_owners_id_prepare(user_id, scraper_target_id, **kwargs) + + return self.api_client.call_api( + '/api/v2/scrapers/{scraperTargetID}/owners/{userID}', 'DELETE', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type=None, # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + async def delete_scrapers_id_owners_id_async(self, user_id, scraper_target_id, **kwargs): # noqa: E501,D401,D403 + """Remove an owner from a scraper target. + + This method makes an asynchronous HTTP request. + + :param async_req bool + :param str user_id: The ID of owner to remove. (required) + :param str scraper_target_id: The scraper target ID. (required) + :param str zap_trace_span: OpenTracing span context + :return: None + If the method is called asynchronously, + returns the request thread. + """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._delete_scrapers_id_owners_id_prepare(user_id, scraper_target_id, **kwargs) + + return await self.api_client.call_api( + '/api/v2/scrapers/{scraperTargetID}/owners/{userID}', 'DELETE', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type=None, # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + def _delete_scrapers_id_owners_id_prepare(self, user_id, scraper_target_id, **kwargs): # noqa: E501,D401,D403 local_var_params = locals() all_params = ['user_id', 'scraper_target_id', 'zap_trace_span'] # noqa: E501 - all_params.append('async_req') - all_params.append('_return_http_data_only') - all_params.append('_preload_content') - all_params.append('_request_timeout') - all_params.append('urlopen_kw') - - for key, val in six.iteritems(local_var_params['kwargs']): - if key not in all_params: - raise TypeError( - "Got an unexpected keyword argument '%s'" - " to method delete_scrapers_id_owners_id" % key - ) - local_var_params[key] = val - del local_var_params['kwargs'] + self._check_operation_params('delete_scrapers_id_owners_id', all_params, local_var_params) # verify the required parameter 'user_id' is set if ('user_id' not in local_var_params or local_var_params['user_id'] is None): @@ -425,8 +503,6 @@ def delete_scrapers_id_owners_id_with_http_info(self, user_id, scraper_target_id local_var_params['scraper_target_id'] is None): raise ValueError("Missing the required parameter `scraper_target_id` when calling `delete_scrapers_id_owners_id`") # noqa: E501 - collection_formats = {} - path_params = {} if 'user_id' in local_var_params: path_params['userID'] = local_var_params['user_id'] # noqa: E501 @@ -439,38 +515,12 @@ def delete_scrapers_id_owners_id_with_http_info(self, user_id, scraper_target_id if 'zap_trace_span' in local_var_params: header_params['Zap-Trace-Span'] = local_var_params['zap_trace_span'] # noqa: E501 - form_params = [] - local_var_files = {} - body_params = None # HTTP header `Accept` header_params['Accept'] = self.api_client.select_header_accept( ['application/json']) # noqa: E501 - # Authentication setting - auth_settings = [] # noqa: E501 - - # urlopen optional setting - urlopen_kw = None - if 'urlopen_kw' in kwargs: - urlopen_kw = kwargs['urlopen_kw'] - - return self.api_client.call_api( - '/api/v2/scrapers/{scraperTargetID}/owners/{userID}', 'DELETE', - path_params, - query_params, - header_params, - body=body_params, - post_params=form_params, - files=local_var_files, - response_type=None, # noqa: E501 - auth_settings=auth_settings, - async_req=local_var_params.get('async_req'), - _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 - _preload_content=local_var_params.get('_preload_content', True), - _request_timeout=local_var_params.get('_request_timeout'), - collection_formats=collection_formats, - urlopen_kw=urlopen_kw) + return local_var_params, path_params, query_params, header_params, body_params def get_scrapers(self, **kwargs): # noqa: E501,D401,D403 """List all scraper targets. @@ -515,25 +565,66 @@ def get_scrapers_with_http_info(self, **kwargs): # noqa: E501,D401,D403 If the method is called asynchronously, returns the request thread. """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._get_scrapers_prepare(**kwargs) + + return self.api_client.call_api( + '/api/v2/scrapers', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='ScraperTargetResponses', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + async def get_scrapers_async(self, **kwargs): # noqa: E501,D401,D403 + """List all scraper targets. + + This method makes an asynchronous HTTP request. + + :param async_req bool + :param str zap_trace_span: OpenTracing span context + :param str name: Specifies the name of the scraper target. + :param list[str] id: List of scraper target IDs to return. If both `id` and `owner` are specified, only `id` is used. + :param str org_id: Specifies the organization ID of the scraper target. + :param str org: Specifies the organization name of the scraper target. + :return: ScraperTargetResponses + If the method is called asynchronously, + returns the request thread. + """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._get_scrapers_prepare(**kwargs) + + return await self.api_client.call_api( + '/api/v2/scrapers', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='ScraperTargetResponses', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + def _get_scrapers_prepare(self, **kwargs): # noqa: E501,D401,D403 local_var_params = locals() all_params = ['zap_trace_span', 'name', 'id', 'org_id', 'org'] # noqa: E501 - all_params.append('async_req') - all_params.append('_return_http_data_only') - all_params.append('_preload_content') - all_params.append('_request_timeout') - all_params.append('urlopen_kw') - - for key, val in six.iteritems(local_var_params['kwargs']): - if key not in all_params: - raise TypeError( - "Got an unexpected keyword argument '%s'" - " to method get_scrapers" % key - ) - local_var_params[key] = val - del local_var_params['kwargs'] - - collection_formats = {} + self._check_operation_params('get_scrapers', all_params, local_var_params) path_params = {} @@ -542,7 +633,6 @@ def get_scrapers_with_http_info(self, **kwargs): # noqa: E501,D401,D403 query_params.append(('name', local_var_params['name'])) # noqa: E501 if 'id' in local_var_params: query_params.append(('id', local_var_params['id'])) # noqa: E501 - collection_formats['id'] = 'multi' # noqa: E501 if 'org_id' in local_var_params: query_params.append(('orgID', local_var_params['org_id'])) # noqa: E501 if 'org' in local_var_params: @@ -552,38 +642,12 @@ def get_scrapers_with_http_info(self, **kwargs): # noqa: E501,D401,D403 if 'zap_trace_span' in local_var_params: header_params['Zap-Trace-Span'] = local_var_params['zap_trace_span'] # noqa: E501 - form_params = [] - local_var_files = {} - body_params = None # HTTP header `Accept` header_params['Accept'] = self.api_client.select_header_accept( ['application/json']) # noqa: E501 - # Authentication setting - auth_settings = [] # noqa: E501 - - # urlopen optional setting - urlopen_kw = None - if 'urlopen_kw' in kwargs: - urlopen_kw = kwargs['urlopen_kw'] - - return self.api_client.call_api( - '/api/v2/scrapers', 'GET', - path_params, - query_params, - header_params, - body=body_params, - post_params=form_params, - files=local_var_files, - response_type='ScraperTargetResponses', # noqa: E501 - auth_settings=auth_settings, - async_req=local_var_params.get('async_req'), - _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 - _preload_content=local_var_params.get('_preload_content', True), - _request_timeout=local_var_params.get('_request_timeout'), - collection_formats=collection_formats, - urlopen_kw=urlopen_kw) + return local_var_params, path_params, query_params, header_params, body_params def get_scrapers_id(self, scraper_target_id, **kwargs): # noqa: E501,D401,D403 """Retrieve a scraper target. @@ -622,30 +686,68 @@ def get_scrapers_id_with_http_info(self, scraper_target_id, **kwargs): # noqa: If the method is called asynchronously, returns the request thread. """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._get_scrapers_id_prepare(scraper_target_id, **kwargs) + + return self.api_client.call_api( + '/api/v2/scrapers/{scraperTargetID}', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='ScraperTargetResponse', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + async def get_scrapers_id_async(self, scraper_target_id, **kwargs): # noqa: E501,D401,D403 + """Retrieve a scraper target. + + This method makes an asynchronous HTTP request. + + :param async_req bool + :param str scraper_target_id: The identifier of the scraper target. (required) + :param str zap_trace_span: OpenTracing span context + :return: ScraperTargetResponse + If the method is called asynchronously, + returns the request thread. + """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._get_scrapers_id_prepare(scraper_target_id, **kwargs) + + return await self.api_client.call_api( + '/api/v2/scrapers/{scraperTargetID}', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='ScraperTargetResponse', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + def _get_scrapers_id_prepare(self, scraper_target_id, **kwargs): # noqa: E501,D401,D403 local_var_params = locals() all_params = ['scraper_target_id', 'zap_trace_span'] # noqa: E501 - all_params.append('async_req') - all_params.append('_return_http_data_only') - all_params.append('_preload_content') - all_params.append('_request_timeout') - all_params.append('urlopen_kw') - - for key, val in six.iteritems(local_var_params['kwargs']): - if key not in all_params: - raise TypeError( - "Got an unexpected keyword argument '%s'" - " to method get_scrapers_id" % key - ) - local_var_params[key] = val - del local_var_params['kwargs'] + self._check_operation_params('get_scrapers_id', all_params, local_var_params) # verify the required parameter 'scraper_target_id' is set if ('scraper_target_id' not in local_var_params or local_var_params['scraper_target_id'] is None): raise ValueError("Missing the required parameter `scraper_target_id` when calling `get_scrapers_id`") # noqa: E501 - collection_formats = {} - path_params = {} if 'scraper_target_id' in local_var_params: path_params['scraperTargetID'] = local_var_params['scraper_target_id'] # noqa: E501 @@ -656,38 +758,12 @@ def get_scrapers_id_with_http_info(self, scraper_target_id, **kwargs): # noqa: if 'zap_trace_span' in local_var_params: header_params['Zap-Trace-Span'] = local_var_params['zap_trace_span'] # noqa: E501 - form_params = [] - local_var_files = {} - body_params = None # HTTP header `Accept` header_params['Accept'] = self.api_client.select_header_accept( ['application/json']) # noqa: E501 - # Authentication setting - auth_settings = [] # noqa: E501 - - # urlopen optional setting - urlopen_kw = None - if 'urlopen_kw' in kwargs: - urlopen_kw = kwargs['urlopen_kw'] - - return self.api_client.call_api( - '/api/v2/scrapers/{scraperTargetID}', 'GET', - path_params, - query_params, - header_params, - body=body_params, - post_params=form_params, - files=local_var_files, - response_type='ScraperTargetResponse', # noqa: E501 - auth_settings=auth_settings, - async_req=local_var_params.get('async_req'), - _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 - _preload_content=local_var_params.get('_preload_content', True), - _request_timeout=local_var_params.get('_request_timeout'), - collection_formats=collection_formats, - urlopen_kw=urlopen_kw) + return local_var_params, path_params, query_params, header_params, body_params def get_scrapers_id_labels(self, scraper_target_id, **kwargs): # noqa: E501,D401,D403 """List all labels for a scraper target. @@ -726,30 +802,68 @@ def get_scrapers_id_labels_with_http_info(self, scraper_target_id, **kwargs): # If the method is called asynchronously, returns the request thread. """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._get_scrapers_id_labels_prepare(scraper_target_id, **kwargs) + + return self.api_client.call_api( + '/api/v2/scrapers/{scraperTargetID}/labels', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='LabelsResponse', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + async def get_scrapers_id_labels_async(self, scraper_target_id, **kwargs): # noqa: E501,D401,D403 + """List all labels for a scraper target. + + This method makes an asynchronous HTTP request. + + :param async_req bool + :param str scraper_target_id: The scraper target ID. (required) + :param str zap_trace_span: OpenTracing span context + :return: LabelsResponse + If the method is called asynchronously, + returns the request thread. + """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._get_scrapers_id_labels_prepare(scraper_target_id, **kwargs) + + return await self.api_client.call_api( + '/api/v2/scrapers/{scraperTargetID}/labels', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='LabelsResponse', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + def _get_scrapers_id_labels_prepare(self, scraper_target_id, **kwargs): # noqa: E501,D401,D403 local_var_params = locals() all_params = ['scraper_target_id', 'zap_trace_span'] # noqa: E501 - all_params.append('async_req') - all_params.append('_return_http_data_only') - all_params.append('_preload_content') - all_params.append('_request_timeout') - all_params.append('urlopen_kw') - - for key, val in six.iteritems(local_var_params['kwargs']): - if key not in all_params: - raise TypeError( - "Got an unexpected keyword argument '%s'" - " to method get_scrapers_id_labels" % key - ) - local_var_params[key] = val - del local_var_params['kwargs'] + self._check_operation_params('get_scrapers_id_labels', all_params, local_var_params) # verify the required parameter 'scraper_target_id' is set if ('scraper_target_id' not in local_var_params or local_var_params['scraper_target_id'] is None): raise ValueError("Missing the required parameter `scraper_target_id` when calling `get_scrapers_id_labels`") # noqa: E501 - collection_formats = {} - path_params = {} if 'scraper_target_id' in local_var_params: path_params['scraperTargetID'] = local_var_params['scraper_target_id'] # noqa: E501 @@ -760,38 +874,12 @@ def get_scrapers_id_labels_with_http_info(self, scraper_target_id, **kwargs): # if 'zap_trace_span' in local_var_params: header_params['Zap-Trace-Span'] = local_var_params['zap_trace_span'] # noqa: E501 - form_params = [] - local_var_files = {} - body_params = None # HTTP header `Accept` header_params['Accept'] = self.api_client.select_header_accept( ['application/json']) # noqa: E501 - # Authentication setting - auth_settings = [] # noqa: E501 - - # urlopen optional setting - urlopen_kw = None - if 'urlopen_kw' in kwargs: - urlopen_kw = kwargs['urlopen_kw'] - - return self.api_client.call_api( - '/api/v2/scrapers/{scraperTargetID}/labels', 'GET', - path_params, - query_params, - header_params, - body=body_params, - post_params=form_params, - files=local_var_files, - response_type='LabelsResponse', # noqa: E501 - auth_settings=auth_settings, - async_req=local_var_params.get('async_req'), - _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 - _preload_content=local_var_params.get('_preload_content', True), - _request_timeout=local_var_params.get('_request_timeout'), - collection_formats=collection_formats, - urlopen_kw=urlopen_kw) + return local_var_params, path_params, query_params, header_params, body_params def get_scrapers_id_members(self, scraper_target_id, **kwargs): # noqa: E501,D401,D403 """List all users with member privileges for a scraper target. @@ -830,30 +918,68 @@ def get_scrapers_id_members_with_http_info(self, scraper_target_id, **kwargs): If the method is called asynchronously, returns the request thread. """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._get_scrapers_id_members_prepare(scraper_target_id, **kwargs) + + return self.api_client.call_api( + '/api/v2/scrapers/{scraperTargetID}/members', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='ResourceMembers', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + async def get_scrapers_id_members_async(self, scraper_target_id, **kwargs): # noqa: E501,D401,D403 + """List all users with member privileges for a scraper target. + + This method makes an asynchronous HTTP request. + + :param async_req bool + :param str scraper_target_id: The scraper target ID. (required) + :param str zap_trace_span: OpenTracing span context + :return: ResourceMembers + If the method is called asynchronously, + returns the request thread. + """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._get_scrapers_id_members_prepare(scraper_target_id, **kwargs) + + return await self.api_client.call_api( + '/api/v2/scrapers/{scraperTargetID}/members', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='ResourceMembers', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + def _get_scrapers_id_members_prepare(self, scraper_target_id, **kwargs): # noqa: E501,D401,D403 local_var_params = locals() all_params = ['scraper_target_id', 'zap_trace_span'] # noqa: E501 - all_params.append('async_req') - all_params.append('_return_http_data_only') - all_params.append('_preload_content') - all_params.append('_request_timeout') - all_params.append('urlopen_kw') - - for key, val in six.iteritems(local_var_params['kwargs']): - if key not in all_params: - raise TypeError( - "Got an unexpected keyword argument '%s'" - " to method get_scrapers_id_members" % key - ) - local_var_params[key] = val - del local_var_params['kwargs'] + self._check_operation_params('get_scrapers_id_members', all_params, local_var_params) # verify the required parameter 'scraper_target_id' is set if ('scraper_target_id' not in local_var_params or local_var_params['scraper_target_id'] is None): raise ValueError("Missing the required parameter `scraper_target_id` when calling `get_scrapers_id_members`") # noqa: E501 - collection_formats = {} - path_params = {} if 'scraper_target_id' in local_var_params: path_params['scraperTargetID'] = local_var_params['scraper_target_id'] # noqa: E501 @@ -864,38 +990,12 @@ def get_scrapers_id_members_with_http_info(self, scraper_target_id, **kwargs): if 'zap_trace_span' in local_var_params: header_params['Zap-Trace-Span'] = local_var_params['zap_trace_span'] # noqa: E501 - form_params = [] - local_var_files = {} - body_params = None # HTTP header `Accept` header_params['Accept'] = self.api_client.select_header_accept( ['application/json']) # noqa: E501 - # Authentication setting - auth_settings = [] # noqa: E501 - - # urlopen optional setting - urlopen_kw = None - if 'urlopen_kw' in kwargs: - urlopen_kw = kwargs['urlopen_kw'] - - return self.api_client.call_api( - '/api/v2/scrapers/{scraperTargetID}/members', 'GET', - path_params, - query_params, - header_params, - body=body_params, - post_params=form_params, - files=local_var_files, - response_type='ResourceMembers', # noqa: E501 - auth_settings=auth_settings, - async_req=local_var_params.get('async_req'), - _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 - _preload_content=local_var_params.get('_preload_content', True), - _request_timeout=local_var_params.get('_request_timeout'), - collection_formats=collection_formats, - urlopen_kw=urlopen_kw) + return local_var_params, path_params, query_params, header_params, body_params def get_scrapers_id_owners(self, scraper_target_id, **kwargs): # noqa: E501,D401,D403 """List all owners of a scraper target. @@ -934,30 +1034,68 @@ def get_scrapers_id_owners_with_http_info(self, scraper_target_id, **kwargs): # If the method is called asynchronously, returns the request thread. """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._get_scrapers_id_owners_prepare(scraper_target_id, **kwargs) + + return self.api_client.call_api( + '/api/v2/scrapers/{scraperTargetID}/owners', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='ResourceOwners', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + async def get_scrapers_id_owners_async(self, scraper_target_id, **kwargs): # noqa: E501,D401,D403 + """List all owners of a scraper target. + + This method makes an asynchronous HTTP request. + + :param async_req bool + :param str scraper_target_id: The scraper target ID. (required) + :param str zap_trace_span: OpenTracing span context + :return: ResourceOwners + If the method is called asynchronously, + returns the request thread. + """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._get_scrapers_id_owners_prepare(scraper_target_id, **kwargs) + + return await self.api_client.call_api( + '/api/v2/scrapers/{scraperTargetID}/owners', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='ResourceOwners', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + def _get_scrapers_id_owners_prepare(self, scraper_target_id, **kwargs): # noqa: E501,D401,D403 local_var_params = locals() all_params = ['scraper_target_id', 'zap_trace_span'] # noqa: E501 - all_params.append('async_req') - all_params.append('_return_http_data_only') - all_params.append('_preload_content') - all_params.append('_request_timeout') - all_params.append('urlopen_kw') - - for key, val in six.iteritems(local_var_params['kwargs']): - if key not in all_params: - raise TypeError( - "Got an unexpected keyword argument '%s'" - " to method get_scrapers_id_owners" % key - ) - local_var_params[key] = val - del local_var_params['kwargs'] + self._check_operation_params('get_scrapers_id_owners', all_params, local_var_params) # verify the required parameter 'scraper_target_id' is set if ('scraper_target_id' not in local_var_params or local_var_params['scraper_target_id'] is None): raise ValueError("Missing the required parameter `scraper_target_id` when calling `get_scrapers_id_owners`") # noqa: E501 - collection_formats = {} - path_params = {} if 'scraper_target_id' in local_var_params: path_params['scraperTargetID'] = local_var_params['scraper_target_id'] # noqa: E501 @@ -968,38 +1106,12 @@ def get_scrapers_id_owners_with_http_info(self, scraper_target_id, **kwargs): # if 'zap_trace_span' in local_var_params: header_params['Zap-Trace-Span'] = local_var_params['zap_trace_span'] # noqa: E501 - form_params = [] - local_var_files = {} - body_params = None # HTTP header `Accept` header_params['Accept'] = self.api_client.select_header_accept( - ['application/json']) # noqa: E501 - - # Authentication setting - auth_settings = [] # noqa: E501 - - # urlopen optional setting - urlopen_kw = None - if 'urlopen_kw' in kwargs: - urlopen_kw = kwargs['urlopen_kw'] - - return self.api_client.call_api( - '/api/v2/scrapers/{scraperTargetID}/owners', 'GET', - path_params, - query_params, - header_params, - body=body_params, - post_params=form_params, - files=local_var_files, - response_type='ResourceOwners', # noqa: E501 - auth_settings=auth_settings, - async_req=local_var_params.get('async_req'), - _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 - _preload_content=local_var_params.get('_preload_content', True), - _request_timeout=local_var_params.get('_request_timeout'), - collection_formats=collection_formats, - urlopen_kw=urlopen_kw) + ['application/json']) # noqa: E501 + + return local_var_params, path_params, query_params, header_params, body_params def patch_scrapers_id(self, scraper_target_id, scraper_target_request, **kwargs): # noqa: E501,D401,D403 """Update a scraper target. @@ -1040,23 +1152,64 @@ def patch_scrapers_id_with_http_info(self, scraper_target_id, scraper_target_req If the method is called asynchronously, returns the request thread. """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._patch_scrapers_id_prepare(scraper_target_id, scraper_target_request, **kwargs) + + return self.api_client.call_api( + '/api/v2/scrapers/{scraperTargetID}', 'PATCH', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='ScraperTargetResponse', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + async def patch_scrapers_id_async(self, scraper_target_id, scraper_target_request, **kwargs): # noqa: E501,D401,D403 + """Update a scraper target. + + This method makes an asynchronous HTTP request. + + :param async_req bool + :param str scraper_target_id: The identifier of the scraper target. (required) + :param ScraperTargetRequest scraper_target_request: Scraper target update to apply (required) + :param str zap_trace_span: OpenTracing span context + :return: ScraperTargetResponse + If the method is called asynchronously, + returns the request thread. + """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._patch_scrapers_id_prepare(scraper_target_id, scraper_target_request, **kwargs) + + return await self.api_client.call_api( + '/api/v2/scrapers/{scraperTargetID}', 'PATCH', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='ScraperTargetResponse', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + def _patch_scrapers_id_prepare(self, scraper_target_id, scraper_target_request, **kwargs): # noqa: E501,D401,D403 local_var_params = locals() all_params = ['scraper_target_id', 'scraper_target_request', 'zap_trace_span'] # noqa: E501 - all_params.append('async_req') - all_params.append('_return_http_data_only') - all_params.append('_preload_content') - all_params.append('_request_timeout') - all_params.append('urlopen_kw') - - for key, val in six.iteritems(local_var_params['kwargs']): - if key not in all_params: - raise TypeError( - "Got an unexpected keyword argument '%s'" - " to method patch_scrapers_id" % key - ) - local_var_params[key] = val - del local_var_params['kwargs'] + self._check_operation_params('patch_scrapers_id', all_params, local_var_params) # verify the required parameter 'scraper_target_id' is set if ('scraper_target_id' not in local_var_params or local_var_params['scraper_target_id'] is None): @@ -1066,8 +1219,6 @@ def patch_scrapers_id_with_http_info(self, scraper_target_id, scraper_target_req local_var_params['scraper_target_request'] is None): raise ValueError("Missing the required parameter `scraper_target_request` when calling `patch_scrapers_id`") # noqa: E501 - collection_formats = {} - path_params = {} if 'scraper_target_id' in local_var_params: path_params['scraperTargetID'] = local_var_params['scraper_target_id'] # noqa: E501 @@ -1078,9 +1229,6 @@ def patch_scrapers_id_with_http_info(self, scraper_target_id, scraper_target_req if 'zap_trace_span' in local_var_params: header_params['Zap-Trace-Span'] = local_var_params['zap_trace_span'] # noqa: E501 - form_params = [] - local_var_files = {} - body_params = None if 'scraper_target_request' in local_var_params: body_params = local_var_params['scraper_target_request'] @@ -1092,30 +1240,7 @@ def patch_scrapers_id_with_http_info(self, scraper_target_id, scraper_target_req header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501 ['application/json']) # noqa: E501 - # Authentication setting - auth_settings = [] # noqa: E501 - - # urlopen optional setting - urlopen_kw = None - if 'urlopen_kw' in kwargs: - urlopen_kw = kwargs['urlopen_kw'] - - return self.api_client.call_api( - '/api/v2/scrapers/{scraperTargetID}', 'PATCH', - path_params, - query_params, - header_params, - body=body_params, - post_params=form_params, - files=local_var_files, - response_type='ScraperTargetResponse', # noqa: E501 - auth_settings=auth_settings, - async_req=local_var_params.get('async_req'), - _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 - _preload_content=local_var_params.get('_preload_content', True), - _request_timeout=local_var_params.get('_request_timeout'), - collection_formats=collection_formats, - urlopen_kw=urlopen_kw) + return local_var_params, path_params, query_params, header_params, body_params def post_scrapers(self, scraper_target_request, **kwargs): # noqa: E501,D401,D403 """Create a scraper target. @@ -1154,30 +1279,68 @@ def post_scrapers_with_http_info(self, scraper_target_request, **kwargs): # noq If the method is called asynchronously, returns the request thread. """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._post_scrapers_prepare(scraper_target_request, **kwargs) + + return self.api_client.call_api( + '/api/v2/scrapers', 'POST', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='ScraperTargetResponse', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + async def post_scrapers_async(self, scraper_target_request, **kwargs): # noqa: E501,D401,D403 + """Create a scraper target. + + This method makes an asynchronous HTTP request. + + :param async_req bool + :param ScraperTargetRequest scraper_target_request: Scraper target to create (required) + :param str zap_trace_span: OpenTracing span context + :return: ScraperTargetResponse + If the method is called asynchronously, + returns the request thread. + """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._post_scrapers_prepare(scraper_target_request, **kwargs) + + return await self.api_client.call_api( + '/api/v2/scrapers', 'POST', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='ScraperTargetResponse', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + def _post_scrapers_prepare(self, scraper_target_request, **kwargs): # noqa: E501,D401,D403 local_var_params = locals() all_params = ['scraper_target_request', 'zap_trace_span'] # noqa: E501 - all_params.append('async_req') - all_params.append('_return_http_data_only') - all_params.append('_preload_content') - all_params.append('_request_timeout') - all_params.append('urlopen_kw') - - for key, val in six.iteritems(local_var_params['kwargs']): - if key not in all_params: - raise TypeError( - "Got an unexpected keyword argument '%s'" - " to method post_scrapers" % key - ) - local_var_params[key] = val - del local_var_params['kwargs'] + self._check_operation_params('post_scrapers', all_params, local_var_params) # verify the required parameter 'scraper_target_request' is set if ('scraper_target_request' not in local_var_params or local_var_params['scraper_target_request'] is None): raise ValueError("Missing the required parameter `scraper_target_request` when calling `post_scrapers`") # noqa: E501 - collection_formats = {} - path_params = {} query_params = [] @@ -1186,9 +1349,6 @@ def post_scrapers_with_http_info(self, scraper_target_request, **kwargs): # noq if 'zap_trace_span' in local_var_params: header_params['Zap-Trace-Span'] = local_var_params['zap_trace_span'] # noqa: E501 - form_params = [] - local_var_files = {} - body_params = None if 'scraper_target_request' in local_var_params: body_params = local_var_params['scraper_target_request'] @@ -1200,30 +1360,7 @@ def post_scrapers_with_http_info(self, scraper_target_request, **kwargs): # noq header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501 ['application/json']) # noqa: E501 - # Authentication setting - auth_settings = [] # noqa: E501 - - # urlopen optional setting - urlopen_kw = None - if 'urlopen_kw' in kwargs: - urlopen_kw = kwargs['urlopen_kw'] - - return self.api_client.call_api( - '/api/v2/scrapers', 'POST', - path_params, - query_params, - header_params, - body=body_params, - post_params=form_params, - files=local_var_files, - response_type='ScraperTargetResponse', # noqa: E501 - auth_settings=auth_settings, - async_req=local_var_params.get('async_req'), - _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 - _preload_content=local_var_params.get('_preload_content', True), - _request_timeout=local_var_params.get('_request_timeout'), - collection_formats=collection_formats, - urlopen_kw=urlopen_kw) + return local_var_params, path_params, query_params, header_params, body_params def post_scrapers_id_labels(self, scraper_target_id, label_mapping, **kwargs): # noqa: E501,D401,D403 """Add a label to a scraper target. @@ -1264,23 +1401,64 @@ def post_scrapers_id_labels_with_http_info(self, scraper_target_id, label_mappin If the method is called asynchronously, returns the request thread. """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._post_scrapers_id_labels_prepare(scraper_target_id, label_mapping, **kwargs) + + return self.api_client.call_api( + '/api/v2/scrapers/{scraperTargetID}/labels', 'POST', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='LabelResponse', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + async def post_scrapers_id_labels_async(self, scraper_target_id, label_mapping, **kwargs): # noqa: E501,D401,D403 + """Add a label to a scraper target. + + This method makes an asynchronous HTTP request. + + :param async_req bool + :param str scraper_target_id: The scraper target ID. (required) + :param LabelMapping label_mapping: Label to add (required) + :param str zap_trace_span: OpenTracing span context + :return: LabelResponse + If the method is called asynchronously, + returns the request thread. + """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._post_scrapers_id_labels_prepare(scraper_target_id, label_mapping, **kwargs) + + return await self.api_client.call_api( + '/api/v2/scrapers/{scraperTargetID}/labels', 'POST', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='LabelResponse', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + def _post_scrapers_id_labels_prepare(self, scraper_target_id, label_mapping, **kwargs): # noqa: E501,D401,D403 local_var_params = locals() all_params = ['scraper_target_id', 'label_mapping', 'zap_trace_span'] # noqa: E501 - all_params.append('async_req') - all_params.append('_return_http_data_only') - all_params.append('_preload_content') - all_params.append('_request_timeout') - all_params.append('urlopen_kw') - - for key, val in six.iteritems(local_var_params['kwargs']): - if key not in all_params: - raise TypeError( - "Got an unexpected keyword argument '%s'" - " to method post_scrapers_id_labels" % key - ) - local_var_params[key] = val - del local_var_params['kwargs'] + self._check_operation_params('post_scrapers_id_labels', all_params, local_var_params) # verify the required parameter 'scraper_target_id' is set if ('scraper_target_id' not in local_var_params or local_var_params['scraper_target_id'] is None): @@ -1290,8 +1468,6 @@ def post_scrapers_id_labels_with_http_info(self, scraper_target_id, label_mappin local_var_params['label_mapping'] is None): raise ValueError("Missing the required parameter `label_mapping` when calling `post_scrapers_id_labels`") # noqa: E501 - collection_formats = {} - path_params = {} if 'scraper_target_id' in local_var_params: path_params['scraperTargetID'] = local_var_params['scraper_target_id'] # noqa: E501 @@ -1302,9 +1478,6 @@ def post_scrapers_id_labels_with_http_info(self, scraper_target_id, label_mappin if 'zap_trace_span' in local_var_params: header_params['Zap-Trace-Span'] = local_var_params['zap_trace_span'] # noqa: E501 - form_params = [] - local_var_files = {} - body_params = None if 'label_mapping' in local_var_params: body_params = local_var_params['label_mapping'] @@ -1316,30 +1489,7 @@ def post_scrapers_id_labels_with_http_info(self, scraper_target_id, label_mappin header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501 ['application/json']) # noqa: E501 - # Authentication setting - auth_settings = [] # noqa: E501 - - # urlopen optional setting - urlopen_kw = None - if 'urlopen_kw' in kwargs: - urlopen_kw = kwargs['urlopen_kw'] - - return self.api_client.call_api( - '/api/v2/scrapers/{scraperTargetID}/labels', 'POST', - path_params, - query_params, - header_params, - body=body_params, - post_params=form_params, - files=local_var_files, - response_type='LabelResponse', # noqa: E501 - auth_settings=auth_settings, - async_req=local_var_params.get('async_req'), - _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 - _preload_content=local_var_params.get('_preload_content', True), - _request_timeout=local_var_params.get('_request_timeout'), - collection_formats=collection_formats, - urlopen_kw=urlopen_kw) + return local_var_params, path_params, query_params, header_params, body_params def post_scrapers_id_members(self, scraper_target_id, add_resource_member_request_body, **kwargs): # noqa: E501,D401,D403 """Add a member to a scraper target. @@ -1380,23 +1530,64 @@ def post_scrapers_id_members_with_http_info(self, scraper_target_id, add_resourc If the method is called asynchronously, returns the request thread. """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._post_scrapers_id_members_prepare(scraper_target_id, add_resource_member_request_body, **kwargs) + + return self.api_client.call_api( + '/api/v2/scrapers/{scraperTargetID}/members', 'POST', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='ResourceMember', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + async def post_scrapers_id_members_async(self, scraper_target_id, add_resource_member_request_body, **kwargs): # noqa: E501,D401,D403 + """Add a member to a scraper target. + + This method makes an asynchronous HTTP request. + + :param async_req bool + :param str scraper_target_id: The scraper target ID. (required) + :param AddResourceMemberRequestBody add_resource_member_request_body: User to add as member (required) + :param str zap_trace_span: OpenTracing span context + :return: ResourceMember + If the method is called asynchronously, + returns the request thread. + """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._post_scrapers_id_members_prepare(scraper_target_id, add_resource_member_request_body, **kwargs) + + return await self.api_client.call_api( + '/api/v2/scrapers/{scraperTargetID}/members', 'POST', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='ResourceMember', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + def _post_scrapers_id_members_prepare(self, scraper_target_id, add_resource_member_request_body, **kwargs): # noqa: E501,D401,D403 local_var_params = locals() all_params = ['scraper_target_id', 'add_resource_member_request_body', 'zap_trace_span'] # noqa: E501 - all_params.append('async_req') - all_params.append('_return_http_data_only') - all_params.append('_preload_content') - all_params.append('_request_timeout') - all_params.append('urlopen_kw') - - for key, val in six.iteritems(local_var_params['kwargs']): - if key not in all_params: - raise TypeError( - "Got an unexpected keyword argument '%s'" - " to method post_scrapers_id_members" % key - ) - local_var_params[key] = val - del local_var_params['kwargs'] + self._check_operation_params('post_scrapers_id_members', all_params, local_var_params) # verify the required parameter 'scraper_target_id' is set if ('scraper_target_id' not in local_var_params or local_var_params['scraper_target_id'] is None): @@ -1406,8 +1597,6 @@ def post_scrapers_id_members_with_http_info(self, scraper_target_id, add_resourc local_var_params['add_resource_member_request_body'] is None): raise ValueError("Missing the required parameter `add_resource_member_request_body` when calling `post_scrapers_id_members`") # noqa: E501 - collection_formats = {} - path_params = {} if 'scraper_target_id' in local_var_params: path_params['scraperTargetID'] = local_var_params['scraper_target_id'] # noqa: E501 @@ -1418,9 +1607,6 @@ def post_scrapers_id_members_with_http_info(self, scraper_target_id, add_resourc if 'zap_trace_span' in local_var_params: header_params['Zap-Trace-Span'] = local_var_params['zap_trace_span'] # noqa: E501 - form_params = [] - local_var_files = {} - body_params = None if 'add_resource_member_request_body' in local_var_params: body_params = local_var_params['add_resource_member_request_body'] @@ -1432,30 +1618,7 @@ def post_scrapers_id_members_with_http_info(self, scraper_target_id, add_resourc header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501 ['application/json']) # noqa: E501 - # Authentication setting - auth_settings = [] # noqa: E501 - - # urlopen optional setting - urlopen_kw = None - if 'urlopen_kw' in kwargs: - urlopen_kw = kwargs['urlopen_kw'] - - return self.api_client.call_api( - '/api/v2/scrapers/{scraperTargetID}/members', 'POST', - path_params, - query_params, - header_params, - body=body_params, - post_params=form_params, - files=local_var_files, - response_type='ResourceMember', # noqa: E501 - auth_settings=auth_settings, - async_req=local_var_params.get('async_req'), - _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 - _preload_content=local_var_params.get('_preload_content', True), - _request_timeout=local_var_params.get('_request_timeout'), - collection_formats=collection_formats, - urlopen_kw=urlopen_kw) + return local_var_params, path_params, query_params, header_params, body_params def post_scrapers_id_owners(self, scraper_target_id, add_resource_member_request_body, **kwargs): # noqa: E501,D401,D403 """Add an owner to a scraper target. @@ -1496,23 +1659,64 @@ def post_scrapers_id_owners_with_http_info(self, scraper_target_id, add_resource If the method is called asynchronously, returns the request thread. """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._post_scrapers_id_owners_prepare(scraper_target_id, add_resource_member_request_body, **kwargs) + + return self.api_client.call_api( + '/api/v2/scrapers/{scraperTargetID}/owners', 'POST', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='ResourceOwner', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + async def post_scrapers_id_owners_async(self, scraper_target_id, add_resource_member_request_body, **kwargs): # noqa: E501,D401,D403 + """Add an owner to a scraper target. + + This method makes an asynchronous HTTP request. + + :param async_req bool + :param str scraper_target_id: The scraper target ID. (required) + :param AddResourceMemberRequestBody add_resource_member_request_body: User to add as owner (required) + :param str zap_trace_span: OpenTracing span context + :return: ResourceOwner + If the method is called asynchronously, + returns the request thread. + """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._post_scrapers_id_owners_prepare(scraper_target_id, add_resource_member_request_body, **kwargs) + + return await self.api_client.call_api( + '/api/v2/scrapers/{scraperTargetID}/owners', 'POST', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='ResourceOwner', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + def _post_scrapers_id_owners_prepare(self, scraper_target_id, add_resource_member_request_body, **kwargs): # noqa: E501,D401,D403 local_var_params = locals() all_params = ['scraper_target_id', 'add_resource_member_request_body', 'zap_trace_span'] # noqa: E501 - all_params.append('async_req') - all_params.append('_return_http_data_only') - all_params.append('_preload_content') - all_params.append('_request_timeout') - all_params.append('urlopen_kw') - - for key, val in six.iteritems(local_var_params['kwargs']): - if key not in all_params: - raise TypeError( - "Got an unexpected keyword argument '%s'" - " to method post_scrapers_id_owners" % key - ) - local_var_params[key] = val - del local_var_params['kwargs'] + self._check_operation_params('post_scrapers_id_owners', all_params, local_var_params) # verify the required parameter 'scraper_target_id' is set if ('scraper_target_id' not in local_var_params or local_var_params['scraper_target_id'] is None): @@ -1522,8 +1726,6 @@ def post_scrapers_id_owners_with_http_info(self, scraper_target_id, add_resource local_var_params['add_resource_member_request_body'] is None): raise ValueError("Missing the required parameter `add_resource_member_request_body` when calling `post_scrapers_id_owners`") # noqa: E501 - collection_formats = {} - path_params = {} if 'scraper_target_id' in local_var_params: path_params['scraperTargetID'] = local_var_params['scraper_target_id'] # noqa: E501 @@ -1534,9 +1736,6 @@ def post_scrapers_id_owners_with_http_info(self, scraper_target_id, add_resource if 'zap_trace_span' in local_var_params: header_params['Zap-Trace-Span'] = local_var_params['zap_trace_span'] # noqa: E501 - form_params = [] - local_var_files = {} - body_params = None if 'add_resource_member_request_body' in local_var_params: body_params = local_var_params['add_resource_member_request_body'] @@ -1548,27 +1747,4 @@ def post_scrapers_id_owners_with_http_info(self, scraper_target_id, add_resource header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501 ['application/json']) # noqa: E501 - # Authentication setting - auth_settings = [] # noqa: E501 - - # urlopen optional setting - urlopen_kw = None - if 'urlopen_kw' in kwargs: - urlopen_kw = kwargs['urlopen_kw'] - - return self.api_client.call_api( - '/api/v2/scrapers/{scraperTargetID}/owners', 'POST', - path_params, - query_params, - header_params, - body=body_params, - post_params=form_params, - files=local_var_files, - response_type='ResourceOwner', # noqa: E501 - auth_settings=auth_settings, - async_req=local_var_params.get('async_req'), - _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 - _preload_content=local_var_params.get('_preload_content', True), - _request_timeout=local_var_params.get('_request_timeout'), - collection_formats=collection_formats, - urlopen_kw=urlopen_kw) + return local_var_params, path_params, query_params, header_params, body_params diff --git a/influxdb_client/service/secrets_service.py b/influxdb_client/service/secrets_service.py index 7e87c4bc..9baf888c 100644 --- a/influxdb_client/service/secrets_service.py +++ b/influxdb_client/service/secrets_service.py @@ -14,11 +14,10 @@ import re # noqa: F401 -# python 2 and python 3 compatibility library -import six +from influxdb_client.service._base_service import _BaseService -class SecretsService(object): +class SecretsService(_BaseService): """NOTE: This class is auto generated by OpenAPI Generator. Ref: https://openapi-generator.tech @@ -71,23 +70,64 @@ def delete_orgs_id_secrets_id_with_http_info(self, org_id, secret_id, **kwargs): If the method is called asynchronously, returns the request thread. """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._delete_orgs_id_secrets_id_prepare(org_id, secret_id, **kwargs) + + return self.api_client.call_api( + '/api/v2/orgs/{orgID}/secrets/{secretID}', 'DELETE', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type=None, # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + async def delete_orgs_id_secrets_id_async(self, org_id, secret_id, **kwargs): # noqa: E501,D401,D403 + """Delete a secret from an organization. + + This method makes an asynchronous HTTP request. + + :param async_req bool + :param str org_id: The organization ID. (required) + :param str secret_id: The secret ID. (required) + :param str zap_trace_span: OpenTracing span context + :return: None + If the method is called asynchronously, + returns the request thread. + """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._delete_orgs_id_secrets_id_prepare(org_id, secret_id, **kwargs) + + return await self.api_client.call_api( + '/api/v2/orgs/{orgID}/secrets/{secretID}', 'DELETE', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type=None, # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + def _delete_orgs_id_secrets_id_prepare(self, org_id, secret_id, **kwargs): # noqa: E501,D401,D403 local_var_params = locals() all_params = ['org_id', 'secret_id', 'zap_trace_span'] # noqa: E501 - all_params.append('async_req') - all_params.append('_return_http_data_only') - all_params.append('_preload_content') - all_params.append('_request_timeout') - all_params.append('urlopen_kw') - - for key, val in six.iteritems(local_var_params['kwargs']): - if key not in all_params: - raise TypeError( - "Got an unexpected keyword argument '%s'" - " to method delete_orgs_id_secrets_id" % key - ) - local_var_params[key] = val - del local_var_params['kwargs'] + self._check_operation_params('delete_orgs_id_secrets_id', all_params, local_var_params) # verify the required parameter 'org_id' is set if ('org_id' not in local_var_params or local_var_params['org_id'] is None): @@ -97,8 +137,6 @@ def delete_orgs_id_secrets_id_with_http_info(self, org_id, secret_id, **kwargs): local_var_params['secret_id'] is None): raise ValueError("Missing the required parameter `secret_id` when calling `delete_orgs_id_secrets_id`") # noqa: E501 - collection_formats = {} - path_params = {} if 'org_id' in local_var_params: path_params['orgID'] = local_var_params['org_id'] # noqa: E501 @@ -111,38 +149,12 @@ def delete_orgs_id_secrets_id_with_http_info(self, org_id, secret_id, **kwargs): if 'zap_trace_span' in local_var_params: header_params['Zap-Trace-Span'] = local_var_params['zap_trace_span'] # noqa: E501 - form_params = [] - local_var_files = {} - body_params = None # HTTP header `Accept` header_params['Accept'] = self.api_client.select_header_accept( ['application/json']) # noqa: E501 - # Authentication setting - auth_settings = [] # noqa: E501 - - # urlopen optional setting - urlopen_kw = None - if 'urlopen_kw' in kwargs: - urlopen_kw = kwargs['urlopen_kw'] - - return self.api_client.call_api( - '/api/v2/orgs/{orgID}/secrets/{secretID}', 'DELETE', - path_params, - query_params, - header_params, - body=body_params, - post_params=form_params, - files=local_var_files, - response_type=None, # noqa: E501 - auth_settings=auth_settings, - async_req=local_var_params.get('async_req'), - _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 - _preload_content=local_var_params.get('_preload_content', True), - _request_timeout=local_var_params.get('_request_timeout'), - collection_formats=collection_formats, - urlopen_kw=urlopen_kw) + return local_var_params, path_params, query_params, header_params, body_params def get_orgs_id_secrets(self, org_id, **kwargs): # noqa: E501,D401,D403 """List all secret keys for an organization. @@ -181,30 +193,68 @@ def get_orgs_id_secrets_with_http_info(self, org_id, **kwargs): # noqa: E501,D4 If the method is called asynchronously, returns the request thread. """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._get_orgs_id_secrets_prepare(org_id, **kwargs) + + return self.api_client.call_api( + '/api/v2/orgs/{orgID}/secrets', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='SecretKeysResponse', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + async def get_orgs_id_secrets_async(self, org_id, **kwargs): # noqa: E501,D401,D403 + """List all secret keys for an organization. + + This method makes an asynchronous HTTP request. + + :param async_req bool + :param str org_id: The organization ID. (required) + :param str zap_trace_span: OpenTracing span context + :return: SecretKeysResponse + If the method is called asynchronously, + returns the request thread. + """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._get_orgs_id_secrets_prepare(org_id, **kwargs) + + return await self.api_client.call_api( + '/api/v2/orgs/{orgID}/secrets', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='SecretKeysResponse', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + def _get_orgs_id_secrets_prepare(self, org_id, **kwargs): # noqa: E501,D401,D403 local_var_params = locals() all_params = ['org_id', 'zap_trace_span'] # noqa: E501 - all_params.append('async_req') - all_params.append('_return_http_data_only') - all_params.append('_preload_content') - all_params.append('_request_timeout') - all_params.append('urlopen_kw') - - for key, val in six.iteritems(local_var_params['kwargs']): - if key not in all_params: - raise TypeError( - "Got an unexpected keyword argument '%s'" - " to method get_orgs_id_secrets" % key - ) - local_var_params[key] = val - del local_var_params['kwargs'] + self._check_operation_params('get_orgs_id_secrets', all_params, local_var_params) # verify the required parameter 'org_id' is set if ('org_id' not in local_var_params or local_var_params['org_id'] is None): raise ValueError("Missing the required parameter `org_id` when calling `get_orgs_id_secrets`") # noqa: E501 - collection_formats = {} - path_params = {} if 'org_id' in local_var_params: path_params['orgID'] = local_var_params['org_id'] # noqa: E501 @@ -215,38 +265,12 @@ def get_orgs_id_secrets_with_http_info(self, org_id, **kwargs): # noqa: E501,D4 if 'zap_trace_span' in local_var_params: header_params['Zap-Trace-Span'] = local_var_params['zap_trace_span'] # noqa: E501 - form_params = [] - local_var_files = {} - body_params = None # HTTP header `Accept` header_params['Accept'] = self.api_client.select_header_accept( ['application/json']) # noqa: E501 - # Authentication setting - auth_settings = [] # noqa: E501 - - # urlopen optional setting - urlopen_kw = None - if 'urlopen_kw' in kwargs: - urlopen_kw = kwargs['urlopen_kw'] - - return self.api_client.call_api( - '/api/v2/orgs/{orgID}/secrets', 'GET', - path_params, - query_params, - header_params, - body=body_params, - post_params=form_params, - files=local_var_files, - response_type='SecretKeysResponse', # noqa: E501 - auth_settings=auth_settings, - async_req=local_var_params.get('async_req'), - _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 - _preload_content=local_var_params.get('_preload_content', True), - _request_timeout=local_var_params.get('_request_timeout'), - collection_formats=collection_formats, - urlopen_kw=urlopen_kw) + return local_var_params, path_params, query_params, header_params, body_params def patch_orgs_id_secrets(self, org_id, request_body, **kwargs): # noqa: E501,D401,D403 """Update secrets in an organization. @@ -287,23 +311,64 @@ def patch_orgs_id_secrets_with_http_info(self, org_id, request_body, **kwargs): If the method is called asynchronously, returns the request thread. """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._patch_orgs_id_secrets_prepare(org_id, request_body, **kwargs) + + return self.api_client.call_api( + '/api/v2/orgs/{orgID}/secrets', 'PATCH', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type=None, # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + async def patch_orgs_id_secrets_async(self, org_id, request_body, **kwargs): # noqa: E501,D401,D403 + """Update secrets in an organization. + + This method makes an asynchronous HTTP request. + + :param async_req bool + :param str org_id: The organization ID. (required) + :param dict(str, str) request_body: Secret key value pairs to update/add (required) + :param str zap_trace_span: OpenTracing span context + :return: None + If the method is called asynchronously, + returns the request thread. + """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._patch_orgs_id_secrets_prepare(org_id, request_body, **kwargs) + + return await self.api_client.call_api( + '/api/v2/orgs/{orgID}/secrets', 'PATCH', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type=None, # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + def _patch_orgs_id_secrets_prepare(self, org_id, request_body, **kwargs): # noqa: E501,D401,D403 local_var_params = locals() all_params = ['org_id', 'request_body', 'zap_trace_span'] # noqa: E501 - all_params.append('async_req') - all_params.append('_return_http_data_only') - all_params.append('_preload_content') - all_params.append('_request_timeout') - all_params.append('urlopen_kw') - - for key, val in six.iteritems(local_var_params['kwargs']): - if key not in all_params: - raise TypeError( - "Got an unexpected keyword argument '%s'" - " to method patch_orgs_id_secrets" % key - ) - local_var_params[key] = val - del local_var_params['kwargs'] + self._check_operation_params('patch_orgs_id_secrets', all_params, local_var_params) # verify the required parameter 'org_id' is set if ('org_id' not in local_var_params or local_var_params['org_id'] is None): @@ -313,8 +378,6 @@ def patch_orgs_id_secrets_with_http_info(self, org_id, request_body, **kwargs): local_var_params['request_body'] is None): raise ValueError("Missing the required parameter `request_body` when calling `patch_orgs_id_secrets`") # noqa: E501 - collection_formats = {} - path_params = {} if 'org_id' in local_var_params: path_params['orgID'] = local_var_params['org_id'] # noqa: E501 @@ -325,9 +388,6 @@ def patch_orgs_id_secrets_with_http_info(self, org_id, request_body, **kwargs): if 'zap_trace_span' in local_var_params: header_params['Zap-Trace-Span'] = local_var_params['zap_trace_span'] # noqa: E501 - form_params = [] - local_var_files = {} - body_params = None if 'request_body' in local_var_params: body_params = local_var_params['request_body'] @@ -339,30 +399,7 @@ def patch_orgs_id_secrets_with_http_info(self, org_id, request_body, **kwargs): header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501 ['application/json']) # noqa: E501 - # Authentication setting - auth_settings = [] # noqa: E501 - - # urlopen optional setting - urlopen_kw = None - if 'urlopen_kw' in kwargs: - urlopen_kw = kwargs['urlopen_kw'] - - return self.api_client.call_api( - '/api/v2/orgs/{orgID}/secrets', 'PATCH', - path_params, - query_params, - header_params, - body=body_params, - post_params=form_params, - files=local_var_files, - response_type=None, # noqa: E501 - auth_settings=auth_settings, - async_req=local_var_params.get('async_req'), - _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 - _preload_content=local_var_params.get('_preload_content', True), - _request_timeout=local_var_params.get('_request_timeout'), - collection_formats=collection_formats, - urlopen_kw=urlopen_kw) + return local_var_params, path_params, query_params, header_params, body_params def post_orgs_id_secrets(self, org_id, secret_keys, **kwargs): # noqa: E501,D401,D403 """Delete secrets from an organization. @@ -403,23 +440,64 @@ def post_orgs_id_secrets_with_http_info(self, org_id, secret_keys, **kwargs): # If the method is called asynchronously, returns the request thread. """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._post_orgs_id_secrets_prepare(org_id, secret_keys, **kwargs) + + return self.api_client.call_api( + '/api/v2/orgs/{orgID}/secrets/delete', 'POST', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type=None, # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + async def post_orgs_id_secrets_async(self, org_id, secret_keys, **kwargs): # noqa: E501,D401,D403 + """Delete secrets from an organization. + + This method makes an asynchronous HTTP request. + + :param async_req bool + :param str org_id: The organization ID. (required) + :param SecretKeys secret_keys: Secret key to delete (required) + :param str zap_trace_span: OpenTracing span context + :return: None + If the method is called asynchronously, + returns the request thread. + """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._post_orgs_id_secrets_prepare(org_id, secret_keys, **kwargs) + + return await self.api_client.call_api( + '/api/v2/orgs/{orgID}/secrets/delete', 'POST', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type=None, # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + def _post_orgs_id_secrets_prepare(self, org_id, secret_keys, **kwargs): # noqa: E501,D401,D403 local_var_params = locals() all_params = ['org_id', 'secret_keys', 'zap_trace_span'] # noqa: E501 - all_params.append('async_req') - all_params.append('_return_http_data_only') - all_params.append('_preload_content') - all_params.append('_request_timeout') - all_params.append('urlopen_kw') - - for key, val in six.iteritems(local_var_params['kwargs']): - if key not in all_params: - raise TypeError( - "Got an unexpected keyword argument '%s'" - " to method post_orgs_id_secrets" % key - ) - local_var_params[key] = val - del local_var_params['kwargs'] + self._check_operation_params('post_orgs_id_secrets', all_params, local_var_params) # verify the required parameter 'org_id' is set if ('org_id' not in local_var_params or local_var_params['org_id'] is None): @@ -429,8 +507,6 @@ def post_orgs_id_secrets_with_http_info(self, org_id, secret_keys, **kwargs): # local_var_params['secret_keys'] is None): raise ValueError("Missing the required parameter `secret_keys` when calling `post_orgs_id_secrets`") # noqa: E501 - collection_formats = {} - path_params = {} if 'org_id' in local_var_params: path_params['orgID'] = local_var_params['org_id'] # noqa: E501 @@ -441,9 +517,6 @@ def post_orgs_id_secrets_with_http_info(self, org_id, secret_keys, **kwargs): # if 'zap_trace_span' in local_var_params: header_params['Zap-Trace-Span'] = local_var_params['zap_trace_span'] # noqa: E501 - form_params = [] - local_var_files = {} - body_params = None if 'secret_keys' in local_var_params: body_params = local_var_params['secret_keys'] @@ -455,27 +528,4 @@ def post_orgs_id_secrets_with_http_info(self, org_id, secret_keys, **kwargs): # header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501 ['application/json']) # noqa: E501 - # Authentication setting - auth_settings = [] # noqa: E501 - - # urlopen optional setting - urlopen_kw = None - if 'urlopen_kw' in kwargs: - urlopen_kw = kwargs['urlopen_kw'] - - return self.api_client.call_api( - '/api/v2/orgs/{orgID}/secrets/delete', 'POST', - path_params, - query_params, - header_params, - body=body_params, - post_params=form_params, - files=local_var_files, - response_type=None, # noqa: E501 - auth_settings=auth_settings, - async_req=local_var_params.get('async_req'), - _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 - _preload_content=local_var_params.get('_preload_content', True), - _request_timeout=local_var_params.get('_request_timeout'), - collection_formats=collection_formats, - urlopen_kw=urlopen_kw) + return local_var_params, path_params, query_params, header_params, body_params diff --git a/influxdb_client/service/setup_service.py b/influxdb_client/service/setup_service.py index 88a05cad..97d7ca2b 100644 --- a/influxdb_client/service/setup_service.py +++ b/influxdb_client/service/setup_service.py @@ -14,11 +14,10 @@ import re # noqa: F401 -# python 2 and python 3 compatibility library -import six +from influxdb_client.service._base_service import _BaseService -class SetupService(object): +class SetupService(_BaseService): """NOTE: This class is auto generated by OpenAPI Generator. Ref: https://openapi-generator.tech @@ -69,25 +68,63 @@ def get_setup_with_http_info(self, **kwargs): # noqa: E501,D401,D403 If the method is called asynchronously, returns the request thread. """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._get_setup_prepare(**kwargs) + + return self.api_client.call_api( + '/api/v2/setup', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='IsOnboarding', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + async def get_setup_async(self, **kwargs): # noqa: E501,D401,D403 + """Check if database has default user, org, bucket. + + Returns `true` if no default user, organization, or bucket has been created. + This method makes an asynchronous HTTP request. + + :param async_req bool + :param str zap_trace_span: OpenTracing span context + :return: IsOnboarding + If the method is called asynchronously, + returns the request thread. + """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._get_setup_prepare(**kwargs) + + return await self.api_client.call_api( + '/api/v2/setup', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='IsOnboarding', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + def _get_setup_prepare(self, **kwargs): # noqa: E501,D401,D403 local_var_params = locals() all_params = ['zap_trace_span'] # noqa: E501 - all_params.append('async_req') - all_params.append('_return_http_data_only') - all_params.append('_preload_content') - all_params.append('_request_timeout') - all_params.append('urlopen_kw') - - for key, val in six.iteritems(local_var_params['kwargs']): - if key not in all_params: - raise TypeError( - "Got an unexpected keyword argument '%s'" - " to method get_setup" % key - ) - local_var_params[key] = val - del local_var_params['kwargs'] - - collection_formats = {} + self._check_operation_params('get_setup', all_params, local_var_params) path_params = {} @@ -97,38 +134,12 @@ def get_setup_with_http_info(self, **kwargs): # noqa: E501,D401,D403 if 'zap_trace_span' in local_var_params: header_params['Zap-Trace-Span'] = local_var_params['zap_trace_span'] # noqa: E501 - form_params = [] - local_var_files = {} - body_params = None # HTTP header `Accept` header_params['Accept'] = self.api_client.select_header_accept( ['application/json']) # noqa: E501 - # Authentication setting - auth_settings = [] # noqa: E501 - - # urlopen optional setting - urlopen_kw = None - if 'urlopen_kw' in kwargs: - urlopen_kw = kwargs['urlopen_kw'] - - return self.api_client.call_api( - '/api/v2/setup', 'GET', - path_params, - query_params, - header_params, - body=body_params, - post_params=form_params, - files=local_var_files, - response_type='IsOnboarding', # noqa: E501 - auth_settings=auth_settings, - async_req=local_var_params.get('async_req'), - _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 - _preload_content=local_var_params.get('_preload_content', True), - _request_timeout=local_var_params.get('_request_timeout'), - collection_formats=collection_formats, - urlopen_kw=urlopen_kw) + return local_var_params, path_params, query_params, header_params, body_params def post_setup(self, onboarding_request, **kwargs): # noqa: E501,D401,D403 """Set up initial user, org and bucket. @@ -169,30 +180,69 @@ def post_setup_with_http_info(self, onboarding_request, **kwargs): # noqa: E501 If the method is called asynchronously, returns the request thread. """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._post_setup_prepare(onboarding_request, **kwargs) + + return self.api_client.call_api( + '/api/v2/setup', 'POST', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='OnboardingResponse', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + async def post_setup_async(self, onboarding_request, **kwargs): # noqa: E501,D401,D403 + """Set up initial user, org and bucket. + + Post an onboarding request to set up initial user, org and bucket. + This method makes an asynchronous HTTP request. + + :param async_req bool + :param OnboardingRequest onboarding_request: Source to create (required) + :param str zap_trace_span: OpenTracing span context + :return: OnboardingResponse + If the method is called asynchronously, + returns the request thread. + """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._post_setup_prepare(onboarding_request, **kwargs) + + return await self.api_client.call_api( + '/api/v2/setup', 'POST', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='OnboardingResponse', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + def _post_setup_prepare(self, onboarding_request, **kwargs): # noqa: E501,D401,D403 local_var_params = locals() all_params = ['onboarding_request', 'zap_trace_span'] # noqa: E501 - all_params.append('async_req') - all_params.append('_return_http_data_only') - all_params.append('_preload_content') - all_params.append('_request_timeout') - all_params.append('urlopen_kw') - - for key, val in six.iteritems(local_var_params['kwargs']): - if key not in all_params: - raise TypeError( - "Got an unexpected keyword argument '%s'" - " to method post_setup" % key - ) - local_var_params[key] = val - del local_var_params['kwargs'] + self._check_operation_params('post_setup', all_params, local_var_params) # verify the required parameter 'onboarding_request' is set if ('onboarding_request' not in local_var_params or local_var_params['onboarding_request'] is None): raise ValueError("Missing the required parameter `onboarding_request` when calling `post_setup`") # noqa: E501 - collection_formats = {} - path_params = {} query_params = [] @@ -201,9 +251,6 @@ def post_setup_with_http_info(self, onboarding_request, **kwargs): # noqa: E501 if 'zap_trace_span' in local_var_params: header_params['Zap-Trace-Span'] = local_var_params['zap_trace_span'] # noqa: E501 - form_params = [] - local_var_files = {} - body_params = None if 'onboarding_request' in local_var_params: body_params = local_var_params['onboarding_request'] @@ -215,27 +262,4 @@ def post_setup_with_http_info(self, onboarding_request, **kwargs): # noqa: E501 header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501 ['application/json']) # noqa: E501 - # Authentication setting - auth_settings = [] # noqa: E501 - - # urlopen optional setting - urlopen_kw = None - if 'urlopen_kw' in kwargs: - urlopen_kw = kwargs['urlopen_kw'] - - return self.api_client.call_api( - '/api/v2/setup', 'POST', - path_params, - query_params, - header_params, - body=body_params, - post_params=form_params, - files=local_var_files, - response_type='OnboardingResponse', # noqa: E501 - auth_settings=auth_settings, - async_req=local_var_params.get('async_req'), - _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 - _preload_content=local_var_params.get('_preload_content', True), - _request_timeout=local_var_params.get('_request_timeout'), - collection_formats=collection_formats, - urlopen_kw=urlopen_kw) + return local_var_params, path_params, query_params, header_params, body_params diff --git a/influxdb_client/service/signin_service.py b/influxdb_client/service/signin_service.py index a4625d4a..b9686d37 100644 --- a/influxdb_client/service/signin_service.py +++ b/influxdb_client/service/signin_service.py @@ -14,11 +14,10 @@ import re # noqa: F401 -# python 2 and python 3 compatibility library -import six +from influxdb_client.service._base_service import _BaseService -class SigninService(object): +class SigninService(_BaseService): """NOTE: This class is auto generated by OpenAPI Generator. Ref: https://openapi-generator.tech @@ -71,25 +70,64 @@ def post_signin_with_http_info(self, **kwargs): # noqa: E501,D401,D403 If the method is called asynchronously, returns the request thread. """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._post_signin_prepare(**kwargs) + + return self.api_client.call_api( + '/api/v2/signin', 'POST', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type=None, # noqa: E501 + auth_settings=['BasicAuthentication'], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + async def post_signin_async(self, **kwargs): # noqa: E501,D401,D403 + """Create a user session.. + + Authenticates ***Basic Auth*** credentials for a user. If successful, creates a new UI session for the user. + This method makes an asynchronous HTTP request. + + :param async_req bool + :param str zap_trace_span: OpenTracing span context + :param str authorization: An auth credential for the Basic scheme + :return: None + If the method is called asynchronously, + returns the request thread. + """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._post_signin_prepare(**kwargs) + + return await self.api_client.call_api( + '/api/v2/signin', 'POST', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type=None, # noqa: E501 + auth_settings=['BasicAuthentication'], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + def _post_signin_prepare(self, **kwargs): # noqa: E501,D401,D403 local_var_params = locals() all_params = ['zap_trace_span', 'authorization'] # noqa: E501 - all_params.append('async_req') - all_params.append('_return_http_data_only') - all_params.append('_preload_content') - all_params.append('_request_timeout') - all_params.append('urlopen_kw') - - for key, val in six.iteritems(local_var_params['kwargs']): - if key not in all_params: - raise TypeError( - "Got an unexpected keyword argument '%s'" - " to method post_signin" % key - ) - local_var_params[key] = val - del local_var_params['kwargs'] - - collection_formats = {} + self._check_operation_params('post_signin', all_params, local_var_params) path_params = {} @@ -101,35 +139,9 @@ def post_signin_with_http_info(self, **kwargs): # noqa: E501,D401,D403 if 'authorization' in local_var_params: header_params['Authorization'] = local_var_params['authorization'] # noqa: E501 - form_params = [] - local_var_files = {} - body_params = None # HTTP header `Accept` header_params['Accept'] = self.api_client.select_header_accept( ['application/json']) # noqa: E501 - # Authentication setting - auth_settings = ['BasicAuthentication'] # noqa: E501 - - # urlopen optional setting - urlopen_kw = None - if 'urlopen_kw' in kwargs: - urlopen_kw = kwargs['urlopen_kw'] - - return self.api_client.call_api( - '/api/v2/signin', 'POST', - path_params, - query_params, - header_params, - body=body_params, - post_params=form_params, - files=local_var_files, - response_type=None, # noqa: E501 - auth_settings=auth_settings, - async_req=local_var_params.get('async_req'), - _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 - _preload_content=local_var_params.get('_preload_content', True), - _request_timeout=local_var_params.get('_request_timeout'), - collection_formats=collection_formats, - urlopen_kw=urlopen_kw) + return local_var_params, path_params, query_params, header_params, body_params diff --git a/influxdb_client/service/signout_service.py b/influxdb_client/service/signout_service.py index ffee18b1..fefb4094 100644 --- a/influxdb_client/service/signout_service.py +++ b/influxdb_client/service/signout_service.py @@ -14,11 +14,10 @@ import re # noqa: F401 -# python 2 and python 3 compatibility library -import six +from influxdb_client.service._base_service import _BaseService -class SignoutService(object): +class SignoutService(_BaseService): """NOTE: This class is auto generated by OpenAPI Generator. Ref: https://openapi-generator.tech @@ -69,25 +68,63 @@ def post_signout_with_http_info(self, **kwargs): # noqa: E501,D401,D403 If the method is called asynchronously, returns the request thread. """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._post_signout_prepare(**kwargs) + + return self.api_client.call_api( + '/api/v2/signout', 'POST', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type=None, # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + async def post_signout_async(self, **kwargs): # noqa: E501,D401,D403 + """Expire the current UI session. + + Expires the current UI session for the user. + This method makes an asynchronous HTTP request. + + :param async_req bool + :param str zap_trace_span: OpenTracing span context + :return: None + If the method is called asynchronously, + returns the request thread. + """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._post_signout_prepare(**kwargs) + + return await self.api_client.call_api( + '/api/v2/signout', 'POST', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type=None, # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + def _post_signout_prepare(self, **kwargs): # noqa: E501,D401,D403 local_var_params = locals() all_params = ['zap_trace_span'] # noqa: E501 - all_params.append('async_req') - all_params.append('_return_http_data_only') - all_params.append('_preload_content') - all_params.append('_request_timeout') - all_params.append('urlopen_kw') - - for key, val in six.iteritems(local_var_params['kwargs']): - if key not in all_params: - raise TypeError( - "Got an unexpected keyword argument '%s'" - " to method post_signout" % key - ) - local_var_params[key] = val - del local_var_params['kwargs'] - - collection_formats = {} + self._check_operation_params('post_signout', all_params, local_var_params) path_params = {} @@ -97,35 +134,9 @@ def post_signout_with_http_info(self, **kwargs): # noqa: E501,D401,D403 if 'zap_trace_span' in local_var_params: header_params['Zap-Trace-Span'] = local_var_params['zap_trace_span'] # noqa: E501 - form_params = [] - local_var_files = {} - body_params = None # HTTP header `Accept` header_params['Accept'] = self.api_client.select_header_accept( ['application/json']) # noqa: E501 - # Authentication setting - auth_settings = [] # noqa: E501 - - # urlopen optional setting - urlopen_kw = None - if 'urlopen_kw' in kwargs: - urlopen_kw = kwargs['urlopen_kw'] - - return self.api_client.call_api( - '/api/v2/signout', 'POST', - path_params, - query_params, - header_params, - body=body_params, - post_params=form_params, - files=local_var_files, - response_type=None, # noqa: E501 - auth_settings=auth_settings, - async_req=local_var_params.get('async_req'), - _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 - _preload_content=local_var_params.get('_preload_content', True), - _request_timeout=local_var_params.get('_request_timeout'), - collection_formats=collection_formats, - urlopen_kw=urlopen_kw) + return local_var_params, path_params, query_params, header_params, body_params diff --git a/influxdb_client/service/sources_service.py b/influxdb_client/service/sources_service.py index cf4d056d..6ed6b035 100644 --- a/influxdb_client/service/sources_service.py +++ b/influxdb_client/service/sources_service.py @@ -14,11 +14,10 @@ import re # noqa: F401 -# python 2 and python 3 compatibility library -import six +from influxdb_client.service._base_service import _BaseService -class SourcesService(object): +class SourcesService(_BaseService): """NOTE: This class is auto generated by OpenAPI Generator. Ref: https://openapi-generator.tech @@ -69,30 +68,68 @@ def delete_sources_id_with_http_info(self, source_id, **kwargs): # noqa: E501,D If the method is called asynchronously, returns the request thread. """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._delete_sources_id_prepare(source_id, **kwargs) + + return self.api_client.call_api( + '/api/v2/sources/{sourceID}', 'DELETE', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type=None, # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + async def delete_sources_id_async(self, source_id, **kwargs): # noqa: E501,D401,D403 + """Delete a source. + + This method makes an asynchronous HTTP request. + + :param async_req bool + :param str source_id: The source ID. (required) + :param str zap_trace_span: OpenTracing span context + :return: None + If the method is called asynchronously, + returns the request thread. + """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._delete_sources_id_prepare(source_id, **kwargs) + + return await self.api_client.call_api( + '/api/v2/sources/{sourceID}', 'DELETE', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type=None, # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + def _delete_sources_id_prepare(self, source_id, **kwargs): # noqa: E501,D401,D403 local_var_params = locals() all_params = ['source_id', 'zap_trace_span'] # noqa: E501 - all_params.append('async_req') - all_params.append('_return_http_data_only') - all_params.append('_preload_content') - all_params.append('_request_timeout') - all_params.append('urlopen_kw') - - for key, val in six.iteritems(local_var_params['kwargs']): - if key not in all_params: - raise TypeError( - "Got an unexpected keyword argument '%s'" - " to method delete_sources_id" % key - ) - local_var_params[key] = val - del local_var_params['kwargs'] + self._check_operation_params('delete_sources_id', all_params, local_var_params) # verify the required parameter 'source_id' is set if ('source_id' not in local_var_params or local_var_params['source_id'] is None): raise ValueError("Missing the required parameter `source_id` when calling `delete_sources_id`") # noqa: E501 - collection_formats = {} - path_params = {} if 'source_id' in local_var_params: path_params['sourceID'] = local_var_params['source_id'] # noqa: E501 @@ -103,38 +140,12 @@ def delete_sources_id_with_http_info(self, source_id, **kwargs): # noqa: E501,D if 'zap_trace_span' in local_var_params: header_params['Zap-Trace-Span'] = local_var_params['zap_trace_span'] # noqa: E501 - form_params = [] - local_var_files = {} - body_params = None # HTTP header `Accept` header_params['Accept'] = self.api_client.select_header_accept( ['application/json']) # noqa: E501 - # Authentication setting - auth_settings = [] # noqa: E501 - - # urlopen optional setting - urlopen_kw = None - if 'urlopen_kw' in kwargs: - urlopen_kw = kwargs['urlopen_kw'] - - return self.api_client.call_api( - '/api/v2/sources/{sourceID}', 'DELETE', - path_params, - query_params, - header_params, - body=body_params, - post_params=form_params, - files=local_var_files, - response_type=None, # noqa: E501 - auth_settings=auth_settings, - async_req=local_var_params.get('async_req'), - _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 - _preload_content=local_var_params.get('_preload_content', True), - _request_timeout=local_var_params.get('_request_timeout'), - collection_formats=collection_formats, - urlopen_kw=urlopen_kw) + return local_var_params, path_params, query_params, header_params, body_params def get_sources(self, **kwargs): # noqa: E501,D401,D403 """List all sources. @@ -173,25 +184,63 @@ def get_sources_with_http_info(self, **kwargs): # noqa: E501,D401,D403 If the method is called asynchronously, returns the request thread. """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._get_sources_prepare(**kwargs) + + return self.api_client.call_api( + '/api/v2/sources', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='Sources', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + async def get_sources_async(self, **kwargs): # noqa: E501,D401,D403 + """List all sources. + + This method makes an asynchronous HTTP request. + + :param async_req bool + :param str zap_trace_span: OpenTracing span context + :param str org: The name of the organization. + :return: Sources + If the method is called asynchronously, + returns the request thread. + """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._get_sources_prepare(**kwargs) + + return await self.api_client.call_api( + '/api/v2/sources', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='Sources', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + def _get_sources_prepare(self, **kwargs): # noqa: E501,D401,D403 local_var_params = locals() all_params = ['zap_trace_span', 'org'] # noqa: E501 - all_params.append('async_req') - all_params.append('_return_http_data_only') - all_params.append('_preload_content') - all_params.append('_request_timeout') - all_params.append('urlopen_kw') - - for key, val in six.iteritems(local_var_params['kwargs']): - if key not in all_params: - raise TypeError( - "Got an unexpected keyword argument '%s'" - " to method get_sources" % key - ) - local_var_params[key] = val - del local_var_params['kwargs'] - - collection_formats = {} + self._check_operation_params('get_sources', all_params, local_var_params) path_params = {} @@ -203,38 +252,12 @@ def get_sources_with_http_info(self, **kwargs): # noqa: E501,D401,D403 if 'zap_trace_span' in local_var_params: header_params['Zap-Trace-Span'] = local_var_params['zap_trace_span'] # noqa: E501 - form_params = [] - local_var_files = {} - body_params = None # HTTP header `Accept` header_params['Accept'] = self.api_client.select_header_accept( ['application/json']) # noqa: E501 - # Authentication setting - auth_settings = [] # noqa: E501 - - # urlopen optional setting - urlopen_kw = None - if 'urlopen_kw' in kwargs: - urlopen_kw = kwargs['urlopen_kw'] - - return self.api_client.call_api( - '/api/v2/sources', 'GET', - path_params, - query_params, - header_params, - body=body_params, - post_params=form_params, - files=local_var_files, - response_type='Sources', # noqa: E501 - auth_settings=auth_settings, - async_req=local_var_params.get('async_req'), - _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 - _preload_content=local_var_params.get('_preload_content', True), - _request_timeout=local_var_params.get('_request_timeout'), - collection_formats=collection_formats, - urlopen_kw=urlopen_kw) + return local_var_params, path_params, query_params, header_params, body_params def get_sources_id(self, source_id, **kwargs): # noqa: E501,D401,D403 """Retrieve a source. @@ -273,30 +296,68 @@ def get_sources_id_with_http_info(self, source_id, **kwargs): # noqa: E501,D401 If the method is called asynchronously, returns the request thread. """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._get_sources_id_prepare(source_id, **kwargs) + + return self.api_client.call_api( + '/api/v2/sources/{sourceID}', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='Source', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + async def get_sources_id_async(self, source_id, **kwargs): # noqa: E501,D401,D403 + """Retrieve a source. + + This method makes an asynchronous HTTP request. + + :param async_req bool + :param str source_id: The source ID. (required) + :param str zap_trace_span: OpenTracing span context + :return: Source + If the method is called asynchronously, + returns the request thread. + """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._get_sources_id_prepare(source_id, **kwargs) + + return await self.api_client.call_api( + '/api/v2/sources/{sourceID}', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='Source', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + def _get_sources_id_prepare(self, source_id, **kwargs): # noqa: E501,D401,D403 local_var_params = locals() all_params = ['source_id', 'zap_trace_span'] # noqa: E501 - all_params.append('async_req') - all_params.append('_return_http_data_only') - all_params.append('_preload_content') - all_params.append('_request_timeout') - all_params.append('urlopen_kw') - - for key, val in six.iteritems(local_var_params['kwargs']): - if key not in all_params: - raise TypeError( - "Got an unexpected keyword argument '%s'" - " to method get_sources_id" % key - ) - local_var_params[key] = val - del local_var_params['kwargs'] + self._check_operation_params('get_sources_id', all_params, local_var_params) # verify the required parameter 'source_id' is set if ('source_id' not in local_var_params or local_var_params['source_id'] is None): raise ValueError("Missing the required parameter `source_id` when calling `get_sources_id`") # noqa: E501 - collection_formats = {} - path_params = {} if 'source_id' in local_var_params: path_params['sourceID'] = local_var_params['source_id'] # noqa: E501 @@ -307,38 +368,12 @@ def get_sources_id_with_http_info(self, source_id, **kwargs): # noqa: E501,D401 if 'zap_trace_span' in local_var_params: header_params['Zap-Trace-Span'] = local_var_params['zap_trace_span'] # noqa: E501 - form_params = [] - local_var_files = {} - body_params = None # HTTP header `Accept` header_params['Accept'] = self.api_client.select_header_accept( ['application/json']) # noqa: E501 - # Authentication setting - auth_settings = [] # noqa: E501 - - # urlopen optional setting - urlopen_kw = None - if 'urlopen_kw' in kwargs: - urlopen_kw = kwargs['urlopen_kw'] - - return self.api_client.call_api( - '/api/v2/sources/{sourceID}', 'GET', - path_params, - query_params, - header_params, - body=body_params, - post_params=form_params, - files=local_var_files, - response_type='Source', # noqa: E501 - auth_settings=auth_settings, - async_req=local_var_params.get('async_req'), - _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 - _preload_content=local_var_params.get('_preload_content', True), - _request_timeout=local_var_params.get('_request_timeout'), - collection_formats=collection_formats, - urlopen_kw=urlopen_kw) + return local_var_params, path_params, query_params, header_params, body_params def get_sources_id_buckets(self, source_id, **kwargs): # noqa: E501,D401,D403 """Get buckets in a source. @@ -379,30 +414,69 @@ def get_sources_id_buckets_with_http_info(self, source_id, **kwargs): # noqa: E If the method is called asynchronously, returns the request thread. """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._get_sources_id_buckets_prepare(source_id, **kwargs) + + return self.api_client.call_api( + '/api/v2/sources/{sourceID}/buckets', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='Buckets', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + async def get_sources_id_buckets_async(self, source_id, **kwargs): # noqa: E501,D401,D403 + """Get buckets in a source. + + This method makes an asynchronous HTTP request. + + :param async_req bool + :param str source_id: The source ID. (required) + :param str zap_trace_span: OpenTracing span context + :param str org: The name of the organization. + :return: Buckets + If the method is called asynchronously, + returns the request thread. + """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._get_sources_id_buckets_prepare(source_id, **kwargs) + + return await self.api_client.call_api( + '/api/v2/sources/{sourceID}/buckets', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='Buckets', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + def _get_sources_id_buckets_prepare(self, source_id, **kwargs): # noqa: E501,D401,D403 local_var_params = locals() all_params = ['source_id', 'zap_trace_span', 'org'] # noqa: E501 - all_params.append('async_req') - all_params.append('_return_http_data_only') - all_params.append('_preload_content') - all_params.append('_request_timeout') - all_params.append('urlopen_kw') - - for key, val in six.iteritems(local_var_params['kwargs']): - if key not in all_params: - raise TypeError( - "Got an unexpected keyword argument '%s'" - " to method get_sources_id_buckets" % key - ) - local_var_params[key] = val - del local_var_params['kwargs'] + self._check_operation_params('get_sources_id_buckets', all_params, local_var_params) # verify the required parameter 'source_id' is set if ('source_id' not in local_var_params or local_var_params['source_id'] is None): raise ValueError("Missing the required parameter `source_id` when calling `get_sources_id_buckets`") # noqa: E501 - collection_formats = {} - path_params = {} if 'source_id' in local_var_params: path_params['sourceID'] = local_var_params['source_id'] # noqa: E501 @@ -415,38 +489,12 @@ def get_sources_id_buckets_with_http_info(self, source_id, **kwargs): # noqa: E if 'zap_trace_span' in local_var_params: header_params['Zap-Trace-Span'] = local_var_params['zap_trace_span'] # noqa: E501 - form_params = [] - local_var_files = {} - body_params = None # HTTP header `Accept` header_params['Accept'] = self.api_client.select_header_accept( ['application/json']) # noqa: E501 - # Authentication setting - auth_settings = [] # noqa: E501 - - # urlopen optional setting - urlopen_kw = None - if 'urlopen_kw' in kwargs: - urlopen_kw = kwargs['urlopen_kw'] - - return self.api_client.call_api( - '/api/v2/sources/{sourceID}/buckets', 'GET', - path_params, - query_params, - header_params, - body=body_params, - post_params=form_params, - files=local_var_files, - response_type='Buckets', # noqa: E501 - auth_settings=auth_settings, - async_req=local_var_params.get('async_req'), - _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 - _preload_content=local_var_params.get('_preload_content', True), - _request_timeout=local_var_params.get('_request_timeout'), - collection_formats=collection_formats, - urlopen_kw=urlopen_kw) + return local_var_params, path_params, query_params, header_params, body_params def get_sources_id_health(self, source_id, **kwargs): # noqa: E501,D401,D403 """Get the health of a source. @@ -485,30 +533,68 @@ def get_sources_id_health_with_http_info(self, source_id, **kwargs): # noqa: E5 If the method is called asynchronously, returns the request thread. """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._get_sources_id_health_prepare(source_id, **kwargs) + + return self.api_client.call_api( + '/api/v2/sources/{sourceID}/health', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='HealthCheck', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + async def get_sources_id_health_async(self, source_id, **kwargs): # noqa: E501,D401,D403 + """Get the health of a source. + + This method makes an asynchronous HTTP request. + + :param async_req bool + :param str source_id: The source ID. (required) + :param str zap_trace_span: OpenTracing span context + :return: HealthCheck + If the method is called asynchronously, + returns the request thread. + """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._get_sources_id_health_prepare(source_id, **kwargs) + + return await self.api_client.call_api( + '/api/v2/sources/{sourceID}/health', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='HealthCheck', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + def _get_sources_id_health_prepare(self, source_id, **kwargs): # noqa: E501,D401,D403 local_var_params = locals() all_params = ['source_id', 'zap_trace_span'] # noqa: E501 - all_params.append('async_req') - all_params.append('_return_http_data_only') - all_params.append('_preload_content') - all_params.append('_request_timeout') - all_params.append('urlopen_kw') - - for key, val in six.iteritems(local_var_params['kwargs']): - if key not in all_params: - raise TypeError( - "Got an unexpected keyword argument '%s'" - " to method get_sources_id_health" % key - ) - local_var_params[key] = val - del local_var_params['kwargs'] + self._check_operation_params('get_sources_id_health', all_params, local_var_params) # verify the required parameter 'source_id' is set if ('source_id' not in local_var_params or local_var_params['source_id'] is None): raise ValueError("Missing the required parameter `source_id` when calling `get_sources_id_health`") # noqa: E501 - collection_formats = {} - path_params = {} if 'source_id' in local_var_params: path_params['sourceID'] = local_var_params['source_id'] # noqa: E501 @@ -519,38 +605,12 @@ def get_sources_id_health_with_http_info(self, source_id, **kwargs): # noqa: E5 if 'zap_trace_span' in local_var_params: header_params['Zap-Trace-Span'] = local_var_params['zap_trace_span'] # noqa: E501 - form_params = [] - local_var_files = {} - body_params = None # HTTP header `Accept` header_params['Accept'] = self.api_client.select_header_accept( ['application/json']) # noqa: E501 - # Authentication setting - auth_settings = [] # noqa: E501 - - # urlopen optional setting - urlopen_kw = None - if 'urlopen_kw' in kwargs: - urlopen_kw = kwargs['urlopen_kw'] - - return self.api_client.call_api( - '/api/v2/sources/{sourceID}/health', 'GET', - path_params, - query_params, - header_params, - body=body_params, - post_params=form_params, - files=local_var_files, - response_type='HealthCheck', # noqa: E501 - auth_settings=auth_settings, - async_req=local_var_params.get('async_req'), - _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 - _preload_content=local_var_params.get('_preload_content', True), - _request_timeout=local_var_params.get('_request_timeout'), - collection_formats=collection_formats, - urlopen_kw=urlopen_kw) + return local_var_params, path_params, query_params, header_params, body_params def patch_sources_id(self, source_id, source, **kwargs): # noqa: E501,D401,D403 """Update a Source. @@ -591,23 +651,64 @@ def patch_sources_id_with_http_info(self, source_id, source, **kwargs): # noqa: If the method is called asynchronously, returns the request thread. """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._patch_sources_id_prepare(source_id, source, **kwargs) + + return self.api_client.call_api( + '/api/v2/sources/{sourceID}', 'PATCH', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='Source', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + async def patch_sources_id_async(self, source_id, source, **kwargs): # noqa: E501,D401,D403 + """Update a Source. + + This method makes an asynchronous HTTP request. + + :param async_req bool + :param str source_id: The source ID. (required) + :param Source source: Source update (required) + :param str zap_trace_span: OpenTracing span context + :return: Source + If the method is called asynchronously, + returns the request thread. + """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._patch_sources_id_prepare(source_id, source, **kwargs) + + return await self.api_client.call_api( + '/api/v2/sources/{sourceID}', 'PATCH', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='Source', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + def _patch_sources_id_prepare(self, source_id, source, **kwargs): # noqa: E501,D401,D403 local_var_params = locals() all_params = ['source_id', 'source', 'zap_trace_span'] # noqa: E501 - all_params.append('async_req') - all_params.append('_return_http_data_only') - all_params.append('_preload_content') - all_params.append('_request_timeout') - all_params.append('urlopen_kw') - - for key, val in six.iteritems(local_var_params['kwargs']): - if key not in all_params: - raise TypeError( - "Got an unexpected keyword argument '%s'" - " to method patch_sources_id" % key - ) - local_var_params[key] = val - del local_var_params['kwargs'] + self._check_operation_params('patch_sources_id', all_params, local_var_params) # verify the required parameter 'source_id' is set if ('source_id' not in local_var_params or local_var_params['source_id'] is None): @@ -617,8 +718,6 @@ def patch_sources_id_with_http_info(self, source_id, source, **kwargs): # noqa: local_var_params['source'] is None): raise ValueError("Missing the required parameter `source` when calling `patch_sources_id`") # noqa: E501 - collection_formats = {} - path_params = {} if 'source_id' in local_var_params: path_params['sourceID'] = local_var_params['source_id'] # noqa: E501 @@ -629,9 +728,6 @@ def patch_sources_id_with_http_info(self, source_id, source, **kwargs): # noqa: if 'zap_trace_span' in local_var_params: header_params['Zap-Trace-Span'] = local_var_params['zap_trace_span'] # noqa: E501 - form_params = [] - local_var_files = {} - body_params = None if 'source' in local_var_params: body_params = local_var_params['source'] @@ -643,30 +739,7 @@ def patch_sources_id_with_http_info(self, source_id, source, **kwargs): # noqa: header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501 ['application/json']) # noqa: E501 - # Authentication setting - auth_settings = [] # noqa: E501 - - # urlopen optional setting - urlopen_kw = None - if 'urlopen_kw' in kwargs: - urlopen_kw = kwargs['urlopen_kw'] - - return self.api_client.call_api( - '/api/v2/sources/{sourceID}', 'PATCH', - path_params, - query_params, - header_params, - body=body_params, - post_params=form_params, - files=local_var_files, - response_type='Source', # noqa: E501 - auth_settings=auth_settings, - async_req=local_var_params.get('async_req'), - _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 - _preload_content=local_var_params.get('_preload_content', True), - _request_timeout=local_var_params.get('_request_timeout'), - collection_formats=collection_formats, - urlopen_kw=urlopen_kw) + return local_var_params, path_params, query_params, header_params, body_params def post_sources(self, source, **kwargs): # noqa: E501,D401,D403 """Create a source. @@ -705,30 +778,68 @@ def post_sources_with_http_info(self, source, **kwargs): # noqa: E501,D401,D403 If the method is called asynchronously, returns the request thread. """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._post_sources_prepare(source, **kwargs) + + return self.api_client.call_api( + '/api/v2/sources', 'POST', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='Source', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + async def post_sources_async(self, source, **kwargs): # noqa: E501,D401,D403 + """Create a source. + + This method makes an asynchronous HTTP request. + + :param async_req bool + :param Source source: Source to create (required) + :param str zap_trace_span: OpenTracing span context + :return: Source + If the method is called asynchronously, + returns the request thread. + """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._post_sources_prepare(source, **kwargs) + + return await self.api_client.call_api( + '/api/v2/sources', 'POST', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='Source', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + def _post_sources_prepare(self, source, **kwargs): # noqa: E501,D401,D403 local_var_params = locals() all_params = ['source', 'zap_trace_span'] # noqa: E501 - all_params.append('async_req') - all_params.append('_return_http_data_only') - all_params.append('_preload_content') - all_params.append('_request_timeout') - all_params.append('urlopen_kw') - - for key, val in six.iteritems(local_var_params['kwargs']): - if key not in all_params: - raise TypeError( - "Got an unexpected keyword argument '%s'" - " to method post_sources" % key - ) - local_var_params[key] = val - del local_var_params['kwargs'] + self._check_operation_params('post_sources', all_params, local_var_params) # verify the required parameter 'source' is set if ('source' not in local_var_params or local_var_params['source'] is None): raise ValueError("Missing the required parameter `source` when calling `post_sources`") # noqa: E501 - collection_formats = {} - path_params = {} query_params = [] @@ -737,9 +848,6 @@ def post_sources_with_http_info(self, source, **kwargs): # noqa: E501,D401,D403 if 'zap_trace_span' in local_var_params: header_params['Zap-Trace-Span'] = local_var_params['zap_trace_span'] # noqa: E501 - form_params = [] - local_var_files = {} - body_params = None if 'source' in local_var_params: body_params = local_var_params['source'] @@ -751,27 +859,4 @@ def post_sources_with_http_info(self, source, **kwargs): # noqa: E501,D401,D403 header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501 ['application/json']) # noqa: E501 - # Authentication setting - auth_settings = [] # noqa: E501 - - # urlopen optional setting - urlopen_kw = None - if 'urlopen_kw' in kwargs: - urlopen_kw = kwargs['urlopen_kw'] - - return self.api_client.call_api( - '/api/v2/sources', 'POST', - path_params, - query_params, - header_params, - body=body_params, - post_params=form_params, - files=local_var_files, - response_type='Source', # noqa: E501 - auth_settings=auth_settings, - async_req=local_var_params.get('async_req'), - _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 - _preload_content=local_var_params.get('_preload_content', True), - _request_timeout=local_var_params.get('_request_timeout'), - collection_formats=collection_formats, - urlopen_kw=urlopen_kw) + return local_var_params, path_params, query_params, header_params, body_params diff --git a/influxdb_client/service/tasks_service.py b/influxdb_client/service/tasks_service.py index fbd4b272..6b4491ab 100644 --- a/influxdb_client/service/tasks_service.py +++ b/influxdb_client/service/tasks_service.py @@ -14,11 +14,10 @@ import re # noqa: F401 -# python 2 and python 3 compatibility library -import six +from influxdb_client.service._base_service import _BaseService -class TasksService(object): +class TasksService(_BaseService): """NOTE: This class is auto generated by OpenAPI Generator. Ref: https://openapi-generator.tech @@ -71,30 +70,69 @@ def delete_tasks_id_with_http_info(self, task_id, **kwargs): # noqa: E501,D401, If the method is called asynchronously, returns the request thread. """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._delete_tasks_id_prepare(task_id, **kwargs) + + return self.api_client.call_api( + '/api/v2/tasks/{taskID}', 'DELETE', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type=None, # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + async def delete_tasks_id_async(self, task_id, **kwargs): # noqa: E501,D401,D403 + """Delete a task. + + Deletes a task and all associated records + This method makes an asynchronous HTTP request. + + :param async_req bool + :param str task_id: The ID of the task to delete. (required) + :param str zap_trace_span: OpenTracing span context + :return: None + If the method is called asynchronously, + returns the request thread. + """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._delete_tasks_id_prepare(task_id, **kwargs) + + return await self.api_client.call_api( + '/api/v2/tasks/{taskID}', 'DELETE', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type=None, # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + def _delete_tasks_id_prepare(self, task_id, **kwargs): # noqa: E501,D401,D403 local_var_params = locals() all_params = ['task_id', 'zap_trace_span'] # noqa: E501 - all_params.append('async_req') - all_params.append('_return_http_data_only') - all_params.append('_preload_content') - all_params.append('_request_timeout') - all_params.append('urlopen_kw') - - for key, val in six.iteritems(local_var_params['kwargs']): - if key not in all_params: - raise TypeError( - "Got an unexpected keyword argument '%s'" - " to method delete_tasks_id" % key - ) - local_var_params[key] = val - del local_var_params['kwargs'] + self._check_operation_params('delete_tasks_id', all_params, local_var_params) # verify the required parameter 'task_id' is set if ('task_id' not in local_var_params or local_var_params['task_id'] is None): raise ValueError("Missing the required parameter `task_id` when calling `delete_tasks_id`") # noqa: E501 - collection_formats = {} - path_params = {} if 'task_id' in local_var_params: path_params['taskID'] = local_var_params['task_id'] # noqa: E501 @@ -105,38 +143,12 @@ def delete_tasks_id_with_http_info(self, task_id, **kwargs): # noqa: E501,D401, if 'zap_trace_span' in local_var_params: header_params['Zap-Trace-Span'] = local_var_params['zap_trace_span'] # noqa: E501 - form_params = [] - local_var_files = {} - body_params = None # HTTP header `Accept` header_params['Accept'] = self.api_client.select_header_accept( ['application/json']) # noqa: E501 - # Authentication setting - auth_settings = [] # noqa: E501 - - # urlopen optional setting - urlopen_kw = None - if 'urlopen_kw' in kwargs: - urlopen_kw = kwargs['urlopen_kw'] - - return self.api_client.call_api( - '/api/v2/tasks/{taskID}', 'DELETE', - path_params, - query_params, - header_params, - body=body_params, - post_params=form_params, - files=local_var_files, - response_type=None, # noqa: E501 - auth_settings=auth_settings, - async_req=local_var_params.get('async_req'), - _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 - _preload_content=local_var_params.get('_preload_content', True), - _request_timeout=local_var_params.get('_request_timeout'), - collection_formats=collection_formats, - urlopen_kw=urlopen_kw) + return local_var_params, path_params, query_params, header_params, body_params def delete_tasks_id_labels_id(self, task_id, label_id, **kwargs): # noqa: E501,D401,D403 """Delete a label from a task. @@ -177,23 +189,64 @@ def delete_tasks_id_labels_id_with_http_info(self, task_id, label_id, **kwargs): If the method is called asynchronously, returns the request thread. """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._delete_tasks_id_labels_id_prepare(task_id, label_id, **kwargs) + + return self.api_client.call_api( + '/api/v2/tasks/{taskID}/labels/{labelID}', 'DELETE', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type=None, # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + async def delete_tasks_id_labels_id_async(self, task_id, label_id, **kwargs): # noqa: E501,D401,D403 + """Delete a label from a task. + + This method makes an asynchronous HTTP request. + + :param async_req bool + :param str task_id: The task ID. (required) + :param str label_id: The label ID. (required) + :param str zap_trace_span: OpenTracing span context + :return: None + If the method is called asynchronously, + returns the request thread. + """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._delete_tasks_id_labels_id_prepare(task_id, label_id, **kwargs) + + return await self.api_client.call_api( + '/api/v2/tasks/{taskID}/labels/{labelID}', 'DELETE', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type=None, # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + def _delete_tasks_id_labels_id_prepare(self, task_id, label_id, **kwargs): # noqa: E501,D401,D403 local_var_params = locals() all_params = ['task_id', 'label_id', 'zap_trace_span'] # noqa: E501 - all_params.append('async_req') - all_params.append('_return_http_data_only') - all_params.append('_preload_content') - all_params.append('_request_timeout') - all_params.append('urlopen_kw') - - for key, val in six.iteritems(local_var_params['kwargs']): - if key not in all_params: - raise TypeError( - "Got an unexpected keyword argument '%s'" - " to method delete_tasks_id_labels_id" % key - ) - local_var_params[key] = val - del local_var_params['kwargs'] + self._check_operation_params('delete_tasks_id_labels_id', all_params, local_var_params) # verify the required parameter 'task_id' is set if ('task_id' not in local_var_params or local_var_params['task_id'] is None): @@ -203,8 +256,6 @@ def delete_tasks_id_labels_id_with_http_info(self, task_id, label_id, **kwargs): local_var_params['label_id'] is None): raise ValueError("Missing the required parameter `label_id` when calling `delete_tasks_id_labels_id`") # noqa: E501 - collection_formats = {} - path_params = {} if 'task_id' in local_var_params: path_params['taskID'] = local_var_params['task_id'] # noqa: E501 @@ -217,38 +268,12 @@ def delete_tasks_id_labels_id_with_http_info(self, task_id, label_id, **kwargs): if 'zap_trace_span' in local_var_params: header_params['Zap-Trace-Span'] = local_var_params['zap_trace_span'] # noqa: E501 - form_params = [] - local_var_files = {} - body_params = None # HTTP header `Accept` header_params['Accept'] = self.api_client.select_header_accept( ['application/json']) # noqa: E501 - # Authentication setting - auth_settings = [] # noqa: E501 - - # urlopen optional setting - urlopen_kw = None - if 'urlopen_kw' in kwargs: - urlopen_kw = kwargs['urlopen_kw'] - - return self.api_client.call_api( - '/api/v2/tasks/{taskID}/labels/{labelID}', 'DELETE', - path_params, - query_params, - header_params, - body=body_params, - post_params=form_params, - files=local_var_files, - response_type=None, # noqa: E501 - auth_settings=auth_settings, - async_req=local_var_params.get('async_req'), - _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 - _preload_content=local_var_params.get('_preload_content', True), - _request_timeout=local_var_params.get('_request_timeout'), - collection_formats=collection_formats, - urlopen_kw=urlopen_kw) + return local_var_params, path_params, query_params, header_params, body_params def delete_tasks_id_members_id(self, user_id, task_id, **kwargs): # noqa: E501,D401,D403 """Remove a member from a task. @@ -289,23 +314,64 @@ def delete_tasks_id_members_id_with_http_info(self, user_id, task_id, **kwargs): If the method is called asynchronously, returns the request thread. """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._delete_tasks_id_members_id_prepare(user_id, task_id, **kwargs) + + return self.api_client.call_api( + '/api/v2/tasks/{taskID}/members/{userID}', 'DELETE', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type=None, # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + async def delete_tasks_id_members_id_async(self, user_id, task_id, **kwargs): # noqa: E501,D401,D403 + """Remove a member from a task. + + This method makes an asynchronous HTTP request. + + :param async_req bool + :param str user_id: The ID of the member to remove. (required) + :param str task_id: The task ID. (required) + :param str zap_trace_span: OpenTracing span context + :return: None + If the method is called asynchronously, + returns the request thread. + """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._delete_tasks_id_members_id_prepare(user_id, task_id, **kwargs) + + return await self.api_client.call_api( + '/api/v2/tasks/{taskID}/members/{userID}', 'DELETE', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type=None, # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + def _delete_tasks_id_members_id_prepare(self, user_id, task_id, **kwargs): # noqa: E501,D401,D403 local_var_params = locals() all_params = ['user_id', 'task_id', 'zap_trace_span'] # noqa: E501 - all_params.append('async_req') - all_params.append('_return_http_data_only') - all_params.append('_preload_content') - all_params.append('_request_timeout') - all_params.append('urlopen_kw') - - for key, val in six.iteritems(local_var_params['kwargs']): - if key not in all_params: - raise TypeError( - "Got an unexpected keyword argument '%s'" - " to method delete_tasks_id_members_id" % key - ) - local_var_params[key] = val - del local_var_params['kwargs'] + self._check_operation_params('delete_tasks_id_members_id', all_params, local_var_params) # verify the required parameter 'user_id' is set if ('user_id' not in local_var_params or local_var_params['user_id'] is None): @@ -315,8 +381,6 @@ def delete_tasks_id_members_id_with_http_info(self, user_id, task_id, **kwargs): local_var_params['task_id'] is None): raise ValueError("Missing the required parameter `task_id` when calling `delete_tasks_id_members_id`") # noqa: E501 - collection_formats = {} - path_params = {} if 'user_id' in local_var_params: path_params['userID'] = local_var_params['user_id'] # noqa: E501 @@ -329,38 +393,12 @@ def delete_tasks_id_members_id_with_http_info(self, user_id, task_id, **kwargs): if 'zap_trace_span' in local_var_params: header_params['Zap-Trace-Span'] = local_var_params['zap_trace_span'] # noqa: E501 - form_params = [] - local_var_files = {} - body_params = None # HTTP header `Accept` header_params['Accept'] = self.api_client.select_header_accept( ['application/json']) # noqa: E501 - # Authentication setting - auth_settings = [] # noqa: E501 - - # urlopen optional setting - urlopen_kw = None - if 'urlopen_kw' in kwargs: - urlopen_kw = kwargs['urlopen_kw'] - - return self.api_client.call_api( - '/api/v2/tasks/{taskID}/members/{userID}', 'DELETE', - path_params, - query_params, - header_params, - body=body_params, - post_params=form_params, - files=local_var_files, - response_type=None, # noqa: E501 - auth_settings=auth_settings, - async_req=local_var_params.get('async_req'), - _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 - _preload_content=local_var_params.get('_preload_content', True), - _request_timeout=local_var_params.get('_request_timeout'), - collection_formats=collection_formats, - urlopen_kw=urlopen_kw) + return local_var_params, path_params, query_params, header_params, body_params def delete_tasks_id_owners_id(self, user_id, task_id, **kwargs): # noqa: E501,D401,D403 """Remove an owner from a task. @@ -401,23 +439,64 @@ def delete_tasks_id_owners_id_with_http_info(self, user_id, task_id, **kwargs): If the method is called asynchronously, returns the request thread. """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._delete_tasks_id_owners_id_prepare(user_id, task_id, **kwargs) + + return self.api_client.call_api( + '/api/v2/tasks/{taskID}/owners/{userID}', 'DELETE', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type=None, # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + async def delete_tasks_id_owners_id_async(self, user_id, task_id, **kwargs): # noqa: E501,D401,D403 + """Remove an owner from a task. + + This method makes an asynchronous HTTP request. + + :param async_req bool + :param str user_id: The ID of the owner to remove. (required) + :param str task_id: The task ID. (required) + :param str zap_trace_span: OpenTracing span context + :return: None + If the method is called asynchronously, + returns the request thread. + """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._delete_tasks_id_owners_id_prepare(user_id, task_id, **kwargs) + + return await self.api_client.call_api( + '/api/v2/tasks/{taskID}/owners/{userID}', 'DELETE', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type=None, # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + def _delete_tasks_id_owners_id_prepare(self, user_id, task_id, **kwargs): # noqa: E501,D401,D403 local_var_params = locals() all_params = ['user_id', 'task_id', 'zap_trace_span'] # noqa: E501 - all_params.append('async_req') - all_params.append('_return_http_data_only') - all_params.append('_preload_content') - all_params.append('_request_timeout') - all_params.append('urlopen_kw') - - for key, val in six.iteritems(local_var_params['kwargs']): - if key not in all_params: - raise TypeError( - "Got an unexpected keyword argument '%s'" - " to method delete_tasks_id_owners_id" % key - ) - local_var_params[key] = val - del local_var_params['kwargs'] + self._check_operation_params('delete_tasks_id_owners_id', all_params, local_var_params) # verify the required parameter 'user_id' is set if ('user_id' not in local_var_params or local_var_params['user_id'] is None): @@ -427,8 +506,6 @@ def delete_tasks_id_owners_id_with_http_info(self, user_id, task_id, **kwargs): local_var_params['task_id'] is None): raise ValueError("Missing the required parameter `task_id` when calling `delete_tasks_id_owners_id`") # noqa: E501 - collection_formats = {} - path_params = {} if 'user_id' in local_var_params: path_params['userID'] = local_var_params['user_id'] # noqa: E501 @@ -441,38 +518,12 @@ def delete_tasks_id_owners_id_with_http_info(self, user_id, task_id, **kwargs): if 'zap_trace_span' in local_var_params: header_params['Zap-Trace-Span'] = local_var_params['zap_trace_span'] # noqa: E501 - form_params = [] - local_var_files = {} - body_params = None # HTTP header `Accept` header_params['Accept'] = self.api_client.select_header_accept( ['application/json']) # noqa: E501 - # Authentication setting - auth_settings = [] # noqa: E501 - - # urlopen optional setting - urlopen_kw = None - if 'urlopen_kw' in kwargs: - urlopen_kw = kwargs['urlopen_kw'] - - return self.api_client.call_api( - '/api/v2/tasks/{taskID}/owners/{userID}', 'DELETE', - path_params, - query_params, - header_params, - body=body_params, - post_params=form_params, - files=local_var_files, - response_type=None, # noqa: E501 - auth_settings=auth_settings, - async_req=local_var_params.get('async_req'), - _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 - _preload_content=local_var_params.get('_preload_content', True), - _request_timeout=local_var_params.get('_request_timeout'), - collection_formats=collection_formats, - urlopen_kw=urlopen_kw) + return local_var_params, path_params, query_params, header_params, body_params def delete_tasks_id_runs_id(self, task_id, run_id, **kwargs): # noqa: E501,D401,D403 """Cancel a running task. @@ -513,23 +564,64 @@ def delete_tasks_id_runs_id_with_http_info(self, task_id, run_id, **kwargs): # If the method is called asynchronously, returns the request thread. """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._delete_tasks_id_runs_id_prepare(task_id, run_id, **kwargs) + + return self.api_client.call_api( + '/api/v2/tasks/{taskID}/runs/{runID}', 'DELETE', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type=None, # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + async def delete_tasks_id_runs_id_async(self, task_id, run_id, **kwargs): # noqa: E501,D401,D403 + """Cancel a running task. + + This method makes an asynchronous HTTP request. + + :param async_req bool + :param str task_id: The task ID. (required) + :param str run_id: The run ID. (required) + :param str zap_trace_span: OpenTracing span context + :return: None + If the method is called asynchronously, + returns the request thread. + """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._delete_tasks_id_runs_id_prepare(task_id, run_id, **kwargs) + + return await self.api_client.call_api( + '/api/v2/tasks/{taskID}/runs/{runID}', 'DELETE', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type=None, # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + def _delete_tasks_id_runs_id_prepare(self, task_id, run_id, **kwargs): # noqa: E501,D401,D403 local_var_params = locals() all_params = ['task_id', 'run_id', 'zap_trace_span'] # noqa: E501 - all_params.append('async_req') - all_params.append('_return_http_data_only') - all_params.append('_preload_content') - all_params.append('_request_timeout') - all_params.append('urlopen_kw') - - for key, val in six.iteritems(local_var_params['kwargs']): - if key not in all_params: - raise TypeError( - "Got an unexpected keyword argument '%s'" - " to method delete_tasks_id_runs_id" % key - ) - local_var_params[key] = val - del local_var_params['kwargs'] + self._check_operation_params('delete_tasks_id_runs_id', all_params, local_var_params) # verify the required parameter 'task_id' is set if ('task_id' not in local_var_params or local_var_params['task_id'] is None): @@ -539,8 +631,6 @@ def delete_tasks_id_runs_id_with_http_info(self, task_id, run_id, **kwargs): # local_var_params['run_id'] is None): raise ValueError("Missing the required parameter `run_id` when calling `delete_tasks_id_runs_id`") # noqa: E501 - collection_formats = {} - path_params = {} if 'task_id' in local_var_params: path_params['taskID'] = local_var_params['task_id'] # noqa: E501 @@ -553,38 +643,12 @@ def delete_tasks_id_runs_id_with_http_info(self, task_id, run_id, **kwargs): # if 'zap_trace_span' in local_var_params: header_params['Zap-Trace-Span'] = local_var_params['zap_trace_span'] # noqa: E501 - form_params = [] - local_var_files = {} - body_params = None # HTTP header `Accept` header_params['Accept'] = self.api_client.select_header_accept( ['application/json']) # noqa: E501 - # Authentication setting - auth_settings = [] # noqa: E501 - - # urlopen optional setting - urlopen_kw = None - if 'urlopen_kw' in kwargs: - urlopen_kw = kwargs['urlopen_kw'] - - return self.api_client.call_api( - '/api/v2/tasks/{taskID}/runs/{runID}', 'DELETE', - path_params, - query_params, - header_params, - body=body_params, - post_params=form_params, - files=local_var_files, - response_type=None, # noqa: E501 - auth_settings=auth_settings, - async_req=local_var_params.get('async_req'), - _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 - _preload_content=local_var_params.get('_preload_content', True), - _request_timeout=local_var_params.get('_request_timeout'), - collection_formats=collection_formats, - urlopen_kw=urlopen_kw) + return local_var_params, path_params, query_params, header_params, body_params def get_tasks(self, **kwargs): # noqa: E501,D401,D403 """List all tasks. @@ -637,30 +701,75 @@ def get_tasks_with_http_info(self, **kwargs): # noqa: E501,D401,D403 If the method is called asynchronously, returns the request thread. """ # noqa: E501 - local_var_params = locals() + local_var_params, path_params, query_params, header_params, body_params = \ + self._get_tasks_prepare(**kwargs) + + return self.api_client.call_api( + '/api/v2/tasks', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='Tasks', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + async def get_tasks_async(self, **kwargs): # noqa: E501,D401,D403 + """List all tasks. + + This method makes an asynchronous HTTP request. + + :param async_req bool + :param str zap_trace_span: OpenTracing span context + :param str name: Returns task with a specific name. + :param str after: Return tasks after a specified ID. + :param str user: Filter tasks to a specific user ID. + :param str org: Filter tasks to a specific organization name. + :param str org_id: Filter tasks to a specific organization ID. + :param str status: Filter tasks by a status--"inactive" or "active". + :param int limit: The number of tasks to return + :param str type: Type of task, unset by default. + :return: Tasks + If the method is called asynchronously, + returns the request thread. + """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._get_tasks_prepare(**kwargs) + + return await self.api_client.call_api( + '/api/v2/tasks', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='Tasks', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + def _get_tasks_prepare(self, **kwargs): # noqa: E501,D401,D403 + local_var_params = locals() all_params = ['zap_trace_span', 'name', 'after', 'user', 'org', 'org_id', 'status', 'limit', 'type'] # noqa: E501 - all_params.append('async_req') - all_params.append('_return_http_data_only') - all_params.append('_preload_content') - all_params.append('_request_timeout') - all_params.append('urlopen_kw') - - for key, val in six.iteritems(local_var_params['kwargs']): - if key not in all_params: - raise TypeError( - "Got an unexpected keyword argument '%s'" - " to method get_tasks" % key - ) - local_var_params[key] = val - del local_var_params['kwargs'] + self._check_operation_params('get_tasks', all_params, local_var_params) if 'limit' in local_var_params and local_var_params['limit'] > 500: # noqa: E501 raise ValueError("Invalid value for parameter `limit` when calling `get_tasks`, must be a value less than or equal to `500`") # noqa: E501 if 'limit' in local_var_params and local_var_params['limit'] < 1: # noqa: E501 raise ValueError("Invalid value for parameter `limit` when calling `get_tasks`, must be a value greater than or equal to `1`") # noqa: E501 - collection_formats = {} - path_params = {} query_params = [] @@ -685,38 +794,12 @@ def get_tasks_with_http_info(self, **kwargs): # noqa: E501,D401,D403 if 'zap_trace_span' in local_var_params: header_params['Zap-Trace-Span'] = local_var_params['zap_trace_span'] # noqa: E501 - form_params = [] - local_var_files = {} - body_params = None # HTTP header `Accept` header_params['Accept'] = self.api_client.select_header_accept( ['application/json']) # noqa: E501 - # Authentication setting - auth_settings = [] # noqa: E501 - - # urlopen optional setting - urlopen_kw = None - if 'urlopen_kw' in kwargs: - urlopen_kw = kwargs['urlopen_kw'] - - return self.api_client.call_api( - '/api/v2/tasks', 'GET', - path_params, - query_params, - header_params, - body=body_params, - post_params=form_params, - files=local_var_files, - response_type='Tasks', # noqa: E501 - auth_settings=auth_settings, - async_req=local_var_params.get('async_req'), - _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 - _preload_content=local_var_params.get('_preload_content', True), - _request_timeout=local_var_params.get('_request_timeout'), - collection_formats=collection_formats, - urlopen_kw=urlopen_kw) + return local_var_params, path_params, query_params, header_params, body_params def get_tasks_id(self, task_id, **kwargs): # noqa: E501,D401,D403 """Retrieve a task. @@ -755,30 +838,68 @@ def get_tasks_id_with_http_info(self, task_id, **kwargs): # noqa: E501,D401,D40 If the method is called asynchronously, returns the request thread. """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._get_tasks_id_prepare(task_id, **kwargs) + + return self.api_client.call_api( + '/api/v2/tasks/{taskID}', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='Task', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + async def get_tasks_id_async(self, task_id, **kwargs): # noqa: E501,D401,D403 + """Retrieve a task. + + This method makes an asynchronous HTTP request. + + :param async_req bool + :param str task_id: The task ID. (required) + :param str zap_trace_span: OpenTracing span context + :return: Task + If the method is called asynchronously, + returns the request thread. + """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._get_tasks_id_prepare(task_id, **kwargs) + + return await self.api_client.call_api( + '/api/v2/tasks/{taskID}', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='Task', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + def _get_tasks_id_prepare(self, task_id, **kwargs): # noqa: E501,D401,D403 local_var_params = locals() all_params = ['task_id', 'zap_trace_span'] # noqa: E501 - all_params.append('async_req') - all_params.append('_return_http_data_only') - all_params.append('_preload_content') - all_params.append('_request_timeout') - all_params.append('urlopen_kw') - - for key, val in six.iteritems(local_var_params['kwargs']): - if key not in all_params: - raise TypeError( - "Got an unexpected keyword argument '%s'" - " to method get_tasks_id" % key - ) - local_var_params[key] = val - del local_var_params['kwargs'] + self._check_operation_params('get_tasks_id', all_params, local_var_params) # verify the required parameter 'task_id' is set if ('task_id' not in local_var_params or local_var_params['task_id'] is None): raise ValueError("Missing the required parameter `task_id` when calling `get_tasks_id`") # noqa: E501 - collection_formats = {} - path_params = {} if 'task_id' in local_var_params: path_params['taskID'] = local_var_params['task_id'] # noqa: E501 @@ -789,38 +910,12 @@ def get_tasks_id_with_http_info(self, task_id, **kwargs): # noqa: E501,D401,D40 if 'zap_trace_span' in local_var_params: header_params['Zap-Trace-Span'] = local_var_params['zap_trace_span'] # noqa: E501 - form_params = [] - local_var_files = {} - body_params = None # HTTP header `Accept` header_params['Accept'] = self.api_client.select_header_accept( ['application/json']) # noqa: E501 - # Authentication setting - auth_settings = [] # noqa: E501 - - # urlopen optional setting - urlopen_kw = None - if 'urlopen_kw' in kwargs: - urlopen_kw = kwargs['urlopen_kw'] - - return self.api_client.call_api( - '/api/v2/tasks/{taskID}', 'GET', - path_params, - query_params, - header_params, - body=body_params, - post_params=form_params, - files=local_var_files, - response_type='Task', # noqa: E501 - auth_settings=auth_settings, - async_req=local_var_params.get('async_req'), - _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 - _preload_content=local_var_params.get('_preload_content', True), - _request_timeout=local_var_params.get('_request_timeout'), - collection_formats=collection_formats, - urlopen_kw=urlopen_kw) + return local_var_params, path_params, query_params, header_params, body_params def get_tasks_id_labels(self, task_id, **kwargs): # noqa: E501,D401,D403 """List all labels for a task. @@ -859,30 +954,68 @@ def get_tasks_id_labels_with_http_info(self, task_id, **kwargs): # noqa: E501,D If the method is called asynchronously, returns the request thread. """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._get_tasks_id_labels_prepare(task_id, **kwargs) + + return self.api_client.call_api( + '/api/v2/tasks/{taskID}/labels', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='LabelsResponse', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + async def get_tasks_id_labels_async(self, task_id, **kwargs): # noqa: E501,D401,D403 + """List all labels for a task. + + This method makes an asynchronous HTTP request. + + :param async_req bool + :param str task_id: The task ID. (required) + :param str zap_trace_span: OpenTracing span context + :return: LabelsResponse + If the method is called asynchronously, + returns the request thread. + """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._get_tasks_id_labels_prepare(task_id, **kwargs) + + return await self.api_client.call_api( + '/api/v2/tasks/{taskID}/labels', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='LabelsResponse', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + def _get_tasks_id_labels_prepare(self, task_id, **kwargs): # noqa: E501,D401,D403 local_var_params = locals() all_params = ['task_id', 'zap_trace_span'] # noqa: E501 - all_params.append('async_req') - all_params.append('_return_http_data_only') - all_params.append('_preload_content') - all_params.append('_request_timeout') - all_params.append('urlopen_kw') - - for key, val in six.iteritems(local_var_params['kwargs']): - if key not in all_params: - raise TypeError( - "Got an unexpected keyword argument '%s'" - " to method get_tasks_id_labels" % key - ) - local_var_params[key] = val - del local_var_params['kwargs'] + self._check_operation_params('get_tasks_id_labels', all_params, local_var_params) # verify the required parameter 'task_id' is set if ('task_id' not in local_var_params or local_var_params['task_id'] is None): raise ValueError("Missing the required parameter `task_id` when calling `get_tasks_id_labels`") # noqa: E501 - collection_formats = {} - path_params = {} if 'task_id' in local_var_params: path_params['taskID'] = local_var_params['task_id'] # noqa: E501 @@ -893,38 +1026,12 @@ def get_tasks_id_labels_with_http_info(self, task_id, **kwargs): # noqa: E501,D if 'zap_trace_span' in local_var_params: header_params['Zap-Trace-Span'] = local_var_params['zap_trace_span'] # noqa: E501 - form_params = [] - local_var_files = {} - body_params = None # HTTP header `Accept` header_params['Accept'] = self.api_client.select_header_accept( ['application/json']) # noqa: E501 - # Authentication setting - auth_settings = [] # noqa: E501 - - # urlopen optional setting - urlopen_kw = None - if 'urlopen_kw' in kwargs: - urlopen_kw = kwargs['urlopen_kw'] - - return self.api_client.call_api( - '/api/v2/tasks/{taskID}/labels', 'GET', - path_params, - query_params, - header_params, - body=body_params, - post_params=form_params, - files=local_var_files, - response_type='LabelsResponse', # noqa: E501 - auth_settings=auth_settings, - async_req=local_var_params.get('async_req'), - _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 - _preload_content=local_var_params.get('_preload_content', True), - _request_timeout=local_var_params.get('_request_timeout'), - collection_formats=collection_formats, - urlopen_kw=urlopen_kw) + return local_var_params, path_params, query_params, header_params, body_params def get_tasks_id_logs(self, task_id, **kwargs): # noqa: E501,D401,D403 """Retrieve all logs for a task. @@ -963,30 +1070,68 @@ def get_tasks_id_logs_with_http_info(self, task_id, **kwargs): # noqa: E501,D40 If the method is called asynchronously, returns the request thread. """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._get_tasks_id_logs_prepare(task_id, **kwargs) + + return self.api_client.call_api( + '/api/v2/tasks/{taskID}/logs', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='Logs', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + async def get_tasks_id_logs_async(self, task_id, **kwargs): # noqa: E501,D401,D403 + """Retrieve all logs for a task. + + This method makes an asynchronous HTTP request. + + :param async_req bool + :param str task_id: The task ID. (required) + :param str zap_trace_span: OpenTracing span context + :return: Logs + If the method is called asynchronously, + returns the request thread. + """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._get_tasks_id_logs_prepare(task_id, **kwargs) + + return await self.api_client.call_api( + '/api/v2/tasks/{taskID}/logs', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='Logs', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + def _get_tasks_id_logs_prepare(self, task_id, **kwargs): # noqa: E501,D401,D403 local_var_params = locals() all_params = ['task_id', 'zap_trace_span'] # noqa: E501 - all_params.append('async_req') - all_params.append('_return_http_data_only') - all_params.append('_preload_content') - all_params.append('_request_timeout') - all_params.append('urlopen_kw') - - for key, val in six.iteritems(local_var_params['kwargs']): - if key not in all_params: - raise TypeError( - "Got an unexpected keyword argument '%s'" - " to method get_tasks_id_logs" % key - ) - local_var_params[key] = val - del local_var_params['kwargs'] + self._check_operation_params('get_tasks_id_logs', all_params, local_var_params) # verify the required parameter 'task_id' is set if ('task_id' not in local_var_params or local_var_params['task_id'] is None): raise ValueError("Missing the required parameter `task_id` when calling `get_tasks_id_logs`") # noqa: E501 - collection_formats = {} - path_params = {} if 'task_id' in local_var_params: path_params['taskID'] = local_var_params['task_id'] # noqa: E501 @@ -997,38 +1142,12 @@ def get_tasks_id_logs_with_http_info(self, task_id, **kwargs): # noqa: E501,D40 if 'zap_trace_span' in local_var_params: header_params['Zap-Trace-Span'] = local_var_params['zap_trace_span'] # noqa: E501 - form_params = [] - local_var_files = {} - body_params = None # HTTP header `Accept` header_params['Accept'] = self.api_client.select_header_accept( ['application/json']) # noqa: E501 - # Authentication setting - auth_settings = [] # noqa: E501 - - # urlopen optional setting - urlopen_kw = None - if 'urlopen_kw' in kwargs: - urlopen_kw = kwargs['urlopen_kw'] - - return self.api_client.call_api( - '/api/v2/tasks/{taskID}/logs', 'GET', - path_params, - query_params, - header_params, - body=body_params, - post_params=form_params, - files=local_var_files, - response_type='Logs', # noqa: E501 - auth_settings=auth_settings, - async_req=local_var_params.get('async_req'), - _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 - _preload_content=local_var_params.get('_preload_content', True), - _request_timeout=local_var_params.get('_request_timeout'), - collection_formats=collection_formats, - urlopen_kw=urlopen_kw) + return local_var_params, path_params, query_params, header_params, body_params def get_tasks_id_members(self, task_id, **kwargs): # noqa: E501,D401,D403 """List all task members. @@ -1067,30 +1186,68 @@ def get_tasks_id_members_with_http_info(self, task_id, **kwargs): # noqa: E501, If the method is called asynchronously, returns the request thread. """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._get_tasks_id_members_prepare(task_id, **kwargs) + + return self.api_client.call_api( + '/api/v2/tasks/{taskID}/members', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='ResourceMembers', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + async def get_tasks_id_members_async(self, task_id, **kwargs): # noqa: E501,D401,D403 + """List all task members. + + This method makes an asynchronous HTTP request. + + :param async_req bool + :param str task_id: The task ID. (required) + :param str zap_trace_span: OpenTracing span context + :return: ResourceMembers + If the method is called asynchronously, + returns the request thread. + """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._get_tasks_id_members_prepare(task_id, **kwargs) + + return await self.api_client.call_api( + '/api/v2/tasks/{taskID}/members', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='ResourceMembers', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + def _get_tasks_id_members_prepare(self, task_id, **kwargs): # noqa: E501,D401,D403 local_var_params = locals() all_params = ['task_id', 'zap_trace_span'] # noqa: E501 - all_params.append('async_req') - all_params.append('_return_http_data_only') - all_params.append('_preload_content') - all_params.append('_request_timeout') - all_params.append('urlopen_kw') - - for key, val in six.iteritems(local_var_params['kwargs']): - if key not in all_params: - raise TypeError( - "Got an unexpected keyword argument '%s'" - " to method get_tasks_id_members" % key - ) - local_var_params[key] = val - del local_var_params['kwargs'] + self._check_operation_params('get_tasks_id_members', all_params, local_var_params) # verify the required parameter 'task_id' is set if ('task_id' not in local_var_params or local_var_params['task_id'] is None): raise ValueError("Missing the required parameter `task_id` when calling `get_tasks_id_members`") # noqa: E501 - collection_formats = {} - path_params = {} if 'task_id' in local_var_params: path_params['taskID'] = local_var_params['task_id'] # noqa: E501 @@ -1101,38 +1258,12 @@ def get_tasks_id_members_with_http_info(self, task_id, **kwargs): # noqa: E501, if 'zap_trace_span' in local_var_params: header_params['Zap-Trace-Span'] = local_var_params['zap_trace_span'] # noqa: E501 - form_params = [] - local_var_files = {} - body_params = None # HTTP header `Accept` header_params['Accept'] = self.api_client.select_header_accept( ['application/json']) # noqa: E501 - # Authentication setting - auth_settings = [] # noqa: E501 - - # urlopen optional setting - urlopen_kw = None - if 'urlopen_kw' in kwargs: - urlopen_kw = kwargs['urlopen_kw'] - - return self.api_client.call_api( - '/api/v2/tasks/{taskID}/members', 'GET', - path_params, - query_params, - header_params, - body=body_params, - post_params=form_params, - files=local_var_files, - response_type='ResourceMembers', # noqa: E501 - auth_settings=auth_settings, - async_req=local_var_params.get('async_req'), - _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 - _preload_content=local_var_params.get('_preload_content', True), - _request_timeout=local_var_params.get('_request_timeout'), - collection_formats=collection_formats, - urlopen_kw=urlopen_kw) + return local_var_params, path_params, query_params, header_params, body_params def get_tasks_id_owners(self, task_id, **kwargs): # noqa: E501,D401,D403 """List all owners of a task. @@ -1171,30 +1302,68 @@ def get_tasks_id_owners_with_http_info(self, task_id, **kwargs): # noqa: E501,D If the method is called asynchronously, returns the request thread. """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._get_tasks_id_owners_prepare(task_id, **kwargs) + + return self.api_client.call_api( + '/api/v2/tasks/{taskID}/owners', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='ResourceOwners', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + async def get_tasks_id_owners_async(self, task_id, **kwargs): # noqa: E501,D401,D403 + """List all owners of a task. + + This method makes an asynchronous HTTP request. + + :param async_req bool + :param str task_id: The task ID. (required) + :param str zap_trace_span: OpenTracing span context + :return: ResourceOwners + If the method is called asynchronously, + returns the request thread. + """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._get_tasks_id_owners_prepare(task_id, **kwargs) + + return await self.api_client.call_api( + '/api/v2/tasks/{taskID}/owners', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='ResourceOwners', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + def _get_tasks_id_owners_prepare(self, task_id, **kwargs): # noqa: E501,D401,D403 local_var_params = locals() all_params = ['task_id', 'zap_trace_span'] # noqa: E501 - all_params.append('async_req') - all_params.append('_return_http_data_only') - all_params.append('_preload_content') - all_params.append('_request_timeout') - all_params.append('urlopen_kw') - - for key, val in six.iteritems(local_var_params['kwargs']): - if key not in all_params: - raise TypeError( - "Got an unexpected keyword argument '%s'" - " to method get_tasks_id_owners" % key - ) - local_var_params[key] = val - del local_var_params['kwargs'] + self._check_operation_params('get_tasks_id_owners', all_params, local_var_params) # verify the required parameter 'task_id' is set if ('task_id' not in local_var_params or local_var_params['task_id'] is None): raise ValueError("Missing the required parameter `task_id` when calling `get_tasks_id_owners`") # noqa: E501 - collection_formats = {} - path_params = {} if 'task_id' in local_var_params: path_params['taskID'] = local_var_params['task_id'] # noqa: E501 @@ -1205,45 +1374,45 @@ def get_tasks_id_owners_with_http_info(self, task_id, **kwargs): # noqa: E501,D if 'zap_trace_span' in local_var_params: header_params['Zap-Trace-Span'] = local_var_params['zap_trace_span'] # noqa: E501 - form_params = [] - local_var_files = {} - body_params = None # HTTP header `Accept` header_params['Accept'] = self.api_client.select_header_accept( ['application/json']) # noqa: E501 - # Authentication setting - auth_settings = [] # noqa: E501 + return local_var_params, path_params, query_params, header_params, body_params - # urlopen optional setting - urlopen_kw = None - if 'urlopen_kw' in kwargs: - urlopen_kw = kwargs['urlopen_kw'] + def get_tasks_id_runs(self, task_id, **kwargs): # noqa: E501,D401,D403 + """List runs for a task. - return self.api_client.call_api( - '/api/v2/tasks/{taskID}/owners', 'GET', - path_params, - query_params, - header_params, - body=body_params, - post_params=form_params, - files=local_var_files, - response_type='ResourceOwners', # noqa: E501 - auth_settings=auth_settings, - async_req=local_var_params.get('async_req'), - _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 - _preload_content=local_var_params.get('_preload_content', True), - _request_timeout=local_var_params.get('_request_timeout'), - collection_formats=collection_formats, - urlopen_kw=urlopen_kw) + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.get_tasks_id_runs(task_id, async_req=True) + >>> result = thread.get() - def get_tasks_id_runs(self, task_id, **kwargs): # noqa: E501,D401,D403 + :param async_req bool + :param str task_id: The ID of the task to get runs for. (required) + :param str zap_trace_span: OpenTracing span context + :param str after: Returns runs after a specific ID. + :param int limit: The number of runs to return + :param datetime after_time: Filter runs to those scheduled after this time, RFC3339 + :param datetime before_time: Filter runs to those scheduled before this time, RFC3339 + :return: Runs + If the method is called asynchronously, + returns the request thread. + """ # noqa: E501 + kwargs['_return_http_data_only'] = True + if kwargs.get('async_req'): + return self.get_tasks_id_runs_with_http_info(task_id, **kwargs) # noqa: E501 + else: + (data) = self.get_tasks_id_runs_with_http_info(task_id, **kwargs) # noqa: E501 + return data + + def get_tasks_id_runs_with_http_info(self, task_id, **kwargs): # noqa: E501,D401,D403 """List runs for a task. This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True - >>> thread = api.get_tasks_id_runs(task_id, async_req=True) + >>> thread = api.get_tasks_id_runs_with_http_info(task_id, async_req=True) >>> result = thread.get() :param async_req bool @@ -1257,20 +1426,30 @@ def get_tasks_id_runs(self, task_id, **kwargs): # noqa: E501,D401,D403 If the method is called asynchronously, returns the request thread. """ # noqa: E501 - kwargs['_return_http_data_only'] = True - if kwargs.get('async_req'): - return self.get_tasks_id_runs_with_http_info(task_id, **kwargs) # noqa: E501 - else: - (data) = self.get_tasks_id_runs_with_http_info(task_id, **kwargs) # noqa: E501 - return data + local_var_params, path_params, query_params, header_params, body_params = \ + self._get_tasks_id_runs_prepare(task_id, **kwargs) - def get_tasks_id_runs_with_http_info(self, task_id, **kwargs): # noqa: E501,D401,D403 + return self.api_client.call_api( + '/api/v2/tasks/{taskID}/runs', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='Runs', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + async def get_tasks_id_runs_async(self, task_id, **kwargs): # noqa: E501,D401,D403 """List runs for a task. - This method makes a synchronous HTTP request by default. To make an - asynchronous HTTP request, please pass async_req=True - >>> thread = api.get_tasks_id_runs_with_http_info(task_id, async_req=True) - >>> result = thread.get() + This method makes an asynchronous HTTP request. :param async_req bool :param str task_id: The ID of the task to get runs for. (required) @@ -1283,23 +1462,31 @@ def get_tasks_id_runs_with_http_info(self, task_id, **kwargs): # noqa: E501,D40 If the method is called asynchronously, returns the request thread. """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._get_tasks_id_runs_prepare(task_id, **kwargs) + + return await self.api_client.call_api( + '/api/v2/tasks/{taskID}/runs', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='Runs', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + def _get_tasks_id_runs_prepare(self, task_id, **kwargs): # noqa: E501,D401,D403 local_var_params = locals() all_params = ['task_id', 'zap_trace_span', 'after', 'limit', 'after_time', 'before_time'] # noqa: E501 - all_params.append('async_req') - all_params.append('_return_http_data_only') - all_params.append('_preload_content') - all_params.append('_request_timeout') - all_params.append('urlopen_kw') - - for key, val in six.iteritems(local_var_params['kwargs']): - if key not in all_params: - raise TypeError( - "Got an unexpected keyword argument '%s'" - " to method get_tasks_id_runs" % key - ) - local_var_params[key] = val - del local_var_params['kwargs'] + self._check_operation_params('get_tasks_id_runs', all_params, local_var_params) # verify the required parameter 'task_id' is set if ('task_id' not in local_var_params or local_var_params['task_id'] is None): @@ -1309,8 +1496,6 @@ def get_tasks_id_runs_with_http_info(self, task_id, **kwargs): # noqa: E501,D40 raise ValueError("Invalid value for parameter `limit` when calling `get_tasks_id_runs`, must be a value less than or equal to `500`") # noqa: E501 if 'limit' in local_var_params and local_var_params['limit'] < 1: # noqa: E501 raise ValueError("Invalid value for parameter `limit` when calling `get_tasks_id_runs`, must be a value greater than or equal to `1`") # noqa: E501 - collection_formats = {} - path_params = {} if 'task_id' in local_var_params: path_params['taskID'] = local_var_params['task_id'] # noqa: E501 @@ -1329,38 +1514,12 @@ def get_tasks_id_runs_with_http_info(self, task_id, **kwargs): # noqa: E501,D40 if 'zap_trace_span' in local_var_params: header_params['Zap-Trace-Span'] = local_var_params['zap_trace_span'] # noqa: E501 - form_params = [] - local_var_files = {} - body_params = None # HTTP header `Accept` header_params['Accept'] = self.api_client.select_header_accept( ['application/json']) # noqa: E501 - # Authentication setting - auth_settings = [] # noqa: E501 - - # urlopen optional setting - urlopen_kw = None - if 'urlopen_kw' in kwargs: - urlopen_kw = kwargs['urlopen_kw'] - - return self.api_client.call_api( - '/api/v2/tasks/{taskID}/runs', 'GET', - path_params, - query_params, - header_params, - body=body_params, - post_params=form_params, - files=local_var_files, - response_type='Runs', # noqa: E501 - auth_settings=auth_settings, - async_req=local_var_params.get('async_req'), - _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 - _preload_content=local_var_params.get('_preload_content', True), - _request_timeout=local_var_params.get('_request_timeout'), - collection_formats=collection_formats, - urlopen_kw=urlopen_kw) + return local_var_params, path_params, query_params, header_params, body_params def get_tasks_id_runs_id(self, task_id, run_id, **kwargs): # noqa: E501,D401,D403 """Retrieve a single run for a task. @@ -1401,23 +1560,64 @@ def get_tasks_id_runs_id_with_http_info(self, task_id, run_id, **kwargs): # noq If the method is called asynchronously, returns the request thread. """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._get_tasks_id_runs_id_prepare(task_id, run_id, **kwargs) + + return self.api_client.call_api( + '/api/v2/tasks/{taskID}/runs/{runID}', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='Run', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + async def get_tasks_id_runs_id_async(self, task_id, run_id, **kwargs): # noqa: E501,D401,D403 + """Retrieve a single run for a task. + + This method makes an asynchronous HTTP request. + + :param async_req bool + :param str task_id: The task ID. (required) + :param str run_id: The run ID. (required) + :param str zap_trace_span: OpenTracing span context + :return: Run + If the method is called asynchronously, + returns the request thread. + """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._get_tasks_id_runs_id_prepare(task_id, run_id, **kwargs) + + return await self.api_client.call_api( + '/api/v2/tasks/{taskID}/runs/{runID}', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='Run', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + def _get_tasks_id_runs_id_prepare(self, task_id, run_id, **kwargs): # noqa: E501,D401,D403 local_var_params = locals() all_params = ['task_id', 'run_id', 'zap_trace_span'] # noqa: E501 - all_params.append('async_req') - all_params.append('_return_http_data_only') - all_params.append('_preload_content') - all_params.append('_request_timeout') - all_params.append('urlopen_kw') - - for key, val in six.iteritems(local_var_params['kwargs']): - if key not in all_params: - raise TypeError( - "Got an unexpected keyword argument '%s'" - " to method get_tasks_id_runs_id" % key - ) - local_var_params[key] = val - del local_var_params['kwargs'] + self._check_operation_params('get_tasks_id_runs_id', all_params, local_var_params) # verify the required parameter 'task_id' is set if ('task_id' not in local_var_params or local_var_params['task_id'] is None): @@ -1427,8 +1627,6 @@ def get_tasks_id_runs_id_with_http_info(self, task_id, run_id, **kwargs): # noq local_var_params['run_id'] is None): raise ValueError("Missing the required parameter `run_id` when calling `get_tasks_id_runs_id`") # noqa: E501 - collection_formats = {} - path_params = {} if 'task_id' in local_var_params: path_params['taskID'] = local_var_params['task_id'] # noqa: E501 @@ -1441,38 +1639,12 @@ def get_tasks_id_runs_id_with_http_info(self, task_id, run_id, **kwargs): # noq if 'zap_trace_span' in local_var_params: header_params['Zap-Trace-Span'] = local_var_params['zap_trace_span'] # noqa: E501 - form_params = [] - local_var_files = {} - body_params = None # HTTP header `Accept` header_params['Accept'] = self.api_client.select_header_accept( ['application/json']) # noqa: E501 - # Authentication setting - auth_settings = [] # noqa: E501 - - # urlopen optional setting - urlopen_kw = None - if 'urlopen_kw' in kwargs: - urlopen_kw = kwargs['urlopen_kw'] - - return self.api_client.call_api( - '/api/v2/tasks/{taskID}/runs/{runID}', 'GET', - path_params, - query_params, - header_params, - body=body_params, - post_params=form_params, - files=local_var_files, - response_type='Run', # noqa: E501 - auth_settings=auth_settings, - async_req=local_var_params.get('async_req'), - _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 - _preload_content=local_var_params.get('_preload_content', True), - _request_timeout=local_var_params.get('_request_timeout'), - collection_formats=collection_formats, - urlopen_kw=urlopen_kw) + return local_var_params, path_params, query_params, header_params, body_params def get_tasks_id_runs_id_logs(self, task_id, run_id, **kwargs): # noqa: E501,D401,D403 """Retrieve all logs for a run. @@ -1513,23 +1685,64 @@ def get_tasks_id_runs_id_logs_with_http_info(self, task_id, run_id, **kwargs): If the method is called asynchronously, returns the request thread. """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._get_tasks_id_runs_id_logs_prepare(task_id, run_id, **kwargs) + + return self.api_client.call_api( + '/api/v2/tasks/{taskID}/runs/{runID}/logs', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='Logs', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + async def get_tasks_id_runs_id_logs_async(self, task_id, run_id, **kwargs): # noqa: E501,D401,D403 + """Retrieve all logs for a run. + + This method makes an asynchronous HTTP request. + + :param async_req bool + :param str task_id: ID of task to get logs for. (required) + :param str run_id: ID of run to get logs for. (required) + :param str zap_trace_span: OpenTracing span context + :return: Logs + If the method is called asynchronously, + returns the request thread. + """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._get_tasks_id_runs_id_logs_prepare(task_id, run_id, **kwargs) + + return await self.api_client.call_api( + '/api/v2/tasks/{taskID}/runs/{runID}/logs', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='Logs', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + def _get_tasks_id_runs_id_logs_prepare(self, task_id, run_id, **kwargs): # noqa: E501,D401,D403 local_var_params = locals() all_params = ['task_id', 'run_id', 'zap_trace_span'] # noqa: E501 - all_params.append('async_req') - all_params.append('_return_http_data_only') - all_params.append('_preload_content') - all_params.append('_request_timeout') - all_params.append('urlopen_kw') - - for key, val in six.iteritems(local_var_params['kwargs']): - if key not in all_params: - raise TypeError( - "Got an unexpected keyword argument '%s'" - " to method get_tasks_id_runs_id_logs" % key - ) - local_var_params[key] = val - del local_var_params['kwargs'] + self._check_operation_params('get_tasks_id_runs_id_logs', all_params, local_var_params) # verify the required parameter 'task_id' is set if ('task_id' not in local_var_params or local_var_params['task_id'] is None): @@ -1539,8 +1752,6 @@ def get_tasks_id_runs_id_logs_with_http_info(self, task_id, run_id, **kwargs): local_var_params['run_id'] is None): raise ValueError("Missing the required parameter `run_id` when calling `get_tasks_id_runs_id_logs`") # noqa: E501 - collection_formats = {} - path_params = {} if 'task_id' in local_var_params: path_params['taskID'] = local_var_params['task_id'] # noqa: E501 @@ -1553,38 +1764,12 @@ def get_tasks_id_runs_id_logs_with_http_info(self, task_id, run_id, **kwargs): if 'zap_trace_span' in local_var_params: header_params['Zap-Trace-Span'] = local_var_params['zap_trace_span'] # noqa: E501 - form_params = [] - local_var_files = {} - body_params = None # HTTP header `Accept` header_params['Accept'] = self.api_client.select_header_accept( ['application/json']) # noqa: E501 - # Authentication setting - auth_settings = [] # noqa: E501 - - # urlopen optional setting - urlopen_kw = None - if 'urlopen_kw' in kwargs: - urlopen_kw = kwargs['urlopen_kw'] - - return self.api_client.call_api( - '/api/v2/tasks/{taskID}/runs/{runID}/logs', 'GET', - path_params, - query_params, - header_params, - body=body_params, - post_params=form_params, - files=local_var_files, - response_type='Logs', # noqa: E501 - auth_settings=auth_settings, - async_req=local_var_params.get('async_req'), - _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 - _preload_content=local_var_params.get('_preload_content', True), - _request_timeout=local_var_params.get('_request_timeout'), - collection_formats=collection_formats, - urlopen_kw=urlopen_kw) + return local_var_params, path_params, query_params, header_params, body_params def patch_tasks_id(self, task_id, task_update_request, **kwargs): # noqa: E501,D401,D403 """Update a task. @@ -1627,23 +1812,65 @@ def patch_tasks_id_with_http_info(self, task_id, task_update_request, **kwargs): If the method is called asynchronously, returns the request thread. """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._patch_tasks_id_prepare(task_id, task_update_request, **kwargs) + + return self.api_client.call_api( + '/api/v2/tasks/{taskID}', 'PATCH', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='Task', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + async def patch_tasks_id_async(self, task_id, task_update_request, **kwargs): # noqa: E501,D401,D403 + """Update a task. + + Update a task. This will cancel all queued runs. + This method makes an asynchronous HTTP request. + + :param async_req bool + :param str task_id: The task ID. (required) + :param TaskUpdateRequest task_update_request: Task update to apply (required) + :param str zap_trace_span: OpenTracing span context + :return: Task + If the method is called asynchronously, + returns the request thread. + """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._patch_tasks_id_prepare(task_id, task_update_request, **kwargs) + + return await self.api_client.call_api( + '/api/v2/tasks/{taskID}', 'PATCH', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='Task', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + def _patch_tasks_id_prepare(self, task_id, task_update_request, **kwargs): # noqa: E501,D401,D403 local_var_params = locals() all_params = ['task_id', 'task_update_request', 'zap_trace_span'] # noqa: E501 - all_params.append('async_req') - all_params.append('_return_http_data_only') - all_params.append('_preload_content') - all_params.append('_request_timeout') - all_params.append('urlopen_kw') - - for key, val in six.iteritems(local_var_params['kwargs']): - if key not in all_params: - raise TypeError( - "Got an unexpected keyword argument '%s'" - " to method patch_tasks_id" % key - ) - local_var_params[key] = val - del local_var_params['kwargs'] + self._check_operation_params('patch_tasks_id', all_params, local_var_params) # verify the required parameter 'task_id' is set if ('task_id' not in local_var_params or local_var_params['task_id'] is None): @@ -1653,8 +1880,6 @@ def patch_tasks_id_with_http_info(self, task_id, task_update_request, **kwargs): local_var_params['task_update_request'] is None): raise ValueError("Missing the required parameter `task_update_request` when calling `patch_tasks_id`") # noqa: E501 - collection_formats = {} - path_params = {} if 'task_id' in local_var_params: path_params['taskID'] = local_var_params['task_id'] # noqa: E501 @@ -1665,9 +1890,6 @@ def patch_tasks_id_with_http_info(self, task_id, task_update_request, **kwargs): if 'zap_trace_span' in local_var_params: header_params['Zap-Trace-Span'] = local_var_params['zap_trace_span'] # noqa: E501 - form_params = [] - local_var_files = {} - body_params = None if 'task_update_request' in local_var_params: body_params = local_var_params['task_update_request'] @@ -1679,30 +1901,7 @@ def patch_tasks_id_with_http_info(self, task_id, task_update_request, **kwargs): header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501 ['application/json']) # noqa: E501 - # Authentication setting - auth_settings = [] # noqa: E501 - - # urlopen optional setting - urlopen_kw = None - if 'urlopen_kw' in kwargs: - urlopen_kw = kwargs['urlopen_kw'] - - return self.api_client.call_api( - '/api/v2/tasks/{taskID}', 'PATCH', - path_params, - query_params, - header_params, - body=body_params, - post_params=form_params, - files=local_var_files, - response_type='Task', # noqa: E501 - auth_settings=auth_settings, - async_req=local_var_params.get('async_req'), - _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 - _preload_content=local_var_params.get('_preload_content', True), - _request_timeout=local_var_params.get('_request_timeout'), - collection_formats=collection_formats, - urlopen_kw=urlopen_kw) + return local_var_params, path_params, query_params, header_params, body_params def post_tasks(self, task_create_request, **kwargs): # noqa: E501,D401,D403 """Create a new task. @@ -1741,30 +1940,68 @@ def post_tasks_with_http_info(self, task_create_request, **kwargs): # noqa: E50 If the method is called asynchronously, returns the request thread. """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._post_tasks_prepare(task_create_request, **kwargs) + + return self.api_client.call_api( + '/api/v2/tasks', 'POST', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='Task', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + async def post_tasks_async(self, task_create_request, **kwargs): # noqa: E501,D401,D403 + """Create a new task. + + This method makes an asynchronous HTTP request. + + :param async_req bool + :param TaskCreateRequest task_create_request: Task to create (required) + :param str zap_trace_span: OpenTracing span context + :return: Task + If the method is called asynchronously, + returns the request thread. + """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._post_tasks_prepare(task_create_request, **kwargs) + + return await self.api_client.call_api( + '/api/v2/tasks', 'POST', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='Task', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + def _post_tasks_prepare(self, task_create_request, **kwargs): # noqa: E501,D401,D403 local_var_params = locals() all_params = ['task_create_request', 'zap_trace_span'] # noqa: E501 - all_params.append('async_req') - all_params.append('_return_http_data_only') - all_params.append('_preload_content') - all_params.append('_request_timeout') - all_params.append('urlopen_kw') - - for key, val in six.iteritems(local_var_params['kwargs']): - if key not in all_params: - raise TypeError( - "Got an unexpected keyword argument '%s'" - " to method post_tasks" % key - ) - local_var_params[key] = val - del local_var_params['kwargs'] + self._check_operation_params('post_tasks', all_params, local_var_params) # verify the required parameter 'task_create_request' is set if ('task_create_request' not in local_var_params or local_var_params['task_create_request'] is None): raise ValueError("Missing the required parameter `task_create_request` when calling `post_tasks`") # noqa: E501 - collection_formats = {} - path_params = {} query_params = [] @@ -1773,9 +2010,6 @@ def post_tasks_with_http_info(self, task_create_request, **kwargs): # noqa: E50 if 'zap_trace_span' in local_var_params: header_params['Zap-Trace-Span'] = local_var_params['zap_trace_span'] # noqa: E501 - form_params = [] - local_var_files = {} - body_params = None if 'task_create_request' in local_var_params: body_params = local_var_params['task_create_request'] @@ -1787,30 +2021,7 @@ def post_tasks_with_http_info(self, task_create_request, **kwargs): # noqa: E50 header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501 ['application/json']) # noqa: E501 - # Authentication setting - auth_settings = [] # noqa: E501 - - # urlopen optional setting - urlopen_kw = None - if 'urlopen_kw' in kwargs: - urlopen_kw = kwargs['urlopen_kw'] - - return self.api_client.call_api( - '/api/v2/tasks', 'POST', - path_params, - query_params, - header_params, - body=body_params, - post_params=form_params, - files=local_var_files, - response_type='Task', # noqa: E501 - auth_settings=auth_settings, - async_req=local_var_params.get('async_req'), - _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 - _preload_content=local_var_params.get('_preload_content', True), - _request_timeout=local_var_params.get('_request_timeout'), - collection_formats=collection_formats, - urlopen_kw=urlopen_kw) + return local_var_params, path_params, query_params, header_params, body_params def post_tasks_id_labels(self, task_id, label_mapping, **kwargs): # noqa: E501,D401,D403 """Add a label to a task. @@ -1851,23 +2062,64 @@ def post_tasks_id_labels_with_http_info(self, task_id, label_mapping, **kwargs): If the method is called asynchronously, returns the request thread. """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._post_tasks_id_labels_prepare(task_id, label_mapping, **kwargs) + + return self.api_client.call_api( + '/api/v2/tasks/{taskID}/labels', 'POST', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='LabelResponse', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + async def post_tasks_id_labels_async(self, task_id, label_mapping, **kwargs): # noqa: E501,D401,D403 + """Add a label to a task. + + This method makes an asynchronous HTTP request. + + :param async_req bool + :param str task_id: The task ID. (required) + :param LabelMapping label_mapping: Label to add (required) + :param str zap_trace_span: OpenTracing span context + :return: LabelResponse + If the method is called asynchronously, + returns the request thread. + """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._post_tasks_id_labels_prepare(task_id, label_mapping, **kwargs) + + return await self.api_client.call_api( + '/api/v2/tasks/{taskID}/labels', 'POST', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='LabelResponse', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + def _post_tasks_id_labels_prepare(self, task_id, label_mapping, **kwargs): # noqa: E501,D401,D403 local_var_params = locals() all_params = ['task_id', 'label_mapping', 'zap_trace_span'] # noqa: E501 - all_params.append('async_req') - all_params.append('_return_http_data_only') - all_params.append('_preload_content') - all_params.append('_request_timeout') - all_params.append('urlopen_kw') - - for key, val in six.iteritems(local_var_params['kwargs']): - if key not in all_params: - raise TypeError( - "Got an unexpected keyword argument '%s'" - " to method post_tasks_id_labels" % key - ) - local_var_params[key] = val - del local_var_params['kwargs'] + self._check_operation_params('post_tasks_id_labels', all_params, local_var_params) # verify the required parameter 'task_id' is set if ('task_id' not in local_var_params or local_var_params['task_id'] is None): @@ -1877,8 +2129,6 @@ def post_tasks_id_labels_with_http_info(self, task_id, label_mapping, **kwargs): local_var_params['label_mapping'] is None): raise ValueError("Missing the required parameter `label_mapping` when calling `post_tasks_id_labels`") # noqa: E501 - collection_formats = {} - path_params = {} if 'task_id' in local_var_params: path_params['taskID'] = local_var_params['task_id'] # noqa: E501 @@ -1889,9 +2139,6 @@ def post_tasks_id_labels_with_http_info(self, task_id, label_mapping, **kwargs): if 'zap_trace_span' in local_var_params: header_params['Zap-Trace-Span'] = local_var_params['zap_trace_span'] # noqa: E501 - form_params = [] - local_var_files = {} - body_params = None if 'label_mapping' in local_var_params: body_params = local_var_params['label_mapping'] @@ -1903,30 +2150,7 @@ def post_tasks_id_labels_with_http_info(self, task_id, label_mapping, **kwargs): header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501 ['application/json']) # noqa: E501 - # Authentication setting - auth_settings = [] # noqa: E501 - - # urlopen optional setting - urlopen_kw = None - if 'urlopen_kw' in kwargs: - urlopen_kw = kwargs['urlopen_kw'] - - return self.api_client.call_api( - '/api/v2/tasks/{taskID}/labels', 'POST', - path_params, - query_params, - header_params, - body=body_params, - post_params=form_params, - files=local_var_files, - response_type='LabelResponse', # noqa: E501 - auth_settings=auth_settings, - async_req=local_var_params.get('async_req'), - _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 - _preload_content=local_var_params.get('_preload_content', True), - _request_timeout=local_var_params.get('_request_timeout'), - collection_formats=collection_formats, - urlopen_kw=urlopen_kw) + return local_var_params, path_params, query_params, header_params, body_params def post_tasks_id_members(self, task_id, add_resource_member_request_body, **kwargs): # noqa: E501,D401,D403 """Add a member to a task. @@ -1967,23 +2191,64 @@ def post_tasks_id_members_with_http_info(self, task_id, add_resource_member_requ If the method is called asynchronously, returns the request thread. """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._post_tasks_id_members_prepare(task_id, add_resource_member_request_body, **kwargs) + + return self.api_client.call_api( + '/api/v2/tasks/{taskID}/members', 'POST', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='ResourceMember', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + async def post_tasks_id_members_async(self, task_id, add_resource_member_request_body, **kwargs): # noqa: E501,D401,D403 + """Add a member to a task. + + This method makes an asynchronous HTTP request. + + :param async_req bool + :param str task_id: The task ID. (required) + :param AddResourceMemberRequestBody add_resource_member_request_body: User to add as member (required) + :param str zap_trace_span: OpenTracing span context + :return: ResourceMember + If the method is called asynchronously, + returns the request thread. + """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._post_tasks_id_members_prepare(task_id, add_resource_member_request_body, **kwargs) + + return await self.api_client.call_api( + '/api/v2/tasks/{taskID}/members', 'POST', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='ResourceMember', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + def _post_tasks_id_members_prepare(self, task_id, add_resource_member_request_body, **kwargs): # noqa: E501,D401,D403 local_var_params = locals() all_params = ['task_id', 'add_resource_member_request_body', 'zap_trace_span'] # noqa: E501 - all_params.append('async_req') - all_params.append('_return_http_data_only') - all_params.append('_preload_content') - all_params.append('_request_timeout') - all_params.append('urlopen_kw') - - for key, val in six.iteritems(local_var_params['kwargs']): - if key not in all_params: - raise TypeError( - "Got an unexpected keyword argument '%s'" - " to method post_tasks_id_members" % key - ) - local_var_params[key] = val - del local_var_params['kwargs'] + self._check_operation_params('post_tasks_id_members', all_params, local_var_params) # verify the required parameter 'task_id' is set if ('task_id' not in local_var_params or local_var_params['task_id'] is None): @@ -1993,8 +2258,6 @@ def post_tasks_id_members_with_http_info(self, task_id, add_resource_member_requ local_var_params['add_resource_member_request_body'] is None): raise ValueError("Missing the required parameter `add_resource_member_request_body` when calling `post_tasks_id_members`") # noqa: E501 - collection_formats = {} - path_params = {} if 'task_id' in local_var_params: path_params['taskID'] = local_var_params['task_id'] # noqa: E501 @@ -2005,9 +2268,6 @@ def post_tasks_id_members_with_http_info(self, task_id, add_resource_member_requ if 'zap_trace_span' in local_var_params: header_params['Zap-Trace-Span'] = local_var_params['zap_trace_span'] # noqa: E501 - form_params = [] - local_var_files = {} - body_params = None if 'add_resource_member_request_body' in local_var_params: body_params = local_var_params['add_resource_member_request_body'] @@ -2019,30 +2279,7 @@ def post_tasks_id_members_with_http_info(self, task_id, add_resource_member_requ header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501 ['application/json']) # noqa: E501 - # Authentication setting - auth_settings = [] # noqa: E501 - - # urlopen optional setting - urlopen_kw = None - if 'urlopen_kw' in kwargs: - urlopen_kw = kwargs['urlopen_kw'] - - return self.api_client.call_api( - '/api/v2/tasks/{taskID}/members', 'POST', - path_params, - query_params, - header_params, - body=body_params, - post_params=form_params, - files=local_var_files, - response_type='ResourceMember', # noqa: E501 - auth_settings=auth_settings, - async_req=local_var_params.get('async_req'), - _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 - _preload_content=local_var_params.get('_preload_content', True), - _request_timeout=local_var_params.get('_request_timeout'), - collection_formats=collection_formats, - urlopen_kw=urlopen_kw) + return local_var_params, path_params, query_params, header_params, body_params def post_tasks_id_owners(self, task_id, add_resource_member_request_body, **kwargs): # noqa: E501,D401,D403 """Add an owner to a task. @@ -2083,23 +2320,64 @@ def post_tasks_id_owners_with_http_info(self, task_id, add_resource_member_reque If the method is called asynchronously, returns the request thread. """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._post_tasks_id_owners_prepare(task_id, add_resource_member_request_body, **kwargs) + + return self.api_client.call_api( + '/api/v2/tasks/{taskID}/owners', 'POST', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='ResourceOwner', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + async def post_tasks_id_owners_async(self, task_id, add_resource_member_request_body, **kwargs): # noqa: E501,D401,D403 + """Add an owner to a task. + + This method makes an asynchronous HTTP request. + + :param async_req bool + :param str task_id: The task ID. (required) + :param AddResourceMemberRequestBody add_resource_member_request_body: User to add as owner (required) + :param str zap_trace_span: OpenTracing span context + :return: ResourceOwner + If the method is called asynchronously, + returns the request thread. + """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._post_tasks_id_owners_prepare(task_id, add_resource_member_request_body, **kwargs) + + return await self.api_client.call_api( + '/api/v2/tasks/{taskID}/owners', 'POST', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='ResourceOwner', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + def _post_tasks_id_owners_prepare(self, task_id, add_resource_member_request_body, **kwargs): # noqa: E501,D401,D403 local_var_params = locals() all_params = ['task_id', 'add_resource_member_request_body', 'zap_trace_span'] # noqa: E501 - all_params.append('async_req') - all_params.append('_return_http_data_only') - all_params.append('_preload_content') - all_params.append('_request_timeout') - all_params.append('urlopen_kw') - - for key, val in six.iteritems(local_var_params['kwargs']): - if key not in all_params: - raise TypeError( - "Got an unexpected keyword argument '%s'" - " to method post_tasks_id_owners" % key - ) - local_var_params[key] = val - del local_var_params['kwargs'] + self._check_operation_params('post_tasks_id_owners', all_params, local_var_params) # verify the required parameter 'task_id' is set if ('task_id' not in local_var_params or local_var_params['task_id'] is None): @@ -2109,8 +2387,6 @@ def post_tasks_id_owners_with_http_info(self, task_id, add_resource_member_reque local_var_params['add_resource_member_request_body'] is None): raise ValueError("Missing the required parameter `add_resource_member_request_body` when calling `post_tasks_id_owners`") # noqa: E501 - collection_formats = {} - path_params = {} if 'task_id' in local_var_params: path_params['taskID'] = local_var_params['task_id'] # noqa: E501 @@ -2121,9 +2397,6 @@ def post_tasks_id_owners_with_http_info(self, task_id, add_resource_member_reque if 'zap_trace_span' in local_var_params: header_params['Zap-Trace-Span'] = local_var_params['zap_trace_span'] # noqa: E501 - form_params = [] - local_var_files = {} - body_params = None if 'add_resource_member_request_body' in local_var_params: body_params = local_var_params['add_resource_member_request_body'] @@ -2135,30 +2408,7 @@ def post_tasks_id_owners_with_http_info(self, task_id, add_resource_member_reque header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501 ['application/json']) # noqa: E501 - # Authentication setting - auth_settings = [] # noqa: E501 - - # urlopen optional setting - urlopen_kw = None - if 'urlopen_kw' in kwargs: - urlopen_kw = kwargs['urlopen_kw'] - - return self.api_client.call_api( - '/api/v2/tasks/{taskID}/owners', 'POST', - path_params, - query_params, - header_params, - body=body_params, - post_params=form_params, - files=local_var_files, - response_type='ResourceOwner', # noqa: E501 - auth_settings=auth_settings, - async_req=local_var_params.get('async_req'), - _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 - _preload_content=local_var_params.get('_preload_content', True), - _request_timeout=local_var_params.get('_request_timeout'), - collection_formats=collection_formats, - urlopen_kw=urlopen_kw) + return local_var_params, path_params, query_params, header_params, body_params def post_tasks_id_runs(self, task_id, **kwargs): # noqa: E501,D401,D403 """Manually start a task run, overriding the current schedule. @@ -2199,30 +2449,69 @@ def post_tasks_id_runs_with_http_info(self, task_id, **kwargs): # noqa: E501,D4 If the method is called asynchronously, returns the request thread. """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._post_tasks_id_runs_prepare(task_id, **kwargs) + + return self.api_client.call_api( + '/api/v2/tasks/{taskID}/runs', 'POST', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='Run', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + async def post_tasks_id_runs_async(self, task_id, **kwargs): # noqa: E501,D401,D403 + """Manually start a task run, overriding the current schedule. + + This method makes an asynchronous HTTP request. + + :param async_req bool + :param str task_id: (required) + :param str zap_trace_span: OpenTracing span context + :param RunManually run_manually: + :return: Run + If the method is called asynchronously, + returns the request thread. + """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._post_tasks_id_runs_prepare(task_id, **kwargs) + + return await self.api_client.call_api( + '/api/v2/tasks/{taskID}/runs', 'POST', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='Run', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + def _post_tasks_id_runs_prepare(self, task_id, **kwargs): # noqa: E501,D401,D403 local_var_params = locals() all_params = ['task_id', 'zap_trace_span', 'run_manually'] # noqa: E501 - all_params.append('async_req') - all_params.append('_return_http_data_only') - all_params.append('_preload_content') - all_params.append('_request_timeout') - all_params.append('urlopen_kw') - - for key, val in six.iteritems(local_var_params['kwargs']): - if key not in all_params: - raise TypeError( - "Got an unexpected keyword argument '%s'" - " to method post_tasks_id_runs" % key - ) - local_var_params[key] = val - del local_var_params['kwargs'] + self._check_operation_params('post_tasks_id_runs', all_params, local_var_params) # verify the required parameter 'task_id' is set if ('task_id' not in local_var_params or local_var_params['task_id'] is None): raise ValueError("Missing the required parameter `task_id` when calling `post_tasks_id_runs`") # noqa: E501 - collection_formats = {} - path_params = {} if 'task_id' in local_var_params: path_params['taskID'] = local_var_params['task_id'] # noqa: E501 @@ -2233,9 +2522,6 @@ def post_tasks_id_runs_with_http_info(self, task_id, **kwargs): # noqa: E501,D4 if 'zap_trace_span' in local_var_params: header_params['Zap-Trace-Span'] = local_var_params['zap_trace_span'] # noqa: E501 - form_params = [] - local_var_files = {} - body_params = None if 'run_manually' in local_var_params: body_params = local_var_params['run_manually'] @@ -2247,30 +2533,7 @@ def post_tasks_id_runs_with_http_info(self, task_id, **kwargs): # noqa: E501,D4 header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501 ['application/json']) # noqa: E501 - # Authentication setting - auth_settings = [] # noqa: E501 - - # urlopen optional setting - urlopen_kw = None - if 'urlopen_kw' in kwargs: - urlopen_kw = kwargs['urlopen_kw'] - - return self.api_client.call_api( - '/api/v2/tasks/{taskID}/runs', 'POST', - path_params, - query_params, - header_params, - body=body_params, - post_params=form_params, - files=local_var_files, - response_type='Run', # noqa: E501 - auth_settings=auth_settings, - async_req=local_var_params.get('async_req'), - _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 - _preload_content=local_var_params.get('_preload_content', True), - _request_timeout=local_var_params.get('_request_timeout'), - collection_formats=collection_formats, - urlopen_kw=urlopen_kw) + return local_var_params, path_params, query_params, header_params, body_params def post_tasks_id_runs_id_retry(self, task_id, run_id, **kwargs): # noqa: E501,D401,D403 """Retry a task run. @@ -2313,23 +2576,65 @@ def post_tasks_id_runs_id_retry_with_http_info(self, task_id, run_id, **kwargs): If the method is called asynchronously, returns the request thread. """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._post_tasks_id_runs_id_retry_prepare(task_id, run_id, **kwargs) + + return self.api_client.call_api( + '/api/v2/tasks/{taskID}/runs/{runID}/retry', 'POST', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='Run', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + async def post_tasks_id_runs_id_retry_async(self, task_id, run_id, **kwargs): # noqa: E501,D401,D403 + """Retry a task run. + + This method makes an asynchronous HTTP request. + + :param async_req bool + :param str task_id: The task ID. (required) + :param str run_id: The run ID. (required) + :param str zap_trace_span: OpenTracing span context + :param str body: + :return: Run + If the method is called asynchronously, + returns the request thread. + """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._post_tasks_id_runs_id_retry_prepare(task_id, run_id, **kwargs) + + return await self.api_client.call_api( + '/api/v2/tasks/{taskID}/runs/{runID}/retry', 'POST', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='Run', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + def _post_tasks_id_runs_id_retry_prepare(self, task_id, run_id, **kwargs): # noqa: E501,D401,D403 local_var_params = locals() all_params = ['task_id', 'run_id', 'zap_trace_span', 'body'] # noqa: E501 - all_params.append('async_req') - all_params.append('_return_http_data_only') - all_params.append('_preload_content') - all_params.append('_request_timeout') - all_params.append('urlopen_kw') - - for key, val in six.iteritems(local_var_params['kwargs']): - if key not in all_params: - raise TypeError( - "Got an unexpected keyword argument '%s'" - " to method post_tasks_id_runs_id_retry" % key - ) - local_var_params[key] = val - del local_var_params['kwargs'] + self._check_operation_params('post_tasks_id_runs_id_retry', all_params, local_var_params) # verify the required parameter 'task_id' is set if ('task_id' not in local_var_params or local_var_params['task_id'] is None): @@ -2339,8 +2644,6 @@ def post_tasks_id_runs_id_retry_with_http_info(self, task_id, run_id, **kwargs): local_var_params['run_id'] is None): raise ValueError("Missing the required parameter `run_id` when calling `post_tasks_id_runs_id_retry`") # noqa: E501 - collection_formats = {} - path_params = {} if 'task_id' in local_var_params: path_params['taskID'] = local_var_params['task_id'] # noqa: E501 @@ -2353,9 +2656,6 @@ def post_tasks_id_runs_id_retry_with_http_info(self, task_id, run_id, **kwargs): if 'zap_trace_span' in local_var_params: header_params['Zap-Trace-Span'] = local_var_params['zap_trace_span'] # noqa: E501 - form_params = [] - local_var_files = {} - body_params = None if 'body' in local_var_params: body_params = local_var_params['body'] @@ -2367,27 +2667,4 @@ def post_tasks_id_runs_id_retry_with_http_info(self, task_id, run_id, **kwargs): header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501 ['application/json; charset=utf-8']) # noqa: E501 - # Authentication setting - auth_settings = [] # noqa: E501 - - # urlopen optional setting - urlopen_kw = None - if 'urlopen_kw' in kwargs: - urlopen_kw = kwargs['urlopen_kw'] - - return self.api_client.call_api( - '/api/v2/tasks/{taskID}/runs/{runID}/retry', 'POST', - path_params, - query_params, - header_params, - body=body_params, - post_params=form_params, - files=local_var_files, - response_type='Run', # noqa: E501 - auth_settings=auth_settings, - async_req=local_var_params.get('async_req'), - _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 - _preload_content=local_var_params.get('_preload_content', True), - _request_timeout=local_var_params.get('_request_timeout'), - collection_formats=collection_formats, - urlopen_kw=urlopen_kw) + return local_var_params, path_params, query_params, header_params, body_params diff --git a/influxdb_client/service/telegraf_plugins_service.py b/influxdb_client/service/telegraf_plugins_service.py index 91e5549d..b70b1284 100644 --- a/influxdb_client/service/telegraf_plugins_service.py +++ b/influxdb_client/service/telegraf_plugins_service.py @@ -14,11 +14,10 @@ import re # noqa: F401 -# python 2 and python 3 compatibility library -import six +from influxdb_client.service._base_service import _BaseService -class TelegrafPluginsService(object): +class TelegrafPluginsService(_BaseService): """NOTE: This class is auto generated by OpenAPI Generator. Ref: https://openapi-generator.tech @@ -69,25 +68,63 @@ def get_telegraf_plugins_with_http_info(self, **kwargs): # noqa: E501,D401,D403 If the method is called asynchronously, returns the request thread. """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._get_telegraf_plugins_prepare(**kwargs) + + return self.api_client.call_api( + '/api/v2/telegraf/plugins', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='TelegrafPlugins', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + async def get_telegraf_plugins_async(self, **kwargs): # noqa: E501,D401,D403 + """List all Telegraf plugins. + + This method makes an asynchronous HTTP request. + + :param async_req bool + :param str zap_trace_span: OpenTracing span context + :param str type: The type of plugin desired. + :return: TelegrafPlugins + If the method is called asynchronously, + returns the request thread. + """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._get_telegraf_plugins_prepare(**kwargs) + + return await self.api_client.call_api( + '/api/v2/telegraf/plugins', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='TelegrafPlugins', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + def _get_telegraf_plugins_prepare(self, **kwargs): # noqa: E501,D401,D403 local_var_params = locals() all_params = ['zap_trace_span', 'type'] # noqa: E501 - all_params.append('async_req') - all_params.append('_return_http_data_only') - all_params.append('_preload_content') - all_params.append('_request_timeout') - all_params.append('urlopen_kw') - - for key, val in six.iteritems(local_var_params['kwargs']): - if key not in all_params: - raise TypeError( - "Got an unexpected keyword argument '%s'" - " to method get_telegraf_plugins" % key - ) - local_var_params[key] = val - del local_var_params['kwargs'] - - collection_formats = {} + self._check_operation_params('get_telegraf_plugins', all_params, local_var_params) path_params = {} @@ -99,35 +136,9 @@ def get_telegraf_plugins_with_http_info(self, **kwargs): # noqa: E501,D401,D403 if 'zap_trace_span' in local_var_params: header_params['Zap-Trace-Span'] = local_var_params['zap_trace_span'] # noqa: E501 - form_params = [] - local_var_files = {} - body_params = None # HTTP header `Accept` header_params['Accept'] = self.api_client.select_header_accept( ['application/json']) # noqa: E501 - # Authentication setting - auth_settings = [] # noqa: E501 - - # urlopen optional setting - urlopen_kw = None - if 'urlopen_kw' in kwargs: - urlopen_kw = kwargs['urlopen_kw'] - - return self.api_client.call_api( - '/api/v2/telegraf/plugins', 'GET', - path_params, - query_params, - header_params, - body=body_params, - post_params=form_params, - files=local_var_files, - response_type='TelegrafPlugins', # noqa: E501 - auth_settings=auth_settings, - async_req=local_var_params.get('async_req'), - _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 - _preload_content=local_var_params.get('_preload_content', True), - _request_timeout=local_var_params.get('_request_timeout'), - collection_formats=collection_formats, - urlopen_kw=urlopen_kw) + return local_var_params, path_params, query_params, header_params, body_params diff --git a/influxdb_client/service/telegrafs_service.py b/influxdb_client/service/telegrafs_service.py index 066cce1c..2c7ac4a3 100644 --- a/influxdb_client/service/telegrafs_service.py +++ b/influxdb_client/service/telegrafs_service.py @@ -14,11 +14,10 @@ import re # noqa: F401 -# python 2 and python 3 compatibility library -import six +from influxdb_client.service._base_service import _BaseService -class TelegrafsService(object): +class TelegrafsService(_BaseService): """NOTE: This class is auto generated by OpenAPI Generator. Ref: https://openapi-generator.tech @@ -69,30 +68,68 @@ def delete_telegrafs_id_with_http_info(self, telegraf_id, **kwargs): # noqa: E5 If the method is called asynchronously, returns the request thread. """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._delete_telegrafs_id_prepare(telegraf_id, **kwargs) + + return self.api_client.call_api( + '/api/v2/telegrafs/{telegrafID}', 'DELETE', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type=None, # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + async def delete_telegrafs_id_async(self, telegraf_id, **kwargs): # noqa: E501,D401,D403 + """Delete a Telegraf configuration. + + This method makes an asynchronous HTTP request. + + :param async_req bool + :param str telegraf_id: The Telegraf configuration ID. (required) + :param str zap_trace_span: OpenTracing span context + :return: None + If the method is called asynchronously, + returns the request thread. + """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._delete_telegrafs_id_prepare(telegraf_id, **kwargs) + + return await self.api_client.call_api( + '/api/v2/telegrafs/{telegrafID}', 'DELETE', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type=None, # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + def _delete_telegrafs_id_prepare(self, telegraf_id, **kwargs): # noqa: E501,D401,D403 local_var_params = locals() all_params = ['telegraf_id', 'zap_trace_span'] # noqa: E501 - all_params.append('async_req') - all_params.append('_return_http_data_only') - all_params.append('_preload_content') - all_params.append('_request_timeout') - all_params.append('urlopen_kw') - - for key, val in six.iteritems(local_var_params['kwargs']): - if key not in all_params: - raise TypeError( - "Got an unexpected keyword argument '%s'" - " to method delete_telegrafs_id" % key - ) - local_var_params[key] = val - del local_var_params['kwargs'] + self._check_operation_params('delete_telegrafs_id', all_params, local_var_params) # verify the required parameter 'telegraf_id' is set if ('telegraf_id' not in local_var_params or local_var_params['telegraf_id'] is None): raise ValueError("Missing the required parameter `telegraf_id` when calling `delete_telegrafs_id`") # noqa: E501 - collection_formats = {} - path_params = {} if 'telegraf_id' in local_var_params: path_params['telegrafID'] = local_var_params['telegraf_id'] # noqa: E501 @@ -103,38 +140,12 @@ def delete_telegrafs_id_with_http_info(self, telegraf_id, **kwargs): # noqa: E5 if 'zap_trace_span' in local_var_params: header_params['Zap-Trace-Span'] = local_var_params['zap_trace_span'] # noqa: E501 - form_params = [] - local_var_files = {} - body_params = None # HTTP header `Accept` header_params['Accept'] = self.api_client.select_header_accept( ['application/json']) # noqa: E501 - # Authentication setting - auth_settings = [] # noqa: E501 - - # urlopen optional setting - urlopen_kw = None - if 'urlopen_kw' in kwargs: - urlopen_kw = kwargs['urlopen_kw'] - - return self.api_client.call_api( - '/api/v2/telegrafs/{telegrafID}', 'DELETE', - path_params, - query_params, - header_params, - body=body_params, - post_params=form_params, - files=local_var_files, - response_type=None, # noqa: E501 - auth_settings=auth_settings, - async_req=local_var_params.get('async_req'), - _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 - _preload_content=local_var_params.get('_preload_content', True), - _request_timeout=local_var_params.get('_request_timeout'), - collection_formats=collection_formats, - urlopen_kw=urlopen_kw) + return local_var_params, path_params, query_params, header_params, body_params def delete_telegrafs_id_labels_id(self, telegraf_id, label_id, **kwargs): # noqa: E501,D401,D403 """Delete a label from a Telegraf config. @@ -175,23 +186,64 @@ def delete_telegrafs_id_labels_id_with_http_info(self, telegraf_id, label_id, ** If the method is called asynchronously, returns the request thread. """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._delete_telegrafs_id_labels_id_prepare(telegraf_id, label_id, **kwargs) + + return self.api_client.call_api( + '/api/v2/telegrafs/{telegrafID}/labels/{labelID}', 'DELETE', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type=None, # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + async def delete_telegrafs_id_labels_id_async(self, telegraf_id, label_id, **kwargs): # noqa: E501,D401,D403 + """Delete a label from a Telegraf config. + + This method makes an asynchronous HTTP request. + + :param async_req bool + :param str telegraf_id: The Telegraf config ID. (required) + :param str label_id: The label ID. (required) + :param str zap_trace_span: OpenTracing span context + :return: None + If the method is called asynchronously, + returns the request thread. + """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._delete_telegrafs_id_labels_id_prepare(telegraf_id, label_id, **kwargs) + + return await self.api_client.call_api( + '/api/v2/telegrafs/{telegrafID}/labels/{labelID}', 'DELETE', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type=None, # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + def _delete_telegrafs_id_labels_id_prepare(self, telegraf_id, label_id, **kwargs): # noqa: E501,D401,D403 local_var_params = locals() all_params = ['telegraf_id', 'label_id', 'zap_trace_span'] # noqa: E501 - all_params.append('async_req') - all_params.append('_return_http_data_only') - all_params.append('_preload_content') - all_params.append('_request_timeout') - all_params.append('urlopen_kw') - - for key, val in six.iteritems(local_var_params['kwargs']): - if key not in all_params: - raise TypeError( - "Got an unexpected keyword argument '%s'" - " to method delete_telegrafs_id_labels_id" % key - ) - local_var_params[key] = val - del local_var_params['kwargs'] + self._check_operation_params('delete_telegrafs_id_labels_id', all_params, local_var_params) # verify the required parameter 'telegraf_id' is set if ('telegraf_id' not in local_var_params or local_var_params['telegraf_id'] is None): @@ -201,8 +253,6 @@ def delete_telegrafs_id_labels_id_with_http_info(self, telegraf_id, label_id, ** local_var_params['label_id'] is None): raise ValueError("Missing the required parameter `label_id` when calling `delete_telegrafs_id_labels_id`") # noqa: E501 - collection_formats = {} - path_params = {} if 'telegraf_id' in local_var_params: path_params['telegrafID'] = local_var_params['telegraf_id'] # noqa: E501 @@ -215,38 +265,12 @@ def delete_telegrafs_id_labels_id_with_http_info(self, telegraf_id, label_id, ** if 'zap_trace_span' in local_var_params: header_params['Zap-Trace-Span'] = local_var_params['zap_trace_span'] # noqa: E501 - form_params = [] - local_var_files = {} - body_params = None # HTTP header `Accept` header_params['Accept'] = self.api_client.select_header_accept( ['application/json']) # noqa: E501 - # Authentication setting - auth_settings = [] # noqa: E501 - - # urlopen optional setting - urlopen_kw = None - if 'urlopen_kw' in kwargs: - urlopen_kw = kwargs['urlopen_kw'] - - return self.api_client.call_api( - '/api/v2/telegrafs/{telegrafID}/labels/{labelID}', 'DELETE', - path_params, - query_params, - header_params, - body=body_params, - post_params=form_params, - files=local_var_files, - response_type=None, # noqa: E501 - auth_settings=auth_settings, - async_req=local_var_params.get('async_req'), - _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 - _preload_content=local_var_params.get('_preload_content', True), - _request_timeout=local_var_params.get('_request_timeout'), - collection_formats=collection_formats, - urlopen_kw=urlopen_kw) + return local_var_params, path_params, query_params, header_params, body_params def delete_telegrafs_id_members_id(self, user_id, telegraf_id, **kwargs): # noqa: E501,D401,D403 """Remove a member from a Telegraf config. @@ -287,23 +311,64 @@ def delete_telegrafs_id_members_id_with_http_info(self, user_id, telegraf_id, ** If the method is called asynchronously, returns the request thread. """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._delete_telegrafs_id_members_id_prepare(user_id, telegraf_id, **kwargs) + + return self.api_client.call_api( + '/api/v2/telegrafs/{telegrafID}/members/{userID}', 'DELETE', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type=None, # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + async def delete_telegrafs_id_members_id_async(self, user_id, telegraf_id, **kwargs): # noqa: E501,D401,D403 + """Remove a member from a Telegraf config. + + This method makes an asynchronous HTTP request. + + :param async_req bool + :param str user_id: The ID of the member to remove. (required) + :param str telegraf_id: The Telegraf config ID. (required) + :param str zap_trace_span: OpenTracing span context + :return: None + If the method is called asynchronously, + returns the request thread. + """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._delete_telegrafs_id_members_id_prepare(user_id, telegraf_id, **kwargs) + + return await self.api_client.call_api( + '/api/v2/telegrafs/{telegrafID}/members/{userID}', 'DELETE', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type=None, # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + def _delete_telegrafs_id_members_id_prepare(self, user_id, telegraf_id, **kwargs): # noqa: E501,D401,D403 local_var_params = locals() all_params = ['user_id', 'telegraf_id', 'zap_trace_span'] # noqa: E501 - all_params.append('async_req') - all_params.append('_return_http_data_only') - all_params.append('_preload_content') - all_params.append('_request_timeout') - all_params.append('urlopen_kw') - - for key, val in six.iteritems(local_var_params['kwargs']): - if key not in all_params: - raise TypeError( - "Got an unexpected keyword argument '%s'" - " to method delete_telegrafs_id_members_id" % key - ) - local_var_params[key] = val - del local_var_params['kwargs'] + self._check_operation_params('delete_telegrafs_id_members_id', all_params, local_var_params) # verify the required parameter 'user_id' is set if ('user_id' not in local_var_params or local_var_params['user_id'] is None): @@ -313,8 +378,6 @@ def delete_telegrafs_id_members_id_with_http_info(self, user_id, telegraf_id, ** local_var_params['telegraf_id'] is None): raise ValueError("Missing the required parameter `telegraf_id` when calling `delete_telegrafs_id_members_id`") # noqa: E501 - collection_formats = {} - path_params = {} if 'user_id' in local_var_params: path_params['userID'] = local_var_params['user_id'] # noqa: E501 @@ -327,38 +390,12 @@ def delete_telegrafs_id_members_id_with_http_info(self, user_id, telegraf_id, ** if 'zap_trace_span' in local_var_params: header_params['Zap-Trace-Span'] = local_var_params['zap_trace_span'] # noqa: E501 - form_params = [] - local_var_files = {} - body_params = None # HTTP header `Accept` header_params['Accept'] = self.api_client.select_header_accept( ['application/json']) # noqa: E501 - # Authentication setting - auth_settings = [] # noqa: E501 - - # urlopen optional setting - urlopen_kw = None - if 'urlopen_kw' in kwargs: - urlopen_kw = kwargs['urlopen_kw'] - - return self.api_client.call_api( - '/api/v2/telegrafs/{telegrafID}/members/{userID}', 'DELETE', - path_params, - query_params, - header_params, - body=body_params, - post_params=form_params, - files=local_var_files, - response_type=None, # noqa: E501 - auth_settings=auth_settings, - async_req=local_var_params.get('async_req'), - _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 - _preload_content=local_var_params.get('_preload_content', True), - _request_timeout=local_var_params.get('_request_timeout'), - collection_formats=collection_formats, - urlopen_kw=urlopen_kw) + return local_var_params, path_params, query_params, header_params, body_params def delete_telegrafs_id_owners_id(self, user_id, telegraf_id, **kwargs): # noqa: E501,D401,D403 """Remove an owner from a Telegraf config. @@ -399,23 +436,64 @@ def delete_telegrafs_id_owners_id_with_http_info(self, user_id, telegraf_id, **k If the method is called asynchronously, returns the request thread. """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._delete_telegrafs_id_owners_id_prepare(user_id, telegraf_id, **kwargs) + + return self.api_client.call_api( + '/api/v2/telegrafs/{telegrafID}/owners/{userID}', 'DELETE', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type=None, # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + async def delete_telegrafs_id_owners_id_async(self, user_id, telegraf_id, **kwargs): # noqa: E501,D401,D403 + """Remove an owner from a Telegraf config. + + This method makes an asynchronous HTTP request. + + :param async_req bool + :param str user_id: The ID of the owner to remove. (required) + :param str telegraf_id: The Telegraf config ID. (required) + :param str zap_trace_span: OpenTracing span context + :return: None + If the method is called asynchronously, + returns the request thread. + """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._delete_telegrafs_id_owners_id_prepare(user_id, telegraf_id, **kwargs) + + return await self.api_client.call_api( + '/api/v2/telegrafs/{telegrafID}/owners/{userID}', 'DELETE', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type=None, # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + def _delete_telegrafs_id_owners_id_prepare(self, user_id, telegraf_id, **kwargs): # noqa: E501,D401,D403 local_var_params = locals() all_params = ['user_id', 'telegraf_id', 'zap_trace_span'] # noqa: E501 - all_params.append('async_req') - all_params.append('_return_http_data_only') - all_params.append('_preload_content') - all_params.append('_request_timeout') - all_params.append('urlopen_kw') - - for key, val in six.iteritems(local_var_params['kwargs']): - if key not in all_params: - raise TypeError( - "Got an unexpected keyword argument '%s'" - " to method delete_telegrafs_id_owners_id" % key - ) - local_var_params[key] = val - del local_var_params['kwargs'] + self._check_operation_params('delete_telegrafs_id_owners_id', all_params, local_var_params) # verify the required parameter 'user_id' is set if ('user_id' not in local_var_params or local_var_params['user_id'] is None): @@ -425,8 +503,6 @@ def delete_telegrafs_id_owners_id_with_http_info(self, user_id, telegraf_id, **k local_var_params['telegraf_id'] is None): raise ValueError("Missing the required parameter `telegraf_id` when calling `delete_telegrafs_id_owners_id`") # noqa: E501 - collection_formats = {} - path_params = {} if 'user_id' in local_var_params: path_params['userID'] = local_var_params['user_id'] # noqa: E501 @@ -439,38 +515,12 @@ def delete_telegrafs_id_owners_id_with_http_info(self, user_id, telegraf_id, **k if 'zap_trace_span' in local_var_params: header_params['Zap-Trace-Span'] = local_var_params['zap_trace_span'] # noqa: E501 - form_params = [] - local_var_files = {} - body_params = None # HTTP header `Accept` header_params['Accept'] = self.api_client.select_header_accept( ['application/json']) # noqa: E501 - # Authentication setting - auth_settings = [] # noqa: E501 - - # urlopen optional setting - urlopen_kw = None - if 'urlopen_kw' in kwargs: - urlopen_kw = kwargs['urlopen_kw'] - - return self.api_client.call_api( - '/api/v2/telegrafs/{telegrafID}/owners/{userID}', 'DELETE', - path_params, - query_params, - header_params, - body=body_params, - post_params=form_params, - files=local_var_files, - response_type=None, # noqa: E501 - auth_settings=auth_settings, - async_req=local_var_params.get('async_req'), - _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 - _preload_content=local_var_params.get('_preload_content', True), - _request_timeout=local_var_params.get('_request_timeout'), - collection_formats=collection_formats, - urlopen_kw=urlopen_kw) + return local_var_params, path_params, query_params, header_params, body_params def get_telegrafs(self, **kwargs): # noqa: E501,D401,D403 """List all Telegraf configurations. @@ -509,25 +559,63 @@ def get_telegrafs_with_http_info(self, **kwargs): # noqa: E501,D401,D403 If the method is called asynchronously, returns the request thread. """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._get_telegrafs_prepare(**kwargs) + + return self.api_client.call_api( + '/api/v2/telegrafs', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='Telegrafs', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + async def get_telegrafs_async(self, **kwargs): # noqa: E501,D401,D403 + """List all Telegraf configurations. + + This method makes an asynchronous HTTP request. + + :param async_req bool + :param str zap_trace_span: OpenTracing span context + :param str org_id: The organization ID the Telegraf config belongs to. + :return: Telegrafs + If the method is called asynchronously, + returns the request thread. + """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._get_telegrafs_prepare(**kwargs) + + return await self.api_client.call_api( + '/api/v2/telegrafs', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='Telegrafs', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + def _get_telegrafs_prepare(self, **kwargs): # noqa: E501,D401,D403 local_var_params = locals() all_params = ['zap_trace_span', 'org_id'] # noqa: E501 - all_params.append('async_req') - all_params.append('_return_http_data_only') - all_params.append('_preload_content') - all_params.append('_request_timeout') - all_params.append('urlopen_kw') - - for key, val in six.iteritems(local_var_params['kwargs']): - if key not in all_params: - raise TypeError( - "Got an unexpected keyword argument '%s'" - " to method get_telegrafs" % key - ) - local_var_params[key] = val - del local_var_params['kwargs'] - - collection_formats = {} + self._check_operation_params('get_telegrafs', all_params, local_var_params) path_params = {} @@ -539,38 +627,12 @@ def get_telegrafs_with_http_info(self, **kwargs): # noqa: E501,D401,D403 if 'zap_trace_span' in local_var_params: header_params['Zap-Trace-Span'] = local_var_params['zap_trace_span'] # noqa: E501 - form_params = [] - local_var_files = {} - body_params = None # HTTP header `Accept` header_params['Accept'] = self.api_client.select_header_accept( ['application/json']) # noqa: E501 - # Authentication setting - auth_settings = [] # noqa: E501 - - # urlopen optional setting - urlopen_kw = None - if 'urlopen_kw' in kwargs: - urlopen_kw = kwargs['urlopen_kw'] - - return self.api_client.call_api( - '/api/v2/telegrafs', 'GET', - path_params, - query_params, - header_params, - body=body_params, - post_params=form_params, - files=local_var_files, - response_type='Telegrafs', # noqa: E501 - auth_settings=auth_settings, - async_req=local_var_params.get('async_req'), - _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 - _preload_content=local_var_params.get('_preload_content', True), - _request_timeout=local_var_params.get('_request_timeout'), - collection_formats=collection_formats, - urlopen_kw=urlopen_kw) + return local_var_params, path_params, query_params, header_params, body_params def get_telegrafs_id(self, telegraf_id, **kwargs): # noqa: E501,D401,D403 """Retrieve a Telegraf configuration. @@ -611,30 +673,69 @@ def get_telegrafs_id_with_http_info(self, telegraf_id, **kwargs): # noqa: E501, If the method is called asynchronously, returns the request thread. """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._get_telegrafs_id_prepare(telegraf_id, **kwargs) + + return self.api_client.call_api( + '/api/v2/telegrafs/{telegrafID}', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='str', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + async def get_telegrafs_id_async(self, telegraf_id, **kwargs): # noqa: E501,D401,D403 + """Retrieve a Telegraf configuration. + + This method makes an asynchronous HTTP request. + + :param async_req bool + :param str telegraf_id: The Telegraf configuration ID. (required) + :param str zap_trace_span: OpenTracing span context + :param str accept: + :return: str + If the method is called asynchronously, + returns the request thread. + """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._get_telegrafs_id_prepare(telegraf_id, **kwargs) + + return await self.api_client.call_api( + '/api/v2/telegrafs/{telegrafID}', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='str', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + def _get_telegrafs_id_prepare(self, telegraf_id, **kwargs): # noqa: E501,D401,D403 local_var_params = locals() all_params = ['telegraf_id', 'zap_trace_span', 'accept'] # noqa: E501 - all_params.append('async_req') - all_params.append('_return_http_data_only') - all_params.append('_preload_content') - all_params.append('_request_timeout') - all_params.append('urlopen_kw') - - for key, val in six.iteritems(local_var_params['kwargs']): - if key not in all_params: - raise TypeError( - "Got an unexpected keyword argument '%s'" - " to method get_telegrafs_id" % key - ) - local_var_params[key] = val - del local_var_params['kwargs'] + self._check_operation_params('get_telegrafs_id', all_params, local_var_params) # verify the required parameter 'telegraf_id' is set if ('telegraf_id' not in local_var_params or local_var_params['telegraf_id'] is None): raise ValueError("Missing the required parameter `telegraf_id` when calling `get_telegrafs_id`") # noqa: E501 - collection_formats = {} - path_params = {} if 'telegraf_id' in local_var_params: path_params['telegrafID'] = local_var_params['telegraf_id'] # noqa: E501 @@ -647,38 +748,12 @@ def get_telegrafs_id_with_http_info(self, telegraf_id, **kwargs): # noqa: E501, if 'accept' in local_var_params: header_params['Accept'] = local_var_params['accept'] # noqa: E501 - form_params = [] - local_var_files = {} - body_params = None # HTTP header `Accept` header_params['Accept'] = self.api_client.select_header_accept( ['application/toml', 'application/json', 'application/octet-stream']) # noqa: E501 - # Authentication setting - auth_settings = [] # noqa: E501 - - # urlopen optional setting - urlopen_kw = None - if 'urlopen_kw' in kwargs: - urlopen_kw = kwargs['urlopen_kw'] - - return self.api_client.call_api( - '/api/v2/telegrafs/{telegrafID}', 'GET', - path_params, - query_params, - header_params, - body=body_params, - post_params=form_params, - files=local_var_files, - response_type='str', # noqa: E501 - auth_settings=auth_settings, - async_req=local_var_params.get('async_req'), - _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 - _preload_content=local_var_params.get('_preload_content', True), - _request_timeout=local_var_params.get('_request_timeout'), - collection_formats=collection_formats, - urlopen_kw=urlopen_kw) + return local_var_params, path_params, query_params, header_params, body_params def get_telegrafs_id_labels(self, telegraf_id, **kwargs): # noqa: E501,D401,D403 """List all labels for a Telegraf config. @@ -717,30 +792,68 @@ def get_telegrafs_id_labels_with_http_info(self, telegraf_id, **kwargs): # noqa If the method is called asynchronously, returns the request thread. """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._get_telegrafs_id_labels_prepare(telegraf_id, **kwargs) + + return self.api_client.call_api( + '/api/v2/telegrafs/{telegrafID}/labels', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='LabelsResponse', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + async def get_telegrafs_id_labels_async(self, telegraf_id, **kwargs): # noqa: E501,D401,D403 + """List all labels for a Telegraf config. + + This method makes an asynchronous HTTP request. + + :param async_req bool + :param str telegraf_id: The Telegraf config ID. (required) + :param str zap_trace_span: OpenTracing span context + :return: LabelsResponse + If the method is called asynchronously, + returns the request thread. + """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._get_telegrafs_id_labels_prepare(telegraf_id, **kwargs) + + return await self.api_client.call_api( + '/api/v2/telegrafs/{telegrafID}/labels', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='LabelsResponse', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + def _get_telegrafs_id_labels_prepare(self, telegraf_id, **kwargs): # noqa: E501,D401,D403 local_var_params = locals() all_params = ['telegraf_id', 'zap_trace_span'] # noqa: E501 - all_params.append('async_req') - all_params.append('_return_http_data_only') - all_params.append('_preload_content') - all_params.append('_request_timeout') - all_params.append('urlopen_kw') - - for key, val in six.iteritems(local_var_params['kwargs']): - if key not in all_params: - raise TypeError( - "Got an unexpected keyword argument '%s'" - " to method get_telegrafs_id_labels" % key - ) - local_var_params[key] = val - del local_var_params['kwargs'] + self._check_operation_params('get_telegrafs_id_labels', all_params, local_var_params) # verify the required parameter 'telegraf_id' is set if ('telegraf_id' not in local_var_params or local_var_params['telegraf_id'] is None): raise ValueError("Missing the required parameter `telegraf_id` when calling `get_telegrafs_id_labels`") # noqa: E501 - collection_formats = {} - path_params = {} if 'telegraf_id' in local_var_params: path_params['telegrafID'] = local_var_params['telegraf_id'] # noqa: E501 @@ -751,38 +864,12 @@ def get_telegrafs_id_labels_with_http_info(self, telegraf_id, **kwargs): # noqa if 'zap_trace_span' in local_var_params: header_params['Zap-Trace-Span'] = local_var_params['zap_trace_span'] # noqa: E501 - form_params = [] - local_var_files = {} - body_params = None # HTTP header `Accept` header_params['Accept'] = self.api_client.select_header_accept( ['application/json']) # noqa: E501 - # Authentication setting - auth_settings = [] # noqa: E501 - - # urlopen optional setting - urlopen_kw = None - if 'urlopen_kw' in kwargs: - urlopen_kw = kwargs['urlopen_kw'] - - return self.api_client.call_api( - '/api/v2/telegrafs/{telegrafID}/labels', 'GET', - path_params, - query_params, - header_params, - body=body_params, - post_params=form_params, - files=local_var_files, - response_type='LabelsResponse', # noqa: E501 - auth_settings=auth_settings, - async_req=local_var_params.get('async_req'), - _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 - _preload_content=local_var_params.get('_preload_content', True), - _request_timeout=local_var_params.get('_request_timeout'), - collection_formats=collection_formats, - urlopen_kw=urlopen_kw) + return local_var_params, path_params, query_params, header_params, body_params def get_telegrafs_id_members(self, telegraf_id, **kwargs): # noqa: E501,D401,D403 """List all users with member privileges for a Telegraf config. @@ -821,30 +908,68 @@ def get_telegrafs_id_members_with_http_info(self, telegraf_id, **kwargs): # noq If the method is called asynchronously, returns the request thread. """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._get_telegrafs_id_members_prepare(telegraf_id, **kwargs) + + return self.api_client.call_api( + '/api/v2/telegrafs/{telegrafID}/members', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='ResourceMembers', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + async def get_telegrafs_id_members_async(self, telegraf_id, **kwargs): # noqa: E501,D401,D403 + """List all users with member privileges for a Telegraf config. + + This method makes an asynchronous HTTP request. + + :param async_req bool + :param str telegraf_id: The Telegraf config ID. (required) + :param str zap_trace_span: OpenTracing span context + :return: ResourceMembers + If the method is called asynchronously, + returns the request thread. + """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._get_telegrafs_id_members_prepare(telegraf_id, **kwargs) + + return await self.api_client.call_api( + '/api/v2/telegrafs/{telegrafID}/members', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='ResourceMembers', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + def _get_telegrafs_id_members_prepare(self, telegraf_id, **kwargs): # noqa: E501,D401,D403 local_var_params = locals() all_params = ['telegraf_id', 'zap_trace_span'] # noqa: E501 - all_params.append('async_req') - all_params.append('_return_http_data_only') - all_params.append('_preload_content') - all_params.append('_request_timeout') - all_params.append('urlopen_kw') - - for key, val in six.iteritems(local_var_params['kwargs']): - if key not in all_params: - raise TypeError( - "Got an unexpected keyword argument '%s'" - " to method get_telegrafs_id_members" % key - ) - local_var_params[key] = val - del local_var_params['kwargs'] + self._check_operation_params('get_telegrafs_id_members', all_params, local_var_params) # verify the required parameter 'telegraf_id' is set if ('telegraf_id' not in local_var_params or local_var_params['telegraf_id'] is None): raise ValueError("Missing the required parameter `telegraf_id` when calling `get_telegrafs_id_members`") # noqa: E501 - collection_formats = {} - path_params = {} if 'telegraf_id' in local_var_params: path_params['telegrafID'] = local_var_params['telegraf_id'] # noqa: E501 @@ -855,38 +980,12 @@ def get_telegrafs_id_members_with_http_info(self, telegraf_id, **kwargs): # noq if 'zap_trace_span' in local_var_params: header_params['Zap-Trace-Span'] = local_var_params['zap_trace_span'] # noqa: E501 - form_params = [] - local_var_files = {} - body_params = None # HTTP header `Accept` header_params['Accept'] = self.api_client.select_header_accept( ['application/json']) # noqa: E501 - # Authentication setting - auth_settings = [] # noqa: E501 - - # urlopen optional setting - urlopen_kw = None - if 'urlopen_kw' in kwargs: - urlopen_kw = kwargs['urlopen_kw'] - - return self.api_client.call_api( - '/api/v2/telegrafs/{telegrafID}/members', 'GET', - path_params, - query_params, - header_params, - body=body_params, - post_params=form_params, - files=local_var_files, - response_type='ResourceMembers', # noqa: E501 - auth_settings=auth_settings, - async_req=local_var_params.get('async_req'), - _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 - _preload_content=local_var_params.get('_preload_content', True), - _request_timeout=local_var_params.get('_request_timeout'), - collection_formats=collection_formats, - urlopen_kw=urlopen_kw) + return local_var_params, path_params, query_params, header_params, body_params def get_telegrafs_id_owners(self, telegraf_id, **kwargs): # noqa: E501,D401,D403 """List all owners of a Telegraf configuration. @@ -925,30 +1024,68 @@ def get_telegrafs_id_owners_with_http_info(self, telegraf_id, **kwargs): # noqa If the method is called asynchronously, returns the request thread. """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._get_telegrafs_id_owners_prepare(telegraf_id, **kwargs) + + return self.api_client.call_api( + '/api/v2/telegrafs/{telegrafID}/owners', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='ResourceOwners', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + async def get_telegrafs_id_owners_async(self, telegraf_id, **kwargs): # noqa: E501,D401,D403 + """List all owners of a Telegraf configuration. + + This method makes an asynchronous HTTP request. + + :param async_req bool + :param str telegraf_id: The Telegraf configuration ID. (required) + :param str zap_trace_span: OpenTracing span context + :return: ResourceOwners + If the method is called asynchronously, + returns the request thread. + """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._get_telegrafs_id_owners_prepare(telegraf_id, **kwargs) + + return await self.api_client.call_api( + '/api/v2/telegrafs/{telegrafID}/owners', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='ResourceOwners', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + def _get_telegrafs_id_owners_prepare(self, telegraf_id, **kwargs): # noqa: E501,D401,D403 local_var_params = locals() all_params = ['telegraf_id', 'zap_trace_span'] # noqa: E501 - all_params.append('async_req') - all_params.append('_return_http_data_only') - all_params.append('_preload_content') - all_params.append('_request_timeout') - all_params.append('urlopen_kw') - - for key, val in six.iteritems(local_var_params['kwargs']): - if key not in all_params: - raise TypeError( - "Got an unexpected keyword argument '%s'" - " to method get_telegrafs_id_owners" % key - ) - local_var_params[key] = val - del local_var_params['kwargs'] + self._check_operation_params('get_telegrafs_id_owners', all_params, local_var_params) # verify the required parameter 'telegraf_id' is set if ('telegraf_id' not in local_var_params or local_var_params['telegraf_id'] is None): raise ValueError("Missing the required parameter `telegraf_id` when calling `get_telegrafs_id_owners`") # noqa: E501 - collection_formats = {} - path_params = {} if 'telegraf_id' in local_var_params: path_params['telegrafID'] = local_var_params['telegraf_id'] # noqa: E501 @@ -959,38 +1096,12 @@ def get_telegrafs_id_owners_with_http_info(self, telegraf_id, **kwargs): # noqa if 'zap_trace_span' in local_var_params: header_params['Zap-Trace-Span'] = local_var_params['zap_trace_span'] # noqa: E501 - form_params = [] - local_var_files = {} - body_params = None # HTTP header `Accept` header_params['Accept'] = self.api_client.select_header_accept( - ['application/json']) # noqa: E501 - - # Authentication setting - auth_settings = [] # noqa: E501 - - # urlopen optional setting - urlopen_kw = None - if 'urlopen_kw' in kwargs: - urlopen_kw = kwargs['urlopen_kw'] - - return self.api_client.call_api( - '/api/v2/telegrafs/{telegrafID}/owners', 'GET', - path_params, - query_params, - header_params, - body=body_params, - post_params=form_params, - files=local_var_files, - response_type='ResourceOwners', # noqa: E501 - auth_settings=auth_settings, - async_req=local_var_params.get('async_req'), - _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 - _preload_content=local_var_params.get('_preload_content', True), - _request_timeout=local_var_params.get('_request_timeout'), - collection_formats=collection_formats, - urlopen_kw=urlopen_kw) + ['application/json']) # noqa: E501 + + return local_var_params, path_params, query_params, header_params, body_params def post_telegrafs(self, telegraf_plugin_request, **kwargs): # noqa: E501,D401,D403 """Create a Telegraf configuration. @@ -1029,30 +1140,68 @@ def post_telegrafs_with_http_info(self, telegraf_plugin_request, **kwargs): # n If the method is called asynchronously, returns the request thread. """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._post_telegrafs_prepare(telegraf_plugin_request, **kwargs) + + return self.api_client.call_api( + '/api/v2/telegrafs', 'POST', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='Telegraf', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + async def post_telegrafs_async(self, telegraf_plugin_request, **kwargs): # noqa: E501,D401,D403 + """Create a Telegraf configuration. + + This method makes an asynchronous HTTP request. + + :param async_req bool + :param TelegrafPluginRequest telegraf_plugin_request: Telegraf configuration to create (required) + :param str zap_trace_span: OpenTracing span context + :return: Telegraf + If the method is called asynchronously, + returns the request thread. + """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._post_telegrafs_prepare(telegraf_plugin_request, **kwargs) + + return await self.api_client.call_api( + '/api/v2/telegrafs', 'POST', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='Telegraf', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + def _post_telegrafs_prepare(self, telegraf_plugin_request, **kwargs): # noqa: E501,D401,D403 local_var_params = locals() all_params = ['telegraf_plugin_request', 'zap_trace_span'] # noqa: E501 - all_params.append('async_req') - all_params.append('_return_http_data_only') - all_params.append('_preload_content') - all_params.append('_request_timeout') - all_params.append('urlopen_kw') - - for key, val in six.iteritems(local_var_params['kwargs']): - if key not in all_params: - raise TypeError( - "Got an unexpected keyword argument '%s'" - " to method post_telegrafs" % key - ) - local_var_params[key] = val - del local_var_params['kwargs'] + self._check_operation_params('post_telegrafs', all_params, local_var_params) # verify the required parameter 'telegraf_plugin_request' is set if ('telegraf_plugin_request' not in local_var_params or local_var_params['telegraf_plugin_request'] is None): raise ValueError("Missing the required parameter `telegraf_plugin_request` when calling `post_telegrafs`") # noqa: E501 - collection_formats = {} - path_params = {} query_params = [] @@ -1061,9 +1210,6 @@ def post_telegrafs_with_http_info(self, telegraf_plugin_request, **kwargs): # n if 'zap_trace_span' in local_var_params: header_params['Zap-Trace-Span'] = local_var_params['zap_trace_span'] # noqa: E501 - form_params = [] - local_var_files = {} - body_params = None if 'telegraf_plugin_request' in local_var_params: body_params = local_var_params['telegraf_plugin_request'] @@ -1075,30 +1221,7 @@ def post_telegrafs_with_http_info(self, telegraf_plugin_request, **kwargs): # n header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501 ['application/json']) # noqa: E501 - # Authentication setting - auth_settings = [] # noqa: E501 - - # urlopen optional setting - urlopen_kw = None - if 'urlopen_kw' in kwargs: - urlopen_kw = kwargs['urlopen_kw'] - - return self.api_client.call_api( - '/api/v2/telegrafs', 'POST', - path_params, - query_params, - header_params, - body=body_params, - post_params=form_params, - files=local_var_files, - response_type='Telegraf', # noqa: E501 - auth_settings=auth_settings, - async_req=local_var_params.get('async_req'), - _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 - _preload_content=local_var_params.get('_preload_content', True), - _request_timeout=local_var_params.get('_request_timeout'), - collection_formats=collection_formats, - urlopen_kw=urlopen_kw) + return local_var_params, path_params, query_params, header_params, body_params def post_telegrafs_id_labels(self, telegraf_id, label_mapping, **kwargs): # noqa: E501,D401,D403 """Add a label to a Telegraf config. @@ -1139,23 +1262,64 @@ def post_telegrafs_id_labels_with_http_info(self, telegraf_id, label_mapping, ** If the method is called asynchronously, returns the request thread. """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._post_telegrafs_id_labels_prepare(telegraf_id, label_mapping, **kwargs) + + return self.api_client.call_api( + '/api/v2/telegrafs/{telegrafID}/labels', 'POST', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='LabelResponse', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + async def post_telegrafs_id_labels_async(self, telegraf_id, label_mapping, **kwargs): # noqa: E501,D401,D403 + """Add a label to a Telegraf config. + + This method makes an asynchronous HTTP request. + + :param async_req bool + :param str telegraf_id: The Telegraf config ID. (required) + :param LabelMapping label_mapping: Label to add (required) + :param str zap_trace_span: OpenTracing span context + :return: LabelResponse + If the method is called asynchronously, + returns the request thread. + """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._post_telegrafs_id_labels_prepare(telegraf_id, label_mapping, **kwargs) + + return await self.api_client.call_api( + '/api/v2/telegrafs/{telegrafID}/labels', 'POST', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='LabelResponse', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + def _post_telegrafs_id_labels_prepare(self, telegraf_id, label_mapping, **kwargs): # noqa: E501,D401,D403 local_var_params = locals() all_params = ['telegraf_id', 'label_mapping', 'zap_trace_span'] # noqa: E501 - all_params.append('async_req') - all_params.append('_return_http_data_only') - all_params.append('_preload_content') - all_params.append('_request_timeout') - all_params.append('urlopen_kw') - - for key, val in six.iteritems(local_var_params['kwargs']): - if key not in all_params: - raise TypeError( - "Got an unexpected keyword argument '%s'" - " to method post_telegrafs_id_labels" % key - ) - local_var_params[key] = val - del local_var_params['kwargs'] + self._check_operation_params('post_telegrafs_id_labels', all_params, local_var_params) # verify the required parameter 'telegraf_id' is set if ('telegraf_id' not in local_var_params or local_var_params['telegraf_id'] is None): @@ -1165,8 +1329,6 @@ def post_telegrafs_id_labels_with_http_info(self, telegraf_id, label_mapping, ** local_var_params['label_mapping'] is None): raise ValueError("Missing the required parameter `label_mapping` when calling `post_telegrafs_id_labels`") # noqa: E501 - collection_formats = {} - path_params = {} if 'telegraf_id' in local_var_params: path_params['telegrafID'] = local_var_params['telegraf_id'] # noqa: E501 @@ -1177,9 +1339,6 @@ def post_telegrafs_id_labels_with_http_info(self, telegraf_id, label_mapping, ** if 'zap_trace_span' in local_var_params: header_params['Zap-Trace-Span'] = local_var_params['zap_trace_span'] # noqa: E501 - form_params = [] - local_var_files = {} - body_params = None if 'label_mapping' in local_var_params: body_params = local_var_params['label_mapping'] @@ -1191,30 +1350,7 @@ def post_telegrafs_id_labels_with_http_info(self, telegraf_id, label_mapping, ** header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501 ['application/json']) # noqa: E501 - # Authentication setting - auth_settings = [] # noqa: E501 - - # urlopen optional setting - urlopen_kw = None - if 'urlopen_kw' in kwargs: - urlopen_kw = kwargs['urlopen_kw'] - - return self.api_client.call_api( - '/api/v2/telegrafs/{telegrafID}/labels', 'POST', - path_params, - query_params, - header_params, - body=body_params, - post_params=form_params, - files=local_var_files, - response_type='LabelResponse', # noqa: E501 - auth_settings=auth_settings, - async_req=local_var_params.get('async_req'), - _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 - _preload_content=local_var_params.get('_preload_content', True), - _request_timeout=local_var_params.get('_request_timeout'), - collection_formats=collection_formats, - urlopen_kw=urlopen_kw) + return local_var_params, path_params, query_params, header_params, body_params def post_telegrafs_id_members(self, telegraf_id, add_resource_member_request_body, **kwargs): # noqa: E501,D401,D403 """Add a member to a Telegraf config. @@ -1255,23 +1391,64 @@ def post_telegrafs_id_members_with_http_info(self, telegraf_id, add_resource_mem If the method is called asynchronously, returns the request thread. """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._post_telegrafs_id_members_prepare(telegraf_id, add_resource_member_request_body, **kwargs) + + return self.api_client.call_api( + '/api/v2/telegrafs/{telegrafID}/members', 'POST', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='ResourceMember', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + async def post_telegrafs_id_members_async(self, telegraf_id, add_resource_member_request_body, **kwargs): # noqa: E501,D401,D403 + """Add a member to a Telegraf config. + + This method makes an asynchronous HTTP request. + + :param async_req bool + :param str telegraf_id: The Telegraf config ID. (required) + :param AddResourceMemberRequestBody add_resource_member_request_body: User to add as member (required) + :param str zap_trace_span: OpenTracing span context + :return: ResourceMember + If the method is called asynchronously, + returns the request thread. + """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._post_telegrafs_id_members_prepare(telegraf_id, add_resource_member_request_body, **kwargs) + + return await self.api_client.call_api( + '/api/v2/telegrafs/{telegrafID}/members', 'POST', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='ResourceMember', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + def _post_telegrafs_id_members_prepare(self, telegraf_id, add_resource_member_request_body, **kwargs): # noqa: E501,D401,D403 local_var_params = locals() all_params = ['telegraf_id', 'add_resource_member_request_body', 'zap_trace_span'] # noqa: E501 - all_params.append('async_req') - all_params.append('_return_http_data_only') - all_params.append('_preload_content') - all_params.append('_request_timeout') - all_params.append('urlopen_kw') - - for key, val in six.iteritems(local_var_params['kwargs']): - if key not in all_params: - raise TypeError( - "Got an unexpected keyword argument '%s'" - " to method post_telegrafs_id_members" % key - ) - local_var_params[key] = val - del local_var_params['kwargs'] + self._check_operation_params('post_telegrafs_id_members', all_params, local_var_params) # verify the required parameter 'telegraf_id' is set if ('telegraf_id' not in local_var_params or local_var_params['telegraf_id'] is None): @@ -1281,8 +1458,6 @@ def post_telegrafs_id_members_with_http_info(self, telegraf_id, add_resource_mem local_var_params['add_resource_member_request_body'] is None): raise ValueError("Missing the required parameter `add_resource_member_request_body` when calling `post_telegrafs_id_members`") # noqa: E501 - collection_formats = {} - path_params = {} if 'telegraf_id' in local_var_params: path_params['telegrafID'] = local_var_params['telegraf_id'] # noqa: E501 @@ -1293,9 +1468,6 @@ def post_telegrafs_id_members_with_http_info(self, telegraf_id, add_resource_mem if 'zap_trace_span' in local_var_params: header_params['Zap-Trace-Span'] = local_var_params['zap_trace_span'] # noqa: E501 - form_params = [] - local_var_files = {} - body_params = None if 'add_resource_member_request_body' in local_var_params: body_params = local_var_params['add_resource_member_request_body'] @@ -1307,30 +1479,7 @@ def post_telegrafs_id_members_with_http_info(self, telegraf_id, add_resource_mem header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501 ['application/json']) # noqa: E501 - # Authentication setting - auth_settings = [] # noqa: E501 - - # urlopen optional setting - urlopen_kw = None - if 'urlopen_kw' in kwargs: - urlopen_kw = kwargs['urlopen_kw'] - - return self.api_client.call_api( - '/api/v2/telegrafs/{telegrafID}/members', 'POST', - path_params, - query_params, - header_params, - body=body_params, - post_params=form_params, - files=local_var_files, - response_type='ResourceMember', # noqa: E501 - auth_settings=auth_settings, - async_req=local_var_params.get('async_req'), - _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 - _preload_content=local_var_params.get('_preload_content', True), - _request_timeout=local_var_params.get('_request_timeout'), - collection_formats=collection_formats, - urlopen_kw=urlopen_kw) + return local_var_params, path_params, query_params, header_params, body_params def post_telegrafs_id_owners(self, telegraf_id, add_resource_member_request_body, **kwargs): # noqa: E501,D401,D403 """Add an owner to a Telegraf configuration. @@ -1371,23 +1520,64 @@ def post_telegrafs_id_owners_with_http_info(self, telegraf_id, add_resource_memb If the method is called asynchronously, returns the request thread. """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._post_telegrafs_id_owners_prepare(telegraf_id, add_resource_member_request_body, **kwargs) + + return self.api_client.call_api( + '/api/v2/telegrafs/{telegrafID}/owners', 'POST', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='ResourceOwner', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + async def post_telegrafs_id_owners_async(self, telegraf_id, add_resource_member_request_body, **kwargs): # noqa: E501,D401,D403 + """Add an owner to a Telegraf configuration. + + This method makes an asynchronous HTTP request. + + :param async_req bool + :param str telegraf_id: The Telegraf configuration ID. (required) + :param AddResourceMemberRequestBody add_resource_member_request_body: User to add as owner (required) + :param str zap_trace_span: OpenTracing span context + :return: ResourceOwner + If the method is called asynchronously, + returns the request thread. + """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._post_telegrafs_id_owners_prepare(telegraf_id, add_resource_member_request_body, **kwargs) + + return await self.api_client.call_api( + '/api/v2/telegrafs/{telegrafID}/owners', 'POST', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='ResourceOwner', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + def _post_telegrafs_id_owners_prepare(self, telegraf_id, add_resource_member_request_body, **kwargs): # noqa: E501,D401,D403 local_var_params = locals() all_params = ['telegraf_id', 'add_resource_member_request_body', 'zap_trace_span'] # noqa: E501 - all_params.append('async_req') - all_params.append('_return_http_data_only') - all_params.append('_preload_content') - all_params.append('_request_timeout') - all_params.append('urlopen_kw') - - for key, val in six.iteritems(local_var_params['kwargs']): - if key not in all_params: - raise TypeError( - "Got an unexpected keyword argument '%s'" - " to method post_telegrafs_id_owners" % key - ) - local_var_params[key] = val - del local_var_params['kwargs'] + self._check_operation_params('post_telegrafs_id_owners', all_params, local_var_params) # verify the required parameter 'telegraf_id' is set if ('telegraf_id' not in local_var_params or local_var_params['telegraf_id'] is None): @@ -1397,8 +1587,6 @@ def post_telegrafs_id_owners_with_http_info(self, telegraf_id, add_resource_memb local_var_params['add_resource_member_request_body'] is None): raise ValueError("Missing the required parameter `add_resource_member_request_body` when calling `post_telegrafs_id_owners`") # noqa: E501 - collection_formats = {} - path_params = {} if 'telegraf_id' in local_var_params: path_params['telegrafID'] = local_var_params['telegraf_id'] # noqa: E501 @@ -1409,9 +1597,6 @@ def post_telegrafs_id_owners_with_http_info(self, telegraf_id, add_resource_memb if 'zap_trace_span' in local_var_params: header_params['Zap-Trace-Span'] = local_var_params['zap_trace_span'] # noqa: E501 - form_params = [] - local_var_files = {} - body_params = None if 'add_resource_member_request_body' in local_var_params: body_params = local_var_params['add_resource_member_request_body'] @@ -1423,30 +1608,7 @@ def post_telegrafs_id_owners_with_http_info(self, telegraf_id, add_resource_memb header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501 ['application/json']) # noqa: E501 - # Authentication setting - auth_settings = [] # noqa: E501 - - # urlopen optional setting - urlopen_kw = None - if 'urlopen_kw' in kwargs: - urlopen_kw = kwargs['urlopen_kw'] - - return self.api_client.call_api( - '/api/v2/telegrafs/{telegrafID}/owners', 'POST', - path_params, - query_params, - header_params, - body=body_params, - post_params=form_params, - files=local_var_files, - response_type='ResourceOwner', # noqa: E501 - auth_settings=auth_settings, - async_req=local_var_params.get('async_req'), - _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 - _preload_content=local_var_params.get('_preload_content', True), - _request_timeout=local_var_params.get('_request_timeout'), - collection_formats=collection_formats, - urlopen_kw=urlopen_kw) + return local_var_params, path_params, query_params, header_params, body_params def put_telegrafs_id(self, telegraf_id, telegraf_plugin_request, **kwargs): # noqa: E501,D401,D403 """Update a Telegraf configuration. @@ -1487,23 +1649,64 @@ def put_telegrafs_id_with_http_info(self, telegraf_id, telegraf_plugin_request, If the method is called asynchronously, returns the request thread. """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._put_telegrafs_id_prepare(telegraf_id, telegraf_plugin_request, **kwargs) + + return self.api_client.call_api( + '/api/v2/telegrafs/{telegrafID}', 'PUT', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='Telegraf', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + async def put_telegrafs_id_async(self, telegraf_id, telegraf_plugin_request, **kwargs): # noqa: E501,D401,D403 + """Update a Telegraf configuration. + + This method makes an asynchronous HTTP request. + + :param async_req bool + :param str telegraf_id: The Telegraf config ID. (required) + :param TelegrafPluginRequest telegraf_plugin_request: Telegraf configuration update to apply (required) + :param str zap_trace_span: OpenTracing span context + :return: Telegraf + If the method is called asynchronously, + returns the request thread. + """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._put_telegrafs_id_prepare(telegraf_id, telegraf_plugin_request, **kwargs) + + return await self.api_client.call_api( + '/api/v2/telegrafs/{telegrafID}', 'PUT', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='Telegraf', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + def _put_telegrafs_id_prepare(self, telegraf_id, telegraf_plugin_request, **kwargs): # noqa: E501,D401,D403 local_var_params = locals() all_params = ['telegraf_id', 'telegraf_plugin_request', 'zap_trace_span'] # noqa: E501 - all_params.append('async_req') - all_params.append('_return_http_data_only') - all_params.append('_preload_content') - all_params.append('_request_timeout') - all_params.append('urlopen_kw') - - for key, val in six.iteritems(local_var_params['kwargs']): - if key not in all_params: - raise TypeError( - "Got an unexpected keyword argument '%s'" - " to method put_telegrafs_id" % key - ) - local_var_params[key] = val - del local_var_params['kwargs'] + self._check_operation_params('put_telegrafs_id', all_params, local_var_params) # verify the required parameter 'telegraf_id' is set if ('telegraf_id' not in local_var_params or local_var_params['telegraf_id'] is None): @@ -1513,8 +1716,6 @@ def put_telegrafs_id_with_http_info(self, telegraf_id, telegraf_plugin_request, local_var_params['telegraf_plugin_request'] is None): raise ValueError("Missing the required parameter `telegraf_plugin_request` when calling `put_telegrafs_id`") # noqa: E501 - collection_formats = {} - path_params = {} if 'telegraf_id' in local_var_params: path_params['telegrafID'] = local_var_params['telegraf_id'] # noqa: E501 @@ -1525,9 +1726,6 @@ def put_telegrafs_id_with_http_info(self, telegraf_id, telegraf_plugin_request, if 'zap_trace_span' in local_var_params: header_params['Zap-Trace-Span'] = local_var_params['zap_trace_span'] # noqa: E501 - form_params = [] - local_var_files = {} - body_params = None if 'telegraf_plugin_request' in local_var_params: body_params = local_var_params['telegraf_plugin_request'] @@ -1539,27 +1737,4 @@ def put_telegrafs_id_with_http_info(self, telegraf_id, telegraf_plugin_request, header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501 ['application/json']) # noqa: E501 - # Authentication setting - auth_settings = [] # noqa: E501 - - # urlopen optional setting - urlopen_kw = None - if 'urlopen_kw' in kwargs: - urlopen_kw = kwargs['urlopen_kw'] - - return self.api_client.call_api( - '/api/v2/telegrafs/{telegrafID}', 'PUT', - path_params, - query_params, - header_params, - body=body_params, - post_params=form_params, - files=local_var_files, - response_type='Telegraf', # noqa: E501 - auth_settings=auth_settings, - async_req=local_var_params.get('async_req'), - _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 - _preload_content=local_var_params.get('_preload_content', True), - _request_timeout=local_var_params.get('_request_timeout'), - collection_formats=collection_formats, - urlopen_kw=urlopen_kw) + return local_var_params, path_params, query_params, header_params, body_params diff --git a/influxdb_client/service/templates_service.py b/influxdb_client/service/templates_service.py index de2c56b4..c2fd6766 100644 --- a/influxdb_client/service/templates_service.py +++ b/influxdb_client/service/templates_service.py @@ -14,11 +14,10 @@ import re # noqa: F401 -# python 2 and python 3 compatibility library -import six +from influxdb_client.service._base_service import _BaseService -class TemplatesService(object): +class TemplatesService(_BaseService): """NOTE: This class is auto generated by OpenAPI Generator. Ref: https://openapi-generator.tech @@ -69,39 +68,74 @@ def apply_template_with_http_info(self, template_apply, **kwargs): # noqa: E501 If the method is called asynchronously, returns the request thread. """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._apply_template_prepare(template_apply, **kwargs) + + return self.api_client.call_api( + '/api/v2/templates/apply', 'POST', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='TemplateSummary', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + async def apply_template_async(self, template_apply, **kwargs): # noqa: E501,D401,D403 + """Apply or dry-run a template. + + Applies or performs a dry-run of template in an organization. + This method makes an asynchronous HTTP request. + + :param async_req bool + :param TemplateApply template_apply: (required) + :return: TemplateSummary + If the method is called asynchronously, + returns the request thread. + """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._apply_template_prepare(template_apply, **kwargs) + + return await self.api_client.call_api( + '/api/v2/templates/apply', 'POST', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='TemplateSummary', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + def _apply_template_prepare(self, template_apply, **kwargs): # noqa: E501,D401,D403 local_var_params = locals() all_params = ['template_apply'] # noqa: E501 - all_params.append('async_req') - all_params.append('_return_http_data_only') - all_params.append('_preload_content') - all_params.append('_request_timeout') - all_params.append('urlopen_kw') - - for key, val in six.iteritems(local_var_params['kwargs']): - if key not in all_params: - raise TypeError( - "Got an unexpected keyword argument '%s'" - " to method apply_template" % key - ) - local_var_params[key] = val - del local_var_params['kwargs'] + self._check_operation_params('apply_template', all_params, local_var_params) # verify the required parameter 'template_apply' is set if ('template_apply' not in local_var_params or local_var_params['template_apply'] is None): raise ValueError("Missing the required parameter `template_apply` when calling `apply_template`") # noqa: E501 - collection_formats = {} - path_params = {} query_params = [] header_params = {} - form_params = [] - local_var_files = {} - body_params = None if 'template_apply' in local_var_params: body_params = local_var_params['template_apply'] @@ -113,30 +147,7 @@ def apply_template_with_http_info(self, template_apply, **kwargs): # noqa: E501 header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501 ['application/json', 'application/x-jsonnet', 'text/yml']) # noqa: E501 - # Authentication setting - auth_settings = [] # noqa: E501 - - # urlopen optional setting - urlopen_kw = None - if 'urlopen_kw' in kwargs: - urlopen_kw = kwargs['urlopen_kw'] - - return self.api_client.call_api( - '/api/v2/templates/apply', 'POST', - path_params, - query_params, - header_params, - body=body_params, - post_params=form_params, - files=local_var_files, - response_type='TemplateSummary', # noqa: E501 - auth_settings=auth_settings, - async_req=local_var_params.get('async_req'), - _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 - _preload_content=local_var_params.get('_preload_content', True), - _request_timeout=local_var_params.get('_request_timeout'), - collection_formats=collection_formats, - urlopen_kw=urlopen_kw) + return local_var_params, path_params, query_params, header_params, body_params def create_stack(self, **kwargs): # noqa: E501,D401,D403 """Create a new stack. @@ -173,25 +184,62 @@ def create_stack_with_http_info(self, **kwargs): # noqa: E501,D401,D403 If the method is called asynchronously, returns the request thread. """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._create_stack_prepare(**kwargs) + + return self.api_client.call_api( + '/api/v2/stacks', 'POST', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='Stack', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + async def create_stack_async(self, **kwargs): # noqa: E501,D401,D403 + """Create a new stack. + + This method makes an asynchronous HTTP request. + + :param async_req bool + :param PostStackRequest post_stack_request: + :return: Stack + If the method is called asynchronously, + returns the request thread. + """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._create_stack_prepare(**kwargs) + + return await self.api_client.call_api( + '/api/v2/stacks', 'POST', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='Stack', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + def _create_stack_prepare(self, **kwargs): # noqa: E501,D401,D403 local_var_params = locals() all_params = ['post_stack_request'] # noqa: E501 - all_params.append('async_req') - all_params.append('_return_http_data_only') - all_params.append('_preload_content') - all_params.append('_request_timeout') - all_params.append('urlopen_kw') - - for key, val in six.iteritems(local_var_params['kwargs']): - if key not in all_params: - raise TypeError( - "Got an unexpected keyword argument '%s'" - " to method create_stack" % key - ) - local_var_params[key] = val - del local_var_params['kwargs'] - - collection_formats = {} + self._check_operation_params('create_stack', all_params, local_var_params) path_params = {} @@ -199,9 +247,6 @@ def create_stack_with_http_info(self, **kwargs): # noqa: E501,D401,D403 header_params = {} - form_params = [] - local_var_files = {} - body_params = None if 'post_stack_request' in local_var_params: body_params = local_var_params['post_stack_request'] @@ -213,30 +258,7 @@ def create_stack_with_http_info(self, **kwargs): # noqa: E501,D401,D403 header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501 ['application/json']) # noqa: E501 - # Authentication setting - auth_settings = [] # noqa: E501 - - # urlopen optional setting - urlopen_kw = None - if 'urlopen_kw' in kwargs: - urlopen_kw = kwargs['urlopen_kw'] - - return self.api_client.call_api( - '/api/v2/stacks', 'POST', - path_params, - query_params, - header_params, - body=body_params, - post_params=form_params, - files=local_var_files, - response_type='Stack', # noqa: E501 - auth_settings=auth_settings, - async_req=local_var_params.get('async_req'), - _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 - _preload_content=local_var_params.get('_preload_content', True), - _request_timeout=local_var_params.get('_request_timeout'), - collection_formats=collection_formats, - urlopen_kw=urlopen_kw) + return local_var_params, path_params, query_params, header_params, body_params def delete_stack(self, stack_id, org_id, **kwargs): # noqa: E501,D401,D403 """Delete a stack and associated resources. @@ -275,23 +297,63 @@ def delete_stack_with_http_info(self, stack_id, org_id, **kwargs): # noqa: E501 If the method is called asynchronously, returns the request thread. """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._delete_stack_prepare(stack_id, org_id, **kwargs) + + return self.api_client.call_api( + '/api/v2/stacks/{stack_id}', 'DELETE', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type=None, # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + async def delete_stack_async(self, stack_id, org_id, **kwargs): # noqa: E501,D401,D403 + """Delete a stack and associated resources. + + This method makes an asynchronous HTTP request. + + :param async_req bool + :param str stack_id: The identifier of the stack. (required) + :param str org_id: The identifier of the organization. (required) + :return: None + If the method is called asynchronously, + returns the request thread. + """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._delete_stack_prepare(stack_id, org_id, **kwargs) + + return await self.api_client.call_api( + '/api/v2/stacks/{stack_id}', 'DELETE', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type=None, # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + def _delete_stack_prepare(self, stack_id, org_id, **kwargs): # noqa: E501,D401,D403 local_var_params = locals() all_params = ['stack_id', 'org_id'] # noqa: E501 - all_params.append('async_req') - all_params.append('_return_http_data_only') - all_params.append('_preload_content') - all_params.append('_request_timeout') - all_params.append('urlopen_kw') - - for key, val in six.iteritems(local_var_params['kwargs']): - if key not in all_params: - raise TypeError( - "Got an unexpected keyword argument '%s'" - " to method delete_stack" % key - ) - local_var_params[key] = val - del local_var_params['kwargs'] + self._check_operation_params('delete_stack', all_params, local_var_params) # verify the required parameter 'stack_id' is set if ('stack_id' not in local_var_params or local_var_params['stack_id'] is None): @@ -301,8 +363,6 @@ def delete_stack_with_http_info(self, stack_id, org_id, **kwargs): # noqa: E501 local_var_params['org_id'] is None): raise ValueError("Missing the required parameter `org_id` when calling `delete_stack`") # noqa: E501 - collection_formats = {} - path_params = {} if 'stack_id' in local_var_params: path_params['stack_id'] = local_var_params['stack_id'] # noqa: E501 @@ -313,38 +373,12 @@ def delete_stack_with_http_info(self, stack_id, org_id, **kwargs): # noqa: E501 header_params = {} - form_params = [] - local_var_files = {} - body_params = None # HTTP header `Accept` header_params['Accept'] = self.api_client.select_header_accept( ['application/json']) # noqa: E501 - # Authentication setting - auth_settings = [] # noqa: E501 - - # urlopen optional setting - urlopen_kw = None - if 'urlopen_kw' in kwargs: - urlopen_kw = kwargs['urlopen_kw'] - - return self.api_client.call_api( - '/api/v2/stacks/{stack_id}', 'DELETE', - path_params, - query_params, - header_params, - body=body_params, - post_params=form_params, - files=local_var_files, - response_type=None, # noqa: E501 - auth_settings=auth_settings, - async_req=local_var_params.get('async_req'), - _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 - _preload_content=local_var_params.get('_preload_content', True), - _request_timeout=local_var_params.get('_request_timeout'), - collection_formats=collection_formats, - urlopen_kw=urlopen_kw) + return local_var_params, path_params, query_params, header_params, body_params def export_template(self, **kwargs): # noqa: E501,D401,D403 """Export a new template. @@ -355,7 +389,7 @@ def export_template(self, **kwargs): # noqa: E501,D401,D403 >>> result = thread.get() :param async_req bool - :param UNKNOWN_BASE_TYPE unknown_base_type: Export resources as an InfluxDB template. + :param TemplateExportByID template_export_by_id: Export resources as an InfluxDB template. :return: list[object] If the method is called asynchronously, returns the request thread. @@ -376,30 +410,67 @@ def export_template_with_http_info(self, **kwargs): # noqa: E501,D401,D403 >>> result = thread.get() :param async_req bool - :param UNKNOWN_BASE_TYPE unknown_base_type: Export resources as an InfluxDB template. + :param TemplateExportByID template_export_by_id: Export resources as an InfluxDB template. :return: list[object] If the method is called asynchronously, returns the request thread. """ # noqa: E501 - local_var_params = locals() + local_var_params, path_params, query_params, header_params, body_params = \ + self._export_template_prepare(**kwargs) - all_params = ['unknown_base_type'] # noqa: E501 - all_params.append('async_req') - all_params.append('_return_http_data_only') - all_params.append('_preload_content') - all_params.append('_request_timeout') - all_params.append('urlopen_kw') + return self.api_client.call_api( + '/api/v2/templates/export', 'POST', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='list[object]', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) - for key, val in six.iteritems(local_var_params['kwargs']): - if key not in all_params: - raise TypeError( - "Got an unexpected keyword argument '%s'" - " to method export_template" % key - ) - local_var_params[key] = val - del local_var_params['kwargs'] + async def export_template_async(self, **kwargs): # noqa: E501,D401,D403 + """Export a new template. - collection_formats = {} + This method makes an asynchronous HTTP request. + + :param async_req bool + :param TemplateExportByID template_export_by_id: Export resources as an InfluxDB template. + :return: list[object] + If the method is called asynchronously, + returns the request thread. + """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._export_template_prepare(**kwargs) + + return await self.api_client.call_api( + '/api/v2/templates/export', 'POST', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='list[object]', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + def _export_template_prepare(self, **kwargs): # noqa: E501,D401,D403 + local_var_params = locals() + + all_params = ['template_export_by_id'] # noqa: E501 + self._check_operation_params('export_template', all_params, local_var_params) path_params = {} @@ -407,12 +478,9 @@ def export_template_with_http_info(self, **kwargs): # noqa: E501,D401,D403 header_params = {} - form_params = [] - local_var_files = {} - body_params = None - if 'unknown_base_type' in local_var_params: - body_params = local_var_params['unknown_base_type'] + if 'template_export_by_id' in local_var_params: + body_params = local_var_params['template_export_by_id'] # HTTP header `Accept` header_params['Accept'] = self.api_client.select_header_accept( ['application/json', 'application/x-yaml']) # noqa: E501 @@ -421,30 +489,7 @@ def export_template_with_http_info(self, **kwargs): # noqa: E501,D401,D403 header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501 ['application/json']) # noqa: E501 - # Authentication setting - auth_settings = [] # noqa: E501 - - # urlopen optional setting - urlopen_kw = None - if 'urlopen_kw' in kwargs: - urlopen_kw = kwargs['urlopen_kw'] - - return self.api_client.call_api( - '/api/v2/templates/export', 'POST', - path_params, - query_params, - header_params, - body=body_params, - post_params=form_params, - files=local_var_files, - response_type='list[object]', # noqa: E501 - auth_settings=auth_settings, - async_req=local_var_params.get('async_req'), - _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 - _preload_content=local_var_params.get('_preload_content', True), - _request_timeout=local_var_params.get('_request_timeout'), - collection_formats=collection_formats, - urlopen_kw=urlopen_kw) + return local_var_params, path_params, query_params, header_params, body_params def list_stacks(self, org_id, **kwargs): # noqa: E501,D401,D403 """List installed templates. @@ -485,30 +530,69 @@ def list_stacks_with_http_info(self, org_id, **kwargs): # noqa: E501,D401,D403 If the method is called asynchronously, returns the request thread. """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._list_stacks_prepare(org_id, **kwargs) + + return self.api_client.call_api( + '/api/v2/stacks', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='ListStacksResponse', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + async def list_stacks_async(self, org_id, **kwargs): # noqa: E501,D401,D403 + """List installed templates. + + This method makes an asynchronous HTTP request. + + :param async_req bool + :param str org_id: The organization ID of the stacks (required) + :param str name: A collection of names to filter the list by. + :param str stack_id: A collection of stackIDs to filter the list by. + :return: ListStacksResponse + If the method is called asynchronously, + returns the request thread. + """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._list_stacks_prepare(org_id, **kwargs) + + return await self.api_client.call_api( + '/api/v2/stacks', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='ListStacksResponse', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + def _list_stacks_prepare(self, org_id, **kwargs): # noqa: E501,D401,D403 local_var_params = locals() all_params = ['org_id', 'name', 'stack_id'] # noqa: E501 - all_params.append('async_req') - all_params.append('_return_http_data_only') - all_params.append('_preload_content') - all_params.append('_request_timeout') - all_params.append('urlopen_kw') - - for key, val in six.iteritems(local_var_params['kwargs']): - if key not in all_params: - raise TypeError( - "Got an unexpected keyword argument '%s'" - " to method list_stacks" % key - ) - local_var_params[key] = val - del local_var_params['kwargs'] + self._check_operation_params('list_stacks', all_params, local_var_params) # verify the required parameter 'org_id' is set if ('org_id' not in local_var_params or local_var_params['org_id'] is None): raise ValueError("Missing the required parameter `org_id` when calling `list_stacks`") # noqa: E501 - collection_formats = {} - path_params = {} query_params = [] @@ -521,38 +605,12 @@ def list_stacks_with_http_info(self, org_id, **kwargs): # noqa: E501,D401,D403 header_params = {} - form_params = [] - local_var_files = {} - body_params = None # HTTP header `Accept` header_params['Accept'] = self.api_client.select_header_accept( ['application/json']) # noqa: E501 - # Authentication setting - auth_settings = [] # noqa: E501 - - # urlopen optional setting - urlopen_kw = None - if 'urlopen_kw' in kwargs: - urlopen_kw = kwargs['urlopen_kw'] - - return self.api_client.call_api( - '/api/v2/stacks', 'GET', - path_params, - query_params, - header_params, - body=body_params, - post_params=form_params, - files=local_var_files, - response_type='ListStacksResponse', # noqa: E501 - auth_settings=auth_settings, - async_req=local_var_params.get('async_req'), - _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 - _preload_content=local_var_params.get('_preload_content', True), - _request_timeout=local_var_params.get('_request_timeout'), - collection_formats=collection_formats, - urlopen_kw=urlopen_kw) + return local_var_params, path_params, query_params, header_params, body_params def read_stack(self, stack_id, **kwargs): # noqa: E501,D401,D403 """Retrieve a stack. @@ -589,30 +647,67 @@ def read_stack_with_http_info(self, stack_id, **kwargs): # noqa: E501,D401,D403 If the method is called asynchronously, returns the request thread. """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._read_stack_prepare(stack_id, **kwargs) + + return self.api_client.call_api( + '/api/v2/stacks/{stack_id}', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='Stack', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + async def read_stack_async(self, stack_id, **kwargs): # noqa: E501,D401,D403 + """Retrieve a stack. + + This method makes an asynchronous HTTP request. + + :param async_req bool + :param str stack_id: The identifier of the stack. (required) + :return: Stack + If the method is called asynchronously, + returns the request thread. + """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._read_stack_prepare(stack_id, **kwargs) + + return await self.api_client.call_api( + '/api/v2/stacks/{stack_id}', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='Stack', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + def _read_stack_prepare(self, stack_id, **kwargs): # noqa: E501,D401,D403 local_var_params = locals() all_params = ['stack_id'] # noqa: E501 - all_params.append('async_req') - all_params.append('_return_http_data_only') - all_params.append('_preload_content') - all_params.append('_request_timeout') - all_params.append('urlopen_kw') - - for key, val in six.iteritems(local_var_params['kwargs']): - if key not in all_params: - raise TypeError( - "Got an unexpected keyword argument '%s'" - " to method read_stack" % key - ) - local_var_params[key] = val - del local_var_params['kwargs'] + self._check_operation_params('read_stack', all_params, local_var_params) # verify the required parameter 'stack_id' is set if ('stack_id' not in local_var_params or local_var_params['stack_id'] is None): raise ValueError("Missing the required parameter `stack_id` when calling `read_stack`") # noqa: E501 - collection_formats = {} - path_params = {} if 'stack_id' in local_var_params: path_params['stack_id'] = local_var_params['stack_id'] # noqa: E501 @@ -621,38 +716,12 @@ def read_stack_with_http_info(self, stack_id, **kwargs): # noqa: E501,D401,D403 header_params = {} - form_params = [] - local_var_files = {} - body_params = None # HTTP header `Accept` header_params['Accept'] = self.api_client.select_header_accept( ['application/json']) # noqa: E501 - # Authentication setting - auth_settings = [] # noqa: E501 - - # urlopen optional setting - urlopen_kw = None - if 'urlopen_kw' in kwargs: - urlopen_kw = kwargs['urlopen_kw'] - - return self.api_client.call_api( - '/api/v2/stacks/{stack_id}', 'GET', - path_params, - query_params, - header_params, - body=body_params, - post_params=form_params, - files=local_var_files, - response_type='Stack', # noqa: E501 - auth_settings=auth_settings, - async_req=local_var_params.get('async_req'), - _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 - _preload_content=local_var_params.get('_preload_content', True), - _request_timeout=local_var_params.get('_request_timeout'), - collection_formats=collection_formats, - urlopen_kw=urlopen_kw) + return local_var_params, path_params, query_params, header_params, body_params def uninstall_stack(self, stack_id, **kwargs): # noqa: E501,D401,D403 """Uninstall a stack. @@ -689,30 +758,67 @@ def uninstall_stack_with_http_info(self, stack_id, **kwargs): # noqa: E501,D401 If the method is called asynchronously, returns the request thread. """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._uninstall_stack_prepare(stack_id, **kwargs) + + return self.api_client.call_api( + '/api/v2/stacks/{stack_id}/uninstall', 'POST', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='Stack', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + async def uninstall_stack_async(self, stack_id, **kwargs): # noqa: E501,D401,D403 + """Uninstall a stack. + + This method makes an asynchronous HTTP request. + + :param async_req bool + :param str stack_id: The identifier of the stack. (required) + :return: Stack + If the method is called asynchronously, + returns the request thread. + """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._uninstall_stack_prepare(stack_id, **kwargs) + + return await self.api_client.call_api( + '/api/v2/stacks/{stack_id}/uninstall', 'POST', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='Stack', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + def _uninstall_stack_prepare(self, stack_id, **kwargs): # noqa: E501,D401,D403 local_var_params = locals() all_params = ['stack_id'] # noqa: E501 - all_params.append('async_req') - all_params.append('_return_http_data_only') - all_params.append('_preload_content') - all_params.append('_request_timeout') - all_params.append('urlopen_kw') - - for key, val in six.iteritems(local_var_params['kwargs']): - if key not in all_params: - raise TypeError( - "Got an unexpected keyword argument '%s'" - " to method uninstall_stack" % key - ) - local_var_params[key] = val - del local_var_params['kwargs'] + self._check_operation_params('uninstall_stack', all_params, local_var_params) # verify the required parameter 'stack_id' is set if ('stack_id' not in local_var_params or local_var_params['stack_id'] is None): raise ValueError("Missing the required parameter `stack_id` when calling `uninstall_stack`") # noqa: E501 - collection_formats = {} - path_params = {} if 'stack_id' in local_var_params: path_params['stack_id'] = local_var_params['stack_id'] # noqa: E501 @@ -721,38 +827,12 @@ def uninstall_stack_with_http_info(self, stack_id, **kwargs): # noqa: E501,D401 header_params = {} - form_params = [] - local_var_files = {} - body_params = None # HTTP header `Accept` header_params['Accept'] = self.api_client.select_header_accept( ['application/json']) # noqa: E501 - # Authentication setting - auth_settings = [] # noqa: E501 - - # urlopen optional setting - urlopen_kw = None - if 'urlopen_kw' in kwargs: - urlopen_kw = kwargs['urlopen_kw'] - - return self.api_client.call_api( - '/api/v2/stacks/{stack_id}/uninstall', 'POST', - path_params, - query_params, - header_params, - body=body_params, - post_params=form_params, - files=local_var_files, - response_type='Stack', # noqa: E501 - auth_settings=auth_settings, - async_req=local_var_params.get('async_req'), - _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 - _preload_content=local_var_params.get('_preload_content', True), - _request_timeout=local_var_params.get('_request_timeout'), - collection_formats=collection_formats, - urlopen_kw=urlopen_kw) + return local_var_params, path_params, query_params, header_params, body_params def update_stack(self, stack_id, **kwargs): # noqa: E501,D401,D403 """Update a stack. @@ -791,30 +871,68 @@ def update_stack_with_http_info(self, stack_id, **kwargs): # noqa: E501,D401,D4 If the method is called asynchronously, returns the request thread. """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._update_stack_prepare(stack_id, **kwargs) + + return self.api_client.call_api( + '/api/v2/stacks/{stack_id}', 'PATCH', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='Stack', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + async def update_stack_async(self, stack_id, **kwargs): # noqa: E501,D401,D403 + """Update a stack. + + This method makes an asynchronous HTTP request. + + :param async_req bool + :param str stack_id: The identifier of the stack. (required) + :param PatchStackRequest patch_stack_request: + :return: Stack + If the method is called asynchronously, + returns the request thread. + """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._update_stack_prepare(stack_id, **kwargs) + + return await self.api_client.call_api( + '/api/v2/stacks/{stack_id}', 'PATCH', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='Stack', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + def _update_stack_prepare(self, stack_id, **kwargs): # noqa: E501,D401,D403 local_var_params = locals() all_params = ['stack_id', 'patch_stack_request'] # noqa: E501 - all_params.append('async_req') - all_params.append('_return_http_data_only') - all_params.append('_preload_content') - all_params.append('_request_timeout') - all_params.append('urlopen_kw') - - for key, val in six.iteritems(local_var_params['kwargs']): - if key not in all_params: - raise TypeError( - "Got an unexpected keyword argument '%s'" - " to method update_stack" % key - ) - local_var_params[key] = val - del local_var_params['kwargs'] + self._check_operation_params('update_stack', all_params, local_var_params) # verify the required parameter 'stack_id' is set if ('stack_id' not in local_var_params or local_var_params['stack_id'] is None): raise ValueError("Missing the required parameter `stack_id` when calling `update_stack`") # noqa: E501 - collection_formats = {} - path_params = {} if 'stack_id' in local_var_params: path_params['stack_id'] = local_var_params['stack_id'] # noqa: E501 @@ -823,9 +941,6 @@ def update_stack_with_http_info(self, stack_id, **kwargs): # noqa: E501,D401,D4 header_params = {} - form_params = [] - local_var_files = {} - body_params = None if 'patch_stack_request' in local_var_params: body_params = local_var_params['patch_stack_request'] @@ -837,27 +952,4 @@ def update_stack_with_http_info(self, stack_id, **kwargs): # noqa: E501,D401,D4 header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501 ['application/json']) # noqa: E501 - # Authentication setting - auth_settings = [] # noqa: E501 - - # urlopen optional setting - urlopen_kw = None - if 'urlopen_kw' in kwargs: - urlopen_kw = kwargs['urlopen_kw'] - - return self.api_client.call_api( - '/api/v2/stacks/{stack_id}', 'PATCH', - path_params, - query_params, - header_params, - body=body_params, - post_params=form_params, - files=local_var_files, - response_type='Stack', # noqa: E501 - auth_settings=auth_settings, - async_req=local_var_params.get('async_req'), - _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 - _preload_content=local_var_params.get('_preload_content', True), - _request_timeout=local_var_params.get('_request_timeout'), - collection_formats=collection_formats, - urlopen_kw=urlopen_kw) + return local_var_params, path_params, query_params, header_params, body_params diff --git a/influxdb_client/service/users_service.py b/influxdb_client/service/users_service.py index 814f95db..f5977f2d 100644 --- a/influxdb_client/service/users_service.py +++ b/influxdb_client/service/users_service.py @@ -14,11 +14,10 @@ import re # noqa: F401 -# python 2 and python 3 compatibility library -import six +from influxdb_client.service._base_service import _BaseService -class UsersService(object): +class UsersService(_BaseService): """NOTE: This class is auto generated by OpenAPI Generator. Ref: https://openapi-generator.tech @@ -69,30 +68,68 @@ def delete_users_id_with_http_info(self, user_id, **kwargs): # noqa: E501,D401, If the method is called asynchronously, returns the request thread. """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._delete_users_id_prepare(user_id, **kwargs) + + return self.api_client.call_api( + '/api/v2/users/{userID}', 'DELETE', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type=None, # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + async def delete_users_id_async(self, user_id, **kwargs): # noqa: E501,D401,D403 + """Delete a user. + + This method makes an asynchronous HTTP request. + + :param async_req bool + :param str user_id: The ID of the user to delete. (required) + :param str zap_trace_span: OpenTracing span context + :return: None + If the method is called asynchronously, + returns the request thread. + """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._delete_users_id_prepare(user_id, **kwargs) + + return await self.api_client.call_api( + '/api/v2/users/{userID}', 'DELETE', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type=None, # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + def _delete_users_id_prepare(self, user_id, **kwargs): # noqa: E501,D401,D403 local_var_params = locals() all_params = ['user_id', 'zap_trace_span'] # noqa: E501 - all_params.append('async_req') - all_params.append('_return_http_data_only') - all_params.append('_preload_content') - all_params.append('_request_timeout') - all_params.append('urlopen_kw') - - for key, val in six.iteritems(local_var_params['kwargs']): - if key not in all_params: - raise TypeError( - "Got an unexpected keyword argument '%s'" - " to method delete_users_id" % key - ) - local_var_params[key] = val - del local_var_params['kwargs'] + self._check_operation_params('delete_users_id', all_params, local_var_params) # verify the required parameter 'user_id' is set if ('user_id' not in local_var_params or local_var_params['user_id'] is None): raise ValueError("Missing the required parameter `user_id` when calling `delete_users_id`") # noqa: E501 - collection_formats = {} - path_params = {} if 'user_id' in local_var_params: path_params['userID'] = local_var_params['user_id'] # noqa: E501 @@ -103,38 +140,12 @@ def delete_users_id_with_http_info(self, user_id, **kwargs): # noqa: E501,D401, if 'zap_trace_span' in local_var_params: header_params['Zap-Trace-Span'] = local_var_params['zap_trace_span'] # noqa: E501 - form_params = [] - local_var_files = {} - body_params = None # HTTP header `Accept` header_params['Accept'] = self.api_client.select_header_accept( ['application/json']) # noqa: E501 - # Authentication setting - auth_settings = [] # noqa: E501 - - # urlopen optional setting - urlopen_kw = None - if 'urlopen_kw' in kwargs: - urlopen_kw = kwargs['urlopen_kw'] - - return self.api_client.call_api( - '/api/v2/users/{userID}', 'DELETE', - path_params, - query_params, - header_params, - body=body_params, - post_params=form_params, - files=local_var_files, - response_type=None, # noqa: E501 - auth_settings=auth_settings, - async_req=local_var_params.get('async_req'), - _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 - _preload_content=local_var_params.get('_preload_content', True), - _request_timeout=local_var_params.get('_request_timeout'), - collection_formats=collection_formats, - urlopen_kw=urlopen_kw) + return local_var_params, path_params, query_params, header_params, body_params def get_flags(self, **kwargs): # noqa: E501,D401,D403 """Return the feature flags for the currently authenticated user. @@ -171,25 +182,62 @@ def get_flags_with_http_info(self, **kwargs): # noqa: E501,D401,D403 If the method is called asynchronously, returns the request thread. """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._get_flags_prepare(**kwargs) + + return self.api_client.call_api( + '/api/v2/flags', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='dict(str, object)', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + async def get_flags_async(self, **kwargs): # noqa: E501,D401,D403 + """Return the feature flags for the currently authenticated user. + + This method makes an asynchronous HTTP request. + + :param async_req bool + :param str zap_trace_span: OpenTracing span context + :return: dict(str, object) + If the method is called asynchronously, + returns the request thread. + """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._get_flags_prepare(**kwargs) + + return await self.api_client.call_api( + '/api/v2/flags', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='dict(str, object)', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + def _get_flags_prepare(self, **kwargs): # noqa: E501,D401,D403 local_var_params = locals() all_params = ['zap_trace_span'] # noqa: E501 - all_params.append('async_req') - all_params.append('_return_http_data_only') - all_params.append('_preload_content') - all_params.append('_request_timeout') - all_params.append('urlopen_kw') - - for key, val in six.iteritems(local_var_params['kwargs']): - if key not in all_params: - raise TypeError( - "Got an unexpected keyword argument '%s'" - " to method get_flags" % key - ) - local_var_params[key] = val - del local_var_params['kwargs'] - - collection_formats = {} + self._check_operation_params('get_flags', all_params, local_var_params) path_params = {} @@ -199,38 +247,12 @@ def get_flags_with_http_info(self, **kwargs): # noqa: E501,D401,D403 if 'zap_trace_span' in local_var_params: header_params['Zap-Trace-Span'] = local_var_params['zap_trace_span'] # noqa: E501 - form_params = [] - local_var_files = {} - body_params = None # HTTP header `Accept` header_params['Accept'] = self.api_client.select_header_accept( ['application/json']) # noqa: E501 - # Authentication setting - auth_settings = [] # noqa: E501 - - # urlopen optional setting - urlopen_kw = None - if 'urlopen_kw' in kwargs: - urlopen_kw = kwargs['urlopen_kw'] - - return self.api_client.call_api( - '/api/v2/flags', 'GET', - path_params, - query_params, - header_params, - body=body_params, - post_params=form_params, - files=local_var_files, - response_type='dict(str, object)', # noqa: E501 - auth_settings=auth_settings, - async_req=local_var_params.get('async_req'), - _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 - _preload_content=local_var_params.get('_preload_content', True), - _request_timeout=local_var_params.get('_request_timeout'), - collection_formats=collection_formats, - urlopen_kw=urlopen_kw) + return local_var_params, path_params, query_params, header_params, body_params def get_me(self, **kwargs): # noqa: E501,D401,D403 """Retrieve the currently authenticated user. @@ -267,25 +289,62 @@ def get_me_with_http_info(self, **kwargs): # noqa: E501,D401,D403 If the method is called asynchronously, returns the request thread. """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._get_me_prepare(**kwargs) + + return self.api_client.call_api( + '/api/v2/me', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='UserResponse', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + async def get_me_async(self, **kwargs): # noqa: E501,D401,D403 + """Retrieve the currently authenticated user. + + This method makes an asynchronous HTTP request. + + :param async_req bool + :param str zap_trace_span: OpenTracing span context + :return: UserResponse + If the method is called asynchronously, + returns the request thread. + """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._get_me_prepare(**kwargs) + + return await self.api_client.call_api( + '/api/v2/me', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='UserResponse', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + def _get_me_prepare(self, **kwargs): # noqa: E501,D401,D403 local_var_params = locals() all_params = ['zap_trace_span'] # noqa: E501 - all_params.append('async_req') - all_params.append('_return_http_data_only') - all_params.append('_preload_content') - all_params.append('_request_timeout') - all_params.append('urlopen_kw') - - for key, val in six.iteritems(local_var_params['kwargs']): - if key not in all_params: - raise TypeError( - "Got an unexpected keyword argument '%s'" - " to method get_me" % key - ) - local_var_params[key] = val - del local_var_params['kwargs'] - - collection_formats = {} + self._check_operation_params('get_me', all_params, local_var_params) path_params = {} @@ -295,38 +354,12 @@ def get_me_with_http_info(self, **kwargs): # noqa: E501,D401,D403 if 'zap_trace_span' in local_var_params: header_params['Zap-Trace-Span'] = local_var_params['zap_trace_span'] # noqa: E501 - form_params = [] - local_var_files = {} - body_params = None # HTTP header `Accept` header_params['Accept'] = self.api_client.select_header_accept( ['application/json']) # noqa: E501 - # Authentication setting - auth_settings = [] # noqa: E501 - - # urlopen optional setting - urlopen_kw = None - if 'urlopen_kw' in kwargs: - urlopen_kw = kwargs['urlopen_kw'] - - return self.api_client.call_api( - '/api/v2/me', 'GET', - path_params, - query_params, - header_params, - body=body_params, - post_params=form_params, - files=local_var_files, - response_type='UserResponse', # noqa: E501 - auth_settings=auth_settings, - async_req=local_var_params.get('async_req'), - _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 - _preload_content=local_var_params.get('_preload_content', True), - _request_timeout=local_var_params.get('_request_timeout'), - collection_formats=collection_formats, - urlopen_kw=urlopen_kw) + return local_var_params, path_params, query_params, header_params, body_params def get_users(self, **kwargs): # noqa: E501,D401,D403 """List all users. @@ -373,23 +406,67 @@ def get_users_with_http_info(self, **kwargs): # noqa: E501,D401,D403 If the method is called asynchronously, returns the request thread. """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._get_users_prepare(**kwargs) + + return self.api_client.call_api( + '/api/v2/users', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='Users', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + async def get_users_async(self, **kwargs): # noqa: E501,D401,D403 + """List all users. + + This method makes an asynchronous HTTP request. + + :param async_req bool + :param str zap_trace_span: OpenTracing span context + :param int offset: + :param int limit: + :param str after: Resource ID to seek from. Results are not inclusive of this ID. Use `after` instead of `offset`. + :param str name: + :param str id: + :return: Users + If the method is called asynchronously, + returns the request thread. + """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._get_users_prepare(**kwargs) + + return await self.api_client.call_api( + '/api/v2/users', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='Users', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + def _get_users_prepare(self, **kwargs): # noqa: E501,D401,D403 local_var_params = locals() all_params = ['zap_trace_span', 'offset', 'limit', 'after', 'name', 'id'] # noqa: E501 - all_params.append('async_req') - all_params.append('_return_http_data_only') - all_params.append('_preload_content') - all_params.append('_request_timeout') - all_params.append('urlopen_kw') - - for key, val in six.iteritems(local_var_params['kwargs']): - if key not in all_params: - raise TypeError( - "Got an unexpected keyword argument '%s'" - " to method get_users" % key - ) - local_var_params[key] = val - del local_var_params['kwargs'] + self._check_operation_params('get_users', all_params, local_var_params) if 'offset' in local_var_params and local_var_params['offset'] < 0: # noqa: E501 raise ValueError("Invalid value for parameter `offset` when calling `get_users`, must be a value greater than or equal to `0`") # noqa: E501 @@ -397,8 +474,6 @@ def get_users_with_http_info(self, **kwargs): # noqa: E501,D401,D403 raise ValueError("Invalid value for parameter `limit` when calling `get_users`, must be a value less than or equal to `100`") # noqa: E501 if 'limit' in local_var_params and local_var_params['limit'] < 1: # noqa: E501 raise ValueError("Invalid value for parameter `limit` when calling `get_users`, must be a value greater than or equal to `1`") # noqa: E501 - collection_formats = {} - path_params = {} query_params = [] @@ -417,38 +492,12 @@ def get_users_with_http_info(self, **kwargs): # noqa: E501,D401,D403 if 'zap_trace_span' in local_var_params: header_params['Zap-Trace-Span'] = local_var_params['zap_trace_span'] # noqa: E501 - form_params = [] - local_var_files = {} - body_params = None # HTTP header `Accept` header_params['Accept'] = self.api_client.select_header_accept( ['application/json']) # noqa: E501 - # Authentication setting - auth_settings = [] # noqa: E501 - - # urlopen optional setting - urlopen_kw = None - if 'urlopen_kw' in kwargs: - urlopen_kw = kwargs['urlopen_kw'] - - return self.api_client.call_api( - '/api/v2/users', 'GET', - path_params, - query_params, - header_params, - body=body_params, - post_params=form_params, - files=local_var_files, - response_type='Users', # noqa: E501 - auth_settings=auth_settings, - async_req=local_var_params.get('async_req'), - _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 - _preload_content=local_var_params.get('_preload_content', True), - _request_timeout=local_var_params.get('_request_timeout'), - collection_formats=collection_formats, - urlopen_kw=urlopen_kw) + return local_var_params, path_params, query_params, header_params, body_params def get_users_id(self, user_id, **kwargs): # noqa: E501,D401,D403 """Retrieve a user. @@ -487,30 +536,68 @@ def get_users_id_with_http_info(self, user_id, **kwargs): # noqa: E501,D401,D40 If the method is called asynchronously, returns the request thread. """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._get_users_id_prepare(user_id, **kwargs) + + return self.api_client.call_api( + '/api/v2/users/{userID}', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='UserResponse', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + async def get_users_id_async(self, user_id, **kwargs): # noqa: E501,D401,D403 + """Retrieve a user. + + This method makes an asynchronous HTTP request. + + :param async_req bool + :param str user_id: The user ID. (required) + :param str zap_trace_span: OpenTracing span context + :return: UserResponse + If the method is called asynchronously, + returns the request thread. + """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._get_users_id_prepare(user_id, **kwargs) + + return await self.api_client.call_api( + '/api/v2/users/{userID}', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='UserResponse', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + def _get_users_id_prepare(self, user_id, **kwargs): # noqa: E501,D401,D403 local_var_params = locals() all_params = ['user_id', 'zap_trace_span'] # noqa: E501 - all_params.append('async_req') - all_params.append('_return_http_data_only') - all_params.append('_preload_content') - all_params.append('_request_timeout') - all_params.append('urlopen_kw') - - for key, val in six.iteritems(local_var_params['kwargs']): - if key not in all_params: - raise TypeError( - "Got an unexpected keyword argument '%s'" - " to method get_users_id" % key - ) - local_var_params[key] = val - del local_var_params['kwargs'] + self._check_operation_params('get_users_id', all_params, local_var_params) # verify the required parameter 'user_id' is set if ('user_id' not in local_var_params or local_var_params['user_id'] is None): raise ValueError("Missing the required parameter `user_id` when calling `get_users_id`") # noqa: E501 - collection_formats = {} - path_params = {} if 'user_id' in local_var_params: path_params['userID'] = local_var_params['user_id'] # noqa: E501 @@ -521,38 +608,12 @@ def get_users_id_with_http_info(self, user_id, **kwargs): # noqa: E501,D401,D40 if 'zap_trace_span' in local_var_params: header_params['Zap-Trace-Span'] = local_var_params['zap_trace_span'] # noqa: E501 - form_params = [] - local_var_files = {} - body_params = None # HTTP header `Accept` header_params['Accept'] = self.api_client.select_header_accept( ['application/json']) # noqa: E501 - # Authentication setting - auth_settings = [] # noqa: E501 - - # urlopen optional setting - urlopen_kw = None - if 'urlopen_kw' in kwargs: - urlopen_kw = kwargs['urlopen_kw'] - - return self.api_client.call_api( - '/api/v2/users/{userID}', 'GET', - path_params, - query_params, - header_params, - body=body_params, - post_params=form_params, - files=local_var_files, - response_type='UserResponse', # noqa: E501 - auth_settings=auth_settings, - async_req=local_var_params.get('async_req'), - _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 - _preload_content=local_var_params.get('_preload_content', True), - _request_timeout=local_var_params.get('_request_timeout'), - collection_formats=collection_formats, - urlopen_kw=urlopen_kw) + return local_var_params, path_params, query_params, header_params, body_params def patch_users_id(self, user_id, user, **kwargs): # noqa: E501,D401,D403 """Update a user. @@ -593,23 +654,64 @@ def patch_users_id_with_http_info(self, user_id, user, **kwargs): # noqa: E501, If the method is called asynchronously, returns the request thread. """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._patch_users_id_prepare(user_id, user, **kwargs) + + return self.api_client.call_api( + '/api/v2/users/{userID}', 'PATCH', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='UserResponse', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + async def patch_users_id_async(self, user_id, user, **kwargs): # noqa: E501,D401,D403 + """Update a user. + + This method makes an asynchronous HTTP request. + + :param async_req bool + :param str user_id: The ID of the user to update. (required) + :param User user: User update to apply (required) + :param str zap_trace_span: OpenTracing span context + :return: UserResponse + If the method is called asynchronously, + returns the request thread. + """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._patch_users_id_prepare(user_id, user, **kwargs) + + return await self.api_client.call_api( + '/api/v2/users/{userID}', 'PATCH', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='UserResponse', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + def _patch_users_id_prepare(self, user_id, user, **kwargs): # noqa: E501,D401,D403 local_var_params = locals() all_params = ['user_id', 'user', 'zap_trace_span'] # noqa: E501 - all_params.append('async_req') - all_params.append('_return_http_data_only') - all_params.append('_preload_content') - all_params.append('_request_timeout') - all_params.append('urlopen_kw') - - for key, val in six.iteritems(local_var_params['kwargs']): - if key not in all_params: - raise TypeError( - "Got an unexpected keyword argument '%s'" - " to method patch_users_id" % key - ) - local_var_params[key] = val - del local_var_params['kwargs'] + self._check_operation_params('patch_users_id', all_params, local_var_params) # verify the required parameter 'user_id' is set if ('user_id' not in local_var_params or local_var_params['user_id'] is None): @@ -619,8 +721,6 @@ def patch_users_id_with_http_info(self, user_id, user, **kwargs): # noqa: E501, local_var_params['user'] is None): raise ValueError("Missing the required parameter `user` when calling `patch_users_id`") # noqa: E501 - collection_formats = {} - path_params = {} if 'user_id' in local_var_params: path_params['userID'] = local_var_params['user_id'] # noqa: E501 @@ -631,9 +731,6 @@ def patch_users_id_with_http_info(self, user_id, user, **kwargs): # noqa: E501, if 'zap_trace_span' in local_var_params: header_params['Zap-Trace-Span'] = local_var_params['zap_trace_span'] # noqa: E501 - form_params = [] - local_var_files = {} - body_params = None if 'user' in local_var_params: body_params = local_var_params['user'] @@ -645,30 +742,7 @@ def patch_users_id_with_http_info(self, user_id, user, **kwargs): # noqa: E501, header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501 ['application/json']) # noqa: E501 - # Authentication setting - auth_settings = [] # noqa: E501 - - # urlopen optional setting - urlopen_kw = None - if 'urlopen_kw' in kwargs: - urlopen_kw = kwargs['urlopen_kw'] - - return self.api_client.call_api( - '/api/v2/users/{userID}', 'PATCH', - path_params, - query_params, - header_params, - body=body_params, - post_params=form_params, - files=local_var_files, - response_type='UserResponse', # noqa: E501 - auth_settings=auth_settings, - async_req=local_var_params.get('async_req'), - _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 - _preload_content=local_var_params.get('_preload_content', True), - _request_timeout=local_var_params.get('_request_timeout'), - collection_formats=collection_formats, - urlopen_kw=urlopen_kw) + return local_var_params, path_params, query_params, header_params, body_params def post_users(self, user, **kwargs): # noqa: E501,D401,D403 """Create a user. @@ -707,30 +781,68 @@ def post_users_with_http_info(self, user, **kwargs): # noqa: E501,D401,D403 If the method is called asynchronously, returns the request thread. """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._post_users_prepare(user, **kwargs) + + return self.api_client.call_api( + '/api/v2/users', 'POST', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='UserResponse', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + async def post_users_async(self, user, **kwargs): # noqa: E501,D401,D403 + """Create a user. + + This method makes an asynchronous HTTP request. + + :param async_req bool + :param User user: User to create (required) + :param str zap_trace_span: OpenTracing span context + :return: UserResponse + If the method is called asynchronously, + returns the request thread. + """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._post_users_prepare(user, **kwargs) + + return await self.api_client.call_api( + '/api/v2/users', 'POST', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='UserResponse', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + def _post_users_prepare(self, user, **kwargs): # noqa: E501,D401,D403 local_var_params = locals() all_params = ['user', 'zap_trace_span'] # noqa: E501 - all_params.append('async_req') - all_params.append('_return_http_data_only') - all_params.append('_preload_content') - all_params.append('_request_timeout') - all_params.append('urlopen_kw') - - for key, val in six.iteritems(local_var_params['kwargs']): - if key not in all_params: - raise TypeError( - "Got an unexpected keyword argument '%s'" - " to method post_users" % key - ) - local_var_params[key] = val - del local_var_params['kwargs'] + self._check_operation_params('post_users', all_params, local_var_params) # verify the required parameter 'user' is set if ('user' not in local_var_params or local_var_params['user'] is None): raise ValueError("Missing the required parameter `user` when calling `post_users`") # noqa: E501 - collection_formats = {} - path_params = {} query_params = [] @@ -739,9 +851,6 @@ def post_users_with_http_info(self, user, **kwargs): # noqa: E501,D401,D403 if 'zap_trace_span' in local_var_params: header_params['Zap-Trace-Span'] = local_var_params['zap_trace_span'] # noqa: E501 - form_params = [] - local_var_files = {} - body_params = None if 'user' in local_var_params: body_params = local_var_params['user'] @@ -753,30 +862,7 @@ def post_users_with_http_info(self, user, **kwargs): # noqa: E501,D401,D403 header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501 ['application/json']) # noqa: E501 - # Authentication setting - auth_settings = [] # noqa: E501 - - # urlopen optional setting - urlopen_kw = None - if 'urlopen_kw' in kwargs: - urlopen_kw = kwargs['urlopen_kw'] - - return self.api_client.call_api( - '/api/v2/users', 'POST', - path_params, - query_params, - header_params, - body=body_params, - post_params=form_params, - files=local_var_files, - response_type='UserResponse', # noqa: E501 - auth_settings=auth_settings, - async_req=local_var_params.get('async_req'), - _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 - _preload_content=local_var_params.get('_preload_content', True), - _request_timeout=local_var_params.get('_request_timeout'), - collection_formats=collection_formats, - urlopen_kw=urlopen_kw) + return local_var_params, path_params, query_params, header_params, body_params def post_users_id_password(self, user_id, password_reset_body, **kwargs): # noqa: E501,D401,D403 """Update a password. @@ -819,23 +905,65 @@ def post_users_id_password_with_http_info(self, user_id, password_reset_body, ** If the method is called asynchronously, returns the request thread. """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._post_users_id_password_prepare(user_id, password_reset_body, **kwargs) + + return self.api_client.call_api( + '/api/v2/users/{userID}/password', 'POST', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type=None, # noqa: E501 + auth_settings=['BasicAuthentication'], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + async def post_users_id_password_async(self, user_id, password_reset_body, **kwargs): # noqa: E501,D401,D403 + """Update a password. + + This method makes an asynchronous HTTP request. + + :param async_req bool + :param str user_id: The user ID. (required) + :param PasswordResetBody password_reset_body: New password (required) + :param str zap_trace_span: OpenTracing span context + :param str authorization: An auth credential for the Basic scheme + :return: None + If the method is called asynchronously, + returns the request thread. + """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._post_users_id_password_prepare(user_id, password_reset_body, **kwargs) + + return await self.api_client.call_api( + '/api/v2/users/{userID}/password', 'POST', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type=None, # noqa: E501 + auth_settings=['BasicAuthentication'], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + def _post_users_id_password_prepare(self, user_id, password_reset_body, **kwargs): # noqa: E501,D401,D403 local_var_params = locals() all_params = ['user_id', 'password_reset_body', 'zap_trace_span', 'authorization'] # noqa: E501 - all_params.append('async_req') - all_params.append('_return_http_data_only') - all_params.append('_preload_content') - all_params.append('_request_timeout') - all_params.append('urlopen_kw') - - for key, val in six.iteritems(local_var_params['kwargs']): - if key not in all_params: - raise TypeError( - "Got an unexpected keyword argument '%s'" - " to method post_users_id_password" % key - ) - local_var_params[key] = val - del local_var_params['kwargs'] + self._check_operation_params('post_users_id_password', all_params, local_var_params) # verify the required parameter 'user_id' is set if ('user_id' not in local_var_params or local_var_params['user_id'] is None): @@ -845,8 +973,6 @@ def post_users_id_password_with_http_info(self, user_id, password_reset_body, ** local_var_params['password_reset_body'] is None): raise ValueError("Missing the required parameter `password_reset_body` when calling `post_users_id_password`") # noqa: E501 - collection_formats = {} - path_params = {} if 'user_id' in local_var_params: path_params['userID'] = local_var_params['user_id'] # noqa: E501 @@ -859,9 +985,6 @@ def post_users_id_password_with_http_info(self, user_id, password_reset_body, ** if 'authorization' in local_var_params: header_params['Authorization'] = local_var_params['authorization'] # noqa: E501 - form_params = [] - local_var_files = {} - body_params = None if 'password_reset_body' in local_var_params: body_params = local_var_params['password_reset_body'] @@ -873,30 +996,7 @@ def post_users_id_password_with_http_info(self, user_id, password_reset_body, ** header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501 ['application/json']) # noqa: E501 - # Authentication setting - auth_settings = ['BasicAuthentication'] # noqa: E501 - - # urlopen optional setting - urlopen_kw = None - if 'urlopen_kw' in kwargs: - urlopen_kw = kwargs['urlopen_kw'] - - return self.api_client.call_api( - '/api/v2/users/{userID}/password', 'POST', - path_params, - query_params, - header_params, - body=body_params, - post_params=form_params, - files=local_var_files, - response_type=None, # noqa: E501 - auth_settings=auth_settings, - async_req=local_var_params.get('async_req'), - _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 - _preload_content=local_var_params.get('_preload_content', True), - _request_timeout=local_var_params.get('_request_timeout'), - collection_formats=collection_formats, - urlopen_kw=urlopen_kw) + return local_var_params, path_params, query_params, header_params, body_params def put_me_password(self, password_reset_body, **kwargs): # noqa: E501,D401,D403 """Update a password. @@ -937,30 +1037,69 @@ def put_me_password_with_http_info(self, password_reset_body, **kwargs): # noqa If the method is called asynchronously, returns the request thread. """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._put_me_password_prepare(password_reset_body, **kwargs) + + return self.api_client.call_api( + '/api/v2/me/password', 'PUT', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type=None, # noqa: E501 + auth_settings=['BasicAuthentication'], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + async def put_me_password_async(self, password_reset_body, **kwargs): # noqa: E501,D401,D403 + """Update a password. + + This method makes an asynchronous HTTP request. + + :param async_req bool + :param PasswordResetBody password_reset_body: New password (required) + :param str zap_trace_span: OpenTracing span context + :param str authorization: An auth credential for the Basic scheme + :return: None + If the method is called asynchronously, + returns the request thread. + """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._put_me_password_prepare(password_reset_body, **kwargs) + + return await self.api_client.call_api( + '/api/v2/me/password', 'PUT', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type=None, # noqa: E501 + auth_settings=['BasicAuthentication'], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + def _put_me_password_prepare(self, password_reset_body, **kwargs): # noqa: E501,D401,D403 local_var_params = locals() all_params = ['password_reset_body', 'zap_trace_span', 'authorization'] # noqa: E501 - all_params.append('async_req') - all_params.append('_return_http_data_only') - all_params.append('_preload_content') - all_params.append('_request_timeout') - all_params.append('urlopen_kw') - - for key, val in six.iteritems(local_var_params['kwargs']): - if key not in all_params: - raise TypeError( - "Got an unexpected keyword argument '%s'" - " to method put_me_password" % key - ) - local_var_params[key] = val - del local_var_params['kwargs'] + self._check_operation_params('put_me_password', all_params, local_var_params) # verify the required parameter 'password_reset_body' is set if ('password_reset_body' not in local_var_params or local_var_params['password_reset_body'] is None): raise ValueError("Missing the required parameter `password_reset_body` when calling `put_me_password`") # noqa: E501 - collection_formats = {} - path_params = {} query_params = [] @@ -971,9 +1110,6 @@ def put_me_password_with_http_info(self, password_reset_body, **kwargs): # noqa if 'authorization' in local_var_params: header_params['Authorization'] = local_var_params['authorization'] # noqa: E501 - form_params = [] - local_var_files = {} - body_params = None if 'password_reset_body' in local_var_params: body_params = local_var_params['password_reset_body'] @@ -985,27 +1121,4 @@ def put_me_password_with_http_info(self, password_reset_body, **kwargs): # noqa header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501 ['application/json']) # noqa: E501 - # Authentication setting - auth_settings = ['BasicAuthentication'] # noqa: E501 - - # urlopen optional setting - urlopen_kw = None - if 'urlopen_kw' in kwargs: - urlopen_kw = kwargs['urlopen_kw'] - - return self.api_client.call_api( - '/api/v2/me/password', 'PUT', - path_params, - query_params, - header_params, - body=body_params, - post_params=form_params, - files=local_var_files, - response_type=None, # noqa: E501 - auth_settings=auth_settings, - async_req=local_var_params.get('async_req'), - _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 - _preload_content=local_var_params.get('_preload_content', True), - _request_timeout=local_var_params.get('_request_timeout'), - collection_formats=collection_formats, - urlopen_kw=urlopen_kw) + return local_var_params, path_params, query_params, header_params, body_params diff --git a/influxdb_client/service/variables_service.py b/influxdb_client/service/variables_service.py index 25ddc260..8bd9c47a 100644 --- a/influxdb_client/service/variables_service.py +++ b/influxdb_client/service/variables_service.py @@ -14,11 +14,10 @@ import re # noqa: F401 -# python 2 and python 3 compatibility library -import six +from influxdb_client.service._base_service import _BaseService -class VariablesService(object): +class VariablesService(_BaseService): """NOTE: This class is auto generated by OpenAPI Generator. Ref: https://openapi-generator.tech @@ -69,30 +68,68 @@ def delete_variables_id_with_http_info(self, variable_id, **kwargs): # noqa: E5 If the method is called asynchronously, returns the request thread. """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._delete_variables_id_prepare(variable_id, **kwargs) + + return self.api_client.call_api( + '/api/v2/variables/{variableID}', 'DELETE', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type=None, # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + async def delete_variables_id_async(self, variable_id, **kwargs): # noqa: E501,D401,D403 + """Delete a variable. + + This method makes an asynchronous HTTP request. + + :param async_req bool + :param str variable_id: The variable ID. (required) + :param str zap_trace_span: OpenTracing span context + :return: None + If the method is called asynchronously, + returns the request thread. + """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._delete_variables_id_prepare(variable_id, **kwargs) + + return await self.api_client.call_api( + '/api/v2/variables/{variableID}', 'DELETE', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type=None, # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + def _delete_variables_id_prepare(self, variable_id, **kwargs): # noqa: E501,D401,D403 local_var_params = locals() all_params = ['variable_id', 'zap_trace_span'] # noqa: E501 - all_params.append('async_req') - all_params.append('_return_http_data_only') - all_params.append('_preload_content') - all_params.append('_request_timeout') - all_params.append('urlopen_kw') - - for key, val in six.iteritems(local_var_params['kwargs']): - if key not in all_params: - raise TypeError( - "Got an unexpected keyword argument '%s'" - " to method delete_variables_id" % key - ) - local_var_params[key] = val - del local_var_params['kwargs'] + self._check_operation_params('delete_variables_id', all_params, local_var_params) # verify the required parameter 'variable_id' is set if ('variable_id' not in local_var_params or local_var_params['variable_id'] is None): raise ValueError("Missing the required parameter `variable_id` when calling `delete_variables_id`") # noqa: E501 - collection_formats = {} - path_params = {} if 'variable_id' in local_var_params: path_params['variableID'] = local_var_params['variable_id'] # noqa: E501 @@ -103,38 +140,12 @@ def delete_variables_id_with_http_info(self, variable_id, **kwargs): # noqa: E5 if 'zap_trace_span' in local_var_params: header_params['Zap-Trace-Span'] = local_var_params['zap_trace_span'] # noqa: E501 - form_params = [] - local_var_files = {} - body_params = None # HTTP header `Accept` header_params['Accept'] = self.api_client.select_header_accept( ['application/json']) # noqa: E501 - # Authentication setting - auth_settings = [] # noqa: E501 - - # urlopen optional setting - urlopen_kw = None - if 'urlopen_kw' in kwargs: - urlopen_kw = kwargs['urlopen_kw'] - - return self.api_client.call_api( - '/api/v2/variables/{variableID}', 'DELETE', - path_params, - query_params, - header_params, - body=body_params, - post_params=form_params, - files=local_var_files, - response_type=None, # noqa: E501 - auth_settings=auth_settings, - async_req=local_var_params.get('async_req'), - _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 - _preload_content=local_var_params.get('_preload_content', True), - _request_timeout=local_var_params.get('_request_timeout'), - collection_formats=collection_formats, - urlopen_kw=urlopen_kw) + return local_var_params, path_params, query_params, header_params, body_params def delete_variables_id_labels_id(self, variable_id, label_id, **kwargs): # noqa: E501,D401,D403 """Delete a label from a variable. @@ -175,23 +186,64 @@ def delete_variables_id_labels_id_with_http_info(self, variable_id, label_id, ** If the method is called asynchronously, returns the request thread. """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._delete_variables_id_labels_id_prepare(variable_id, label_id, **kwargs) + + return self.api_client.call_api( + '/api/v2/variables/{variableID}/labels/{labelID}', 'DELETE', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type=None, # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + async def delete_variables_id_labels_id_async(self, variable_id, label_id, **kwargs): # noqa: E501,D401,D403 + """Delete a label from a variable. + + This method makes an asynchronous HTTP request. + + :param async_req bool + :param str variable_id: The variable ID. (required) + :param str label_id: The label ID to delete. (required) + :param str zap_trace_span: OpenTracing span context + :return: None + If the method is called asynchronously, + returns the request thread. + """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._delete_variables_id_labels_id_prepare(variable_id, label_id, **kwargs) + + return await self.api_client.call_api( + '/api/v2/variables/{variableID}/labels/{labelID}', 'DELETE', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type=None, # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + def _delete_variables_id_labels_id_prepare(self, variable_id, label_id, **kwargs): # noqa: E501,D401,D403 local_var_params = locals() all_params = ['variable_id', 'label_id', 'zap_trace_span'] # noqa: E501 - all_params.append('async_req') - all_params.append('_return_http_data_only') - all_params.append('_preload_content') - all_params.append('_request_timeout') - all_params.append('urlopen_kw') - - for key, val in six.iteritems(local_var_params['kwargs']): - if key not in all_params: - raise TypeError( - "Got an unexpected keyword argument '%s'" - " to method delete_variables_id_labels_id" % key - ) - local_var_params[key] = val - del local_var_params['kwargs'] + self._check_operation_params('delete_variables_id_labels_id', all_params, local_var_params) # verify the required parameter 'variable_id' is set if ('variable_id' not in local_var_params or local_var_params['variable_id'] is None): @@ -201,8 +253,6 @@ def delete_variables_id_labels_id_with_http_info(self, variable_id, label_id, ** local_var_params['label_id'] is None): raise ValueError("Missing the required parameter `label_id` when calling `delete_variables_id_labels_id`") # noqa: E501 - collection_formats = {} - path_params = {} if 'variable_id' in local_var_params: path_params['variableID'] = local_var_params['variable_id'] # noqa: E501 @@ -215,38 +265,12 @@ def delete_variables_id_labels_id_with_http_info(self, variable_id, label_id, ** if 'zap_trace_span' in local_var_params: header_params['Zap-Trace-Span'] = local_var_params['zap_trace_span'] # noqa: E501 - form_params = [] - local_var_files = {} - body_params = None # HTTP header `Accept` header_params['Accept'] = self.api_client.select_header_accept( ['application/json']) # noqa: E501 - # Authentication setting - auth_settings = [] # noqa: E501 - - # urlopen optional setting - urlopen_kw = None - if 'urlopen_kw' in kwargs: - urlopen_kw = kwargs['urlopen_kw'] - - return self.api_client.call_api( - '/api/v2/variables/{variableID}/labels/{labelID}', 'DELETE', - path_params, - query_params, - header_params, - body=body_params, - post_params=form_params, - files=local_var_files, - response_type=None, # noqa: E501 - auth_settings=auth_settings, - async_req=local_var_params.get('async_req'), - _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 - _preload_content=local_var_params.get('_preload_content', True), - _request_timeout=local_var_params.get('_request_timeout'), - collection_formats=collection_formats, - urlopen_kw=urlopen_kw) + return local_var_params, path_params, query_params, header_params, body_params def get_variables(self, **kwargs): # noqa: E501,D401,D403 """List all variables. @@ -287,25 +311,64 @@ def get_variables_with_http_info(self, **kwargs): # noqa: E501,D401,D403 If the method is called asynchronously, returns the request thread. """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._get_variables_prepare(**kwargs) + + return self.api_client.call_api( + '/api/v2/variables', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='Variables', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + async def get_variables_async(self, **kwargs): # noqa: E501,D401,D403 + """List all variables. + + This method makes an asynchronous HTTP request. + + :param async_req bool + :param str zap_trace_span: OpenTracing span context + :param str org: The name of the organization. + :param str org_id: The organization ID. + :return: Variables + If the method is called asynchronously, + returns the request thread. + """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._get_variables_prepare(**kwargs) + + return await self.api_client.call_api( + '/api/v2/variables', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='Variables', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + def _get_variables_prepare(self, **kwargs): # noqa: E501,D401,D403 local_var_params = locals() all_params = ['zap_trace_span', 'org', 'org_id'] # noqa: E501 - all_params.append('async_req') - all_params.append('_return_http_data_only') - all_params.append('_preload_content') - all_params.append('_request_timeout') - all_params.append('urlopen_kw') - - for key, val in six.iteritems(local_var_params['kwargs']): - if key not in all_params: - raise TypeError( - "Got an unexpected keyword argument '%s'" - " to method get_variables" % key - ) - local_var_params[key] = val - del local_var_params['kwargs'] - - collection_formats = {} + self._check_operation_params('get_variables', all_params, local_var_params) path_params = {} @@ -319,38 +382,12 @@ def get_variables_with_http_info(self, **kwargs): # noqa: E501,D401,D403 if 'zap_trace_span' in local_var_params: header_params['Zap-Trace-Span'] = local_var_params['zap_trace_span'] # noqa: E501 - form_params = [] - local_var_files = {} - body_params = None # HTTP header `Accept` header_params['Accept'] = self.api_client.select_header_accept( ['application/json']) # noqa: E501 - # Authentication setting - auth_settings = [] # noqa: E501 - - # urlopen optional setting - urlopen_kw = None - if 'urlopen_kw' in kwargs: - urlopen_kw = kwargs['urlopen_kw'] - - return self.api_client.call_api( - '/api/v2/variables', 'GET', - path_params, - query_params, - header_params, - body=body_params, - post_params=form_params, - files=local_var_files, - response_type='Variables', # noqa: E501 - auth_settings=auth_settings, - async_req=local_var_params.get('async_req'), - _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 - _preload_content=local_var_params.get('_preload_content', True), - _request_timeout=local_var_params.get('_request_timeout'), - collection_formats=collection_formats, - urlopen_kw=urlopen_kw) + return local_var_params, path_params, query_params, header_params, body_params def get_variables_id(self, variable_id, **kwargs): # noqa: E501,D401,D403 """Retrieve a variable. @@ -389,30 +426,68 @@ def get_variables_id_with_http_info(self, variable_id, **kwargs): # noqa: E501, If the method is called asynchronously, returns the request thread. """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._get_variables_id_prepare(variable_id, **kwargs) + + return self.api_client.call_api( + '/api/v2/variables/{variableID}', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='Variable', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + async def get_variables_id_async(self, variable_id, **kwargs): # noqa: E501,D401,D403 + """Retrieve a variable. + + This method makes an asynchronous HTTP request. + + :param async_req bool + :param str variable_id: The variable ID. (required) + :param str zap_trace_span: OpenTracing span context + :return: Variable + If the method is called asynchronously, + returns the request thread. + """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._get_variables_id_prepare(variable_id, **kwargs) + + return await self.api_client.call_api( + '/api/v2/variables/{variableID}', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='Variable', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + def _get_variables_id_prepare(self, variable_id, **kwargs): # noqa: E501,D401,D403 local_var_params = locals() all_params = ['variable_id', 'zap_trace_span'] # noqa: E501 - all_params.append('async_req') - all_params.append('_return_http_data_only') - all_params.append('_preload_content') - all_params.append('_request_timeout') - all_params.append('urlopen_kw') - - for key, val in six.iteritems(local_var_params['kwargs']): - if key not in all_params: - raise TypeError( - "Got an unexpected keyword argument '%s'" - " to method get_variables_id" % key - ) - local_var_params[key] = val - del local_var_params['kwargs'] + self._check_operation_params('get_variables_id', all_params, local_var_params) # verify the required parameter 'variable_id' is set if ('variable_id' not in local_var_params or local_var_params['variable_id'] is None): raise ValueError("Missing the required parameter `variable_id` when calling `get_variables_id`") # noqa: E501 - collection_formats = {} - path_params = {} if 'variable_id' in local_var_params: path_params['variableID'] = local_var_params['variable_id'] # noqa: E501 @@ -423,38 +498,12 @@ def get_variables_id_with_http_info(self, variable_id, **kwargs): # noqa: E501, if 'zap_trace_span' in local_var_params: header_params['Zap-Trace-Span'] = local_var_params['zap_trace_span'] # noqa: E501 - form_params = [] - local_var_files = {} - body_params = None # HTTP header `Accept` header_params['Accept'] = self.api_client.select_header_accept( ['application/json']) # noqa: E501 - # Authentication setting - auth_settings = [] # noqa: E501 - - # urlopen optional setting - urlopen_kw = None - if 'urlopen_kw' in kwargs: - urlopen_kw = kwargs['urlopen_kw'] - - return self.api_client.call_api( - '/api/v2/variables/{variableID}', 'GET', - path_params, - query_params, - header_params, - body=body_params, - post_params=form_params, - files=local_var_files, - response_type='Variable', # noqa: E501 - auth_settings=auth_settings, - async_req=local_var_params.get('async_req'), - _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 - _preload_content=local_var_params.get('_preload_content', True), - _request_timeout=local_var_params.get('_request_timeout'), - collection_formats=collection_formats, - urlopen_kw=urlopen_kw) + return local_var_params, path_params, query_params, header_params, body_params def get_variables_id_labels(self, variable_id, **kwargs): # noqa: E501,D401,D403 """List all labels for a variable. @@ -493,30 +542,68 @@ def get_variables_id_labels_with_http_info(self, variable_id, **kwargs): # noqa If the method is called asynchronously, returns the request thread. """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._get_variables_id_labels_prepare(variable_id, **kwargs) + + return self.api_client.call_api( + '/api/v2/variables/{variableID}/labels', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='LabelsResponse', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + async def get_variables_id_labels_async(self, variable_id, **kwargs): # noqa: E501,D401,D403 + """List all labels for a variable. + + This method makes an asynchronous HTTP request. + + :param async_req bool + :param str variable_id: The variable ID. (required) + :param str zap_trace_span: OpenTracing span context + :return: LabelsResponse + If the method is called asynchronously, + returns the request thread. + """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._get_variables_id_labels_prepare(variable_id, **kwargs) + + return await self.api_client.call_api( + '/api/v2/variables/{variableID}/labels', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='LabelsResponse', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + def _get_variables_id_labels_prepare(self, variable_id, **kwargs): # noqa: E501,D401,D403 local_var_params = locals() all_params = ['variable_id', 'zap_trace_span'] # noqa: E501 - all_params.append('async_req') - all_params.append('_return_http_data_only') - all_params.append('_preload_content') - all_params.append('_request_timeout') - all_params.append('urlopen_kw') - - for key, val in six.iteritems(local_var_params['kwargs']): - if key not in all_params: - raise TypeError( - "Got an unexpected keyword argument '%s'" - " to method get_variables_id_labels" % key - ) - local_var_params[key] = val - del local_var_params['kwargs'] + self._check_operation_params('get_variables_id_labels', all_params, local_var_params) # verify the required parameter 'variable_id' is set if ('variable_id' not in local_var_params or local_var_params['variable_id'] is None): raise ValueError("Missing the required parameter `variable_id` when calling `get_variables_id_labels`") # noqa: E501 - collection_formats = {} - path_params = {} if 'variable_id' in local_var_params: path_params['variableID'] = local_var_params['variable_id'] # noqa: E501 @@ -527,38 +614,12 @@ def get_variables_id_labels_with_http_info(self, variable_id, **kwargs): # noqa if 'zap_trace_span' in local_var_params: header_params['Zap-Trace-Span'] = local_var_params['zap_trace_span'] # noqa: E501 - form_params = [] - local_var_files = {} - body_params = None # HTTP header `Accept` header_params['Accept'] = self.api_client.select_header_accept( ['application/json']) # noqa: E501 - # Authentication setting - auth_settings = [] # noqa: E501 - - # urlopen optional setting - urlopen_kw = None - if 'urlopen_kw' in kwargs: - urlopen_kw = kwargs['urlopen_kw'] - - return self.api_client.call_api( - '/api/v2/variables/{variableID}/labels', 'GET', - path_params, - query_params, - header_params, - body=body_params, - post_params=form_params, - files=local_var_files, - response_type='LabelsResponse', # noqa: E501 - auth_settings=auth_settings, - async_req=local_var_params.get('async_req'), - _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 - _preload_content=local_var_params.get('_preload_content', True), - _request_timeout=local_var_params.get('_request_timeout'), - collection_formats=collection_formats, - urlopen_kw=urlopen_kw) + return local_var_params, path_params, query_params, header_params, body_params def patch_variables_id(self, variable_id, variable, **kwargs): # noqa: E501,D401,D403 """Update a variable. @@ -599,23 +660,64 @@ def patch_variables_id_with_http_info(self, variable_id, variable, **kwargs): # If the method is called asynchronously, returns the request thread. """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._patch_variables_id_prepare(variable_id, variable, **kwargs) + + return self.api_client.call_api( + '/api/v2/variables/{variableID}', 'PATCH', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='Variable', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + async def patch_variables_id_async(self, variable_id, variable, **kwargs): # noqa: E501,D401,D403 + """Update a variable. + + This method makes an asynchronous HTTP request. + + :param async_req bool + :param str variable_id: The variable ID. (required) + :param Variable variable: Variable update to apply (required) + :param str zap_trace_span: OpenTracing span context + :return: Variable + If the method is called asynchronously, + returns the request thread. + """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._patch_variables_id_prepare(variable_id, variable, **kwargs) + + return await self.api_client.call_api( + '/api/v2/variables/{variableID}', 'PATCH', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='Variable', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + def _patch_variables_id_prepare(self, variable_id, variable, **kwargs): # noqa: E501,D401,D403 local_var_params = locals() all_params = ['variable_id', 'variable', 'zap_trace_span'] # noqa: E501 - all_params.append('async_req') - all_params.append('_return_http_data_only') - all_params.append('_preload_content') - all_params.append('_request_timeout') - all_params.append('urlopen_kw') - - for key, val in six.iteritems(local_var_params['kwargs']): - if key not in all_params: - raise TypeError( - "Got an unexpected keyword argument '%s'" - " to method patch_variables_id" % key - ) - local_var_params[key] = val - del local_var_params['kwargs'] + self._check_operation_params('patch_variables_id', all_params, local_var_params) # verify the required parameter 'variable_id' is set if ('variable_id' not in local_var_params or local_var_params['variable_id'] is None): @@ -625,8 +727,6 @@ def patch_variables_id_with_http_info(self, variable_id, variable, **kwargs): # local_var_params['variable'] is None): raise ValueError("Missing the required parameter `variable` when calling `patch_variables_id`") # noqa: E501 - collection_formats = {} - path_params = {} if 'variable_id' in local_var_params: path_params['variableID'] = local_var_params['variable_id'] # noqa: E501 @@ -637,9 +737,6 @@ def patch_variables_id_with_http_info(self, variable_id, variable, **kwargs): # if 'zap_trace_span' in local_var_params: header_params['Zap-Trace-Span'] = local_var_params['zap_trace_span'] # noqa: E501 - form_params = [] - local_var_files = {} - body_params = None if 'variable' in local_var_params: body_params = local_var_params['variable'] @@ -651,30 +748,7 @@ def patch_variables_id_with_http_info(self, variable_id, variable, **kwargs): # header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501 ['application/json']) # noqa: E501 - # Authentication setting - auth_settings = [] # noqa: E501 - - # urlopen optional setting - urlopen_kw = None - if 'urlopen_kw' in kwargs: - urlopen_kw = kwargs['urlopen_kw'] - - return self.api_client.call_api( - '/api/v2/variables/{variableID}', 'PATCH', - path_params, - query_params, - header_params, - body=body_params, - post_params=form_params, - files=local_var_files, - response_type='Variable', # noqa: E501 - auth_settings=auth_settings, - async_req=local_var_params.get('async_req'), - _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 - _preload_content=local_var_params.get('_preload_content', True), - _request_timeout=local_var_params.get('_request_timeout'), - collection_formats=collection_formats, - urlopen_kw=urlopen_kw) + return local_var_params, path_params, query_params, header_params, body_params def post_variables(self, variable, **kwargs): # noqa: E501,D401,D403 """Create a variable. @@ -713,30 +787,68 @@ def post_variables_with_http_info(self, variable, **kwargs): # noqa: E501,D401, If the method is called asynchronously, returns the request thread. """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._post_variables_prepare(variable, **kwargs) + + return self.api_client.call_api( + '/api/v2/variables', 'POST', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='Variable', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + async def post_variables_async(self, variable, **kwargs): # noqa: E501,D401,D403 + """Create a variable. + + This method makes an asynchronous HTTP request. + + :param async_req bool + :param Variable variable: Variable to create (required) + :param str zap_trace_span: OpenTracing span context + :return: Variable + If the method is called asynchronously, + returns the request thread. + """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._post_variables_prepare(variable, **kwargs) + + return await self.api_client.call_api( + '/api/v2/variables', 'POST', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='Variable', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + def _post_variables_prepare(self, variable, **kwargs): # noqa: E501,D401,D403 local_var_params = locals() all_params = ['variable', 'zap_trace_span'] # noqa: E501 - all_params.append('async_req') - all_params.append('_return_http_data_only') - all_params.append('_preload_content') - all_params.append('_request_timeout') - all_params.append('urlopen_kw') - - for key, val in six.iteritems(local_var_params['kwargs']): - if key not in all_params: - raise TypeError( - "Got an unexpected keyword argument '%s'" - " to method post_variables" % key - ) - local_var_params[key] = val - del local_var_params['kwargs'] + self._check_operation_params('post_variables', all_params, local_var_params) # verify the required parameter 'variable' is set if ('variable' not in local_var_params or local_var_params['variable'] is None): raise ValueError("Missing the required parameter `variable` when calling `post_variables`") # noqa: E501 - collection_formats = {} - path_params = {} query_params = [] @@ -745,9 +857,6 @@ def post_variables_with_http_info(self, variable, **kwargs): # noqa: E501,D401, if 'zap_trace_span' in local_var_params: header_params['Zap-Trace-Span'] = local_var_params['zap_trace_span'] # noqa: E501 - form_params = [] - local_var_files = {} - body_params = None if 'variable' in local_var_params: body_params = local_var_params['variable'] @@ -759,30 +868,7 @@ def post_variables_with_http_info(self, variable, **kwargs): # noqa: E501,D401, header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501 ['application/json']) # noqa: E501 - # Authentication setting - auth_settings = [] # noqa: E501 - - # urlopen optional setting - urlopen_kw = None - if 'urlopen_kw' in kwargs: - urlopen_kw = kwargs['urlopen_kw'] - - return self.api_client.call_api( - '/api/v2/variables', 'POST', - path_params, - query_params, - header_params, - body=body_params, - post_params=form_params, - files=local_var_files, - response_type='Variable', # noqa: E501 - auth_settings=auth_settings, - async_req=local_var_params.get('async_req'), - _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 - _preload_content=local_var_params.get('_preload_content', True), - _request_timeout=local_var_params.get('_request_timeout'), - collection_formats=collection_formats, - urlopen_kw=urlopen_kw) + return local_var_params, path_params, query_params, header_params, body_params def post_variables_id_labels(self, variable_id, label_mapping, **kwargs): # noqa: E501,D401,D403 """Add a label to a variable. @@ -823,23 +909,64 @@ def post_variables_id_labels_with_http_info(self, variable_id, label_mapping, ** If the method is called asynchronously, returns the request thread. """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._post_variables_id_labels_prepare(variable_id, label_mapping, **kwargs) + + return self.api_client.call_api( + '/api/v2/variables/{variableID}/labels', 'POST', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='LabelResponse', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + async def post_variables_id_labels_async(self, variable_id, label_mapping, **kwargs): # noqa: E501,D401,D403 + """Add a label to a variable. + + This method makes an asynchronous HTTP request. + + :param async_req bool + :param str variable_id: The variable ID. (required) + :param LabelMapping label_mapping: Label to add (required) + :param str zap_trace_span: OpenTracing span context + :return: LabelResponse + If the method is called asynchronously, + returns the request thread. + """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._post_variables_id_labels_prepare(variable_id, label_mapping, **kwargs) + + return await self.api_client.call_api( + '/api/v2/variables/{variableID}/labels', 'POST', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='LabelResponse', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + def _post_variables_id_labels_prepare(self, variable_id, label_mapping, **kwargs): # noqa: E501,D401,D403 local_var_params = locals() all_params = ['variable_id', 'label_mapping', 'zap_trace_span'] # noqa: E501 - all_params.append('async_req') - all_params.append('_return_http_data_only') - all_params.append('_preload_content') - all_params.append('_request_timeout') - all_params.append('urlopen_kw') - - for key, val in six.iteritems(local_var_params['kwargs']): - if key not in all_params: - raise TypeError( - "Got an unexpected keyword argument '%s'" - " to method post_variables_id_labels" % key - ) - local_var_params[key] = val - del local_var_params['kwargs'] + self._check_operation_params('post_variables_id_labels', all_params, local_var_params) # verify the required parameter 'variable_id' is set if ('variable_id' not in local_var_params or local_var_params['variable_id'] is None): @@ -849,8 +976,6 @@ def post_variables_id_labels_with_http_info(self, variable_id, label_mapping, ** local_var_params['label_mapping'] is None): raise ValueError("Missing the required parameter `label_mapping` when calling `post_variables_id_labels`") # noqa: E501 - collection_formats = {} - path_params = {} if 'variable_id' in local_var_params: path_params['variableID'] = local_var_params['variable_id'] # noqa: E501 @@ -861,9 +986,6 @@ def post_variables_id_labels_with_http_info(self, variable_id, label_mapping, ** if 'zap_trace_span' in local_var_params: header_params['Zap-Trace-Span'] = local_var_params['zap_trace_span'] # noqa: E501 - form_params = [] - local_var_files = {} - body_params = None if 'label_mapping' in local_var_params: body_params = local_var_params['label_mapping'] @@ -875,30 +997,7 @@ def post_variables_id_labels_with_http_info(self, variable_id, label_mapping, ** header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501 ['application/json']) # noqa: E501 - # Authentication setting - auth_settings = [] # noqa: E501 - - # urlopen optional setting - urlopen_kw = None - if 'urlopen_kw' in kwargs: - urlopen_kw = kwargs['urlopen_kw'] - - return self.api_client.call_api( - '/api/v2/variables/{variableID}/labels', 'POST', - path_params, - query_params, - header_params, - body=body_params, - post_params=form_params, - files=local_var_files, - response_type='LabelResponse', # noqa: E501 - auth_settings=auth_settings, - async_req=local_var_params.get('async_req'), - _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 - _preload_content=local_var_params.get('_preload_content', True), - _request_timeout=local_var_params.get('_request_timeout'), - collection_formats=collection_formats, - urlopen_kw=urlopen_kw) + return local_var_params, path_params, query_params, header_params, body_params def put_variables_id(self, variable_id, variable, **kwargs): # noqa: E501,D401,D403 """Replace a variable. @@ -939,23 +1038,64 @@ def put_variables_id_with_http_info(self, variable_id, variable, **kwargs): # n If the method is called asynchronously, returns the request thread. """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._put_variables_id_prepare(variable_id, variable, **kwargs) + + return self.api_client.call_api( + '/api/v2/variables/{variableID}', 'PUT', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='Variable', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + async def put_variables_id_async(self, variable_id, variable, **kwargs): # noqa: E501,D401,D403 + """Replace a variable. + + This method makes an asynchronous HTTP request. + + :param async_req bool + :param str variable_id: The variable ID. (required) + :param Variable variable: Variable to replace (required) + :param str zap_trace_span: OpenTracing span context + :return: Variable + If the method is called asynchronously, + returns the request thread. + """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._put_variables_id_prepare(variable_id, variable, **kwargs) + + return await self.api_client.call_api( + '/api/v2/variables/{variableID}', 'PUT', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='Variable', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + def _put_variables_id_prepare(self, variable_id, variable, **kwargs): # noqa: E501,D401,D403 local_var_params = locals() all_params = ['variable_id', 'variable', 'zap_trace_span'] # noqa: E501 - all_params.append('async_req') - all_params.append('_return_http_data_only') - all_params.append('_preload_content') - all_params.append('_request_timeout') - all_params.append('urlopen_kw') - - for key, val in six.iteritems(local_var_params['kwargs']): - if key not in all_params: - raise TypeError( - "Got an unexpected keyword argument '%s'" - " to method put_variables_id" % key - ) - local_var_params[key] = val - del local_var_params['kwargs'] + self._check_operation_params('put_variables_id', all_params, local_var_params) # verify the required parameter 'variable_id' is set if ('variable_id' not in local_var_params or local_var_params['variable_id'] is None): @@ -965,8 +1105,6 @@ def put_variables_id_with_http_info(self, variable_id, variable, **kwargs): # n local_var_params['variable'] is None): raise ValueError("Missing the required parameter `variable` when calling `put_variables_id`") # noqa: E501 - collection_formats = {} - path_params = {} if 'variable_id' in local_var_params: path_params['variableID'] = local_var_params['variable_id'] # noqa: E501 @@ -977,9 +1115,6 @@ def put_variables_id_with_http_info(self, variable_id, variable, **kwargs): # n if 'zap_trace_span' in local_var_params: header_params['Zap-Trace-Span'] = local_var_params['zap_trace_span'] # noqa: E501 - form_params = [] - local_var_files = {} - body_params = None if 'variable' in local_var_params: body_params = local_var_params['variable'] @@ -991,27 +1126,4 @@ def put_variables_id_with_http_info(self, variable_id, variable, **kwargs): # n header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501 ['application/json']) # noqa: E501 - # Authentication setting - auth_settings = [] # noqa: E501 - - # urlopen optional setting - urlopen_kw = None - if 'urlopen_kw' in kwargs: - urlopen_kw = kwargs['urlopen_kw'] - - return self.api_client.call_api( - '/api/v2/variables/{variableID}', 'PUT', - path_params, - query_params, - header_params, - body=body_params, - post_params=form_params, - files=local_var_files, - response_type='Variable', # noqa: E501 - auth_settings=auth_settings, - async_req=local_var_params.get('async_req'), - _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 - _preload_content=local_var_params.get('_preload_content', True), - _request_timeout=local_var_params.get('_request_timeout'), - collection_formats=collection_formats, - urlopen_kw=urlopen_kw) + return local_var_params, path_params, query_params, header_params, body_params diff --git a/influxdb_client/service/views_service.py b/influxdb_client/service/views_service.py index bb39417c..4431db11 100644 --- a/influxdb_client/service/views_service.py +++ b/influxdb_client/service/views_service.py @@ -14,11 +14,10 @@ import re # noqa: F401 -# python 2 and python 3 compatibility library -import six +from influxdb_client.service._base_service import _BaseService -class ViewsService(object): +class ViewsService(_BaseService): """NOTE: This class is auto generated by OpenAPI Generator. Ref: https://openapi-generator.tech @@ -71,23 +70,64 @@ def get_dashboards_id_cells_id_view_with_http_info(self, dashboard_id, cell_id, If the method is called asynchronously, returns the request thread. """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._get_dashboards_id_cells_id_view_prepare(dashboard_id, cell_id, **kwargs) + + return self.api_client.call_api( + '/api/v2/dashboards/{dashboardID}/cells/{cellID}/view', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='View', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + async def get_dashboards_id_cells_id_view_async(self, dashboard_id, cell_id, **kwargs): # noqa: E501,D401,D403 + """Retrieve the view for a cell. + + This method makes an asynchronous HTTP request. + + :param async_req bool + :param str dashboard_id: The dashboard ID. (required) + :param str cell_id: The cell ID. (required) + :param str zap_trace_span: OpenTracing span context + :return: View + If the method is called asynchronously, + returns the request thread. + """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._get_dashboards_id_cells_id_view_prepare(dashboard_id, cell_id, **kwargs) + + return await self.api_client.call_api( + '/api/v2/dashboards/{dashboardID}/cells/{cellID}/view', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='View', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + def _get_dashboards_id_cells_id_view_prepare(self, dashboard_id, cell_id, **kwargs): # noqa: E501,D401,D403 local_var_params = locals() all_params = ['dashboard_id', 'cell_id', 'zap_trace_span'] # noqa: E501 - all_params.append('async_req') - all_params.append('_return_http_data_only') - all_params.append('_preload_content') - all_params.append('_request_timeout') - all_params.append('urlopen_kw') - - for key, val in six.iteritems(local_var_params['kwargs']): - if key not in all_params: - raise TypeError( - "Got an unexpected keyword argument '%s'" - " to method get_dashboards_id_cells_id_view" % key - ) - local_var_params[key] = val - del local_var_params['kwargs'] + self._check_operation_params('get_dashboards_id_cells_id_view', all_params, local_var_params) # verify the required parameter 'dashboard_id' is set if ('dashboard_id' not in local_var_params or local_var_params['dashboard_id'] is None): @@ -97,8 +137,6 @@ def get_dashboards_id_cells_id_view_with_http_info(self, dashboard_id, cell_id, local_var_params['cell_id'] is None): raise ValueError("Missing the required parameter `cell_id` when calling `get_dashboards_id_cells_id_view`") # noqa: E501 - collection_formats = {} - path_params = {} if 'dashboard_id' in local_var_params: path_params['dashboardID'] = local_var_params['dashboard_id'] # noqa: E501 @@ -111,38 +149,12 @@ def get_dashboards_id_cells_id_view_with_http_info(self, dashboard_id, cell_id, if 'zap_trace_span' in local_var_params: header_params['Zap-Trace-Span'] = local_var_params['zap_trace_span'] # noqa: E501 - form_params = [] - local_var_files = {} - body_params = None # HTTP header `Accept` header_params['Accept'] = self.api_client.select_header_accept( ['application/json']) # noqa: E501 - # Authentication setting - auth_settings = [] # noqa: E501 - - # urlopen optional setting - urlopen_kw = None - if 'urlopen_kw' in kwargs: - urlopen_kw = kwargs['urlopen_kw'] - - return self.api_client.call_api( - '/api/v2/dashboards/{dashboardID}/cells/{cellID}/view', 'GET', - path_params, - query_params, - header_params, - body=body_params, - post_params=form_params, - files=local_var_files, - response_type='View', # noqa: E501 - auth_settings=auth_settings, - async_req=local_var_params.get('async_req'), - _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 - _preload_content=local_var_params.get('_preload_content', True), - _request_timeout=local_var_params.get('_request_timeout'), - collection_formats=collection_formats, - urlopen_kw=urlopen_kw) + return local_var_params, path_params, query_params, header_params, body_params def patch_dashboards_id_cells_id_view(self, dashboard_id, cell_id, view, **kwargs): # noqa: E501,D401,D403 """Update the view for a cell. @@ -185,23 +197,65 @@ def patch_dashboards_id_cells_id_view_with_http_info(self, dashboard_id, cell_id If the method is called asynchronously, returns the request thread. """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._patch_dashboards_id_cells_id_view_prepare(dashboard_id, cell_id, view, **kwargs) + + return self.api_client.call_api( + '/api/v2/dashboards/{dashboardID}/cells/{cellID}/view', 'PATCH', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='View', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + async def patch_dashboards_id_cells_id_view_async(self, dashboard_id, cell_id, view, **kwargs): # noqa: E501,D401,D403 + """Update the view for a cell. + + This method makes an asynchronous HTTP request. + + :param async_req bool + :param str dashboard_id: The ID of the dashboard to update. (required) + :param str cell_id: The ID of the cell to update. (required) + :param View view: (required) + :param str zap_trace_span: OpenTracing span context + :return: View + If the method is called asynchronously, + returns the request thread. + """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._patch_dashboards_id_cells_id_view_prepare(dashboard_id, cell_id, view, **kwargs) + + return await self.api_client.call_api( + '/api/v2/dashboards/{dashboardID}/cells/{cellID}/view', 'PATCH', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type='View', # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + def _patch_dashboards_id_cells_id_view_prepare(self, dashboard_id, cell_id, view, **kwargs): # noqa: E501,D401,D403 local_var_params = locals() all_params = ['dashboard_id', 'cell_id', 'view', 'zap_trace_span'] # noqa: E501 - all_params.append('async_req') - all_params.append('_return_http_data_only') - all_params.append('_preload_content') - all_params.append('_request_timeout') - all_params.append('urlopen_kw') - - for key, val in six.iteritems(local_var_params['kwargs']): - if key not in all_params: - raise TypeError( - "Got an unexpected keyword argument '%s'" - " to method patch_dashboards_id_cells_id_view" % key - ) - local_var_params[key] = val - del local_var_params['kwargs'] + self._check_operation_params('patch_dashboards_id_cells_id_view', all_params, local_var_params) # verify the required parameter 'dashboard_id' is set if ('dashboard_id' not in local_var_params or local_var_params['dashboard_id'] is None): @@ -215,8 +269,6 @@ def patch_dashboards_id_cells_id_view_with_http_info(self, dashboard_id, cell_id local_var_params['view'] is None): raise ValueError("Missing the required parameter `view` when calling `patch_dashboards_id_cells_id_view`") # noqa: E501 - collection_formats = {} - path_params = {} if 'dashboard_id' in local_var_params: path_params['dashboardID'] = local_var_params['dashboard_id'] # noqa: E501 @@ -229,9 +281,6 @@ def patch_dashboards_id_cells_id_view_with_http_info(self, dashboard_id, cell_id if 'zap_trace_span' in local_var_params: header_params['Zap-Trace-Span'] = local_var_params['zap_trace_span'] # noqa: E501 - form_params = [] - local_var_files = {} - body_params = None if 'view' in local_var_params: body_params = local_var_params['view'] @@ -243,27 +292,4 @@ def patch_dashboards_id_cells_id_view_with_http_info(self, dashboard_id, cell_id header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501 ['application/json']) # noqa: E501 - # Authentication setting - auth_settings = [] # noqa: E501 - - # urlopen optional setting - urlopen_kw = None - if 'urlopen_kw' in kwargs: - urlopen_kw = kwargs['urlopen_kw'] - - return self.api_client.call_api( - '/api/v2/dashboards/{dashboardID}/cells/{cellID}/view', 'PATCH', - path_params, - query_params, - header_params, - body=body_params, - post_params=form_params, - files=local_var_files, - response_type='View', # noqa: E501 - auth_settings=auth_settings, - async_req=local_var_params.get('async_req'), - _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 - _preload_content=local_var_params.get('_preload_content', True), - _request_timeout=local_var_params.get('_request_timeout'), - collection_formats=collection_formats, - urlopen_kw=urlopen_kw) + return local_var_params, path_params, query_params, header_params, body_params diff --git a/influxdb_client/service/write_service.py b/influxdb_client/service/write_service.py index f666326a..36f2390d 100644 --- a/influxdb_client/service/write_service.py +++ b/influxdb_client/service/write_service.py @@ -14,11 +14,10 @@ import re # noqa: F401 -# python 2 and python 3 compatibility library -import six +from influxdb_client.service._base_service import _BaseService -class WriteService(object): +class WriteService(_BaseService): """NOTE: This class is auto generated by OpenAPI Generator. Ref: https://openapi-generator.tech @@ -87,83 +86,8 @@ def post_write_with_http_info(self, org, bucket, body, **kwargs): # noqa: E501, If the method is called asynchronously, returns the request thread. """ # noqa: E501 - local_var_params = locals() - - all_params = ['org', 'bucket', 'body', 'zap_trace_span', 'content_encoding', 'content_type', 'content_length', 'accept', 'org_id', 'precision'] # noqa: E501 - all_params.append('async_req') - all_params.append('_return_http_data_only') - all_params.append('_preload_content') - all_params.append('_request_timeout') - all_params.append('urlopen_kw') - - for key, val in six.iteritems(local_var_params['kwargs']): - if key not in all_params: - raise TypeError( - "Got an unexpected keyword argument '%s'" - " to method post_write" % key - ) - local_var_params[key] = val - del local_var_params['kwargs'] - # verify the required parameter 'org' is set - if ('org' not in local_var_params or - local_var_params['org'] is None): - raise ValueError("Missing the required parameter `org` when calling `post_write`") # noqa: E501 - # verify the required parameter 'bucket' is set - if ('bucket' not in local_var_params or - local_var_params['bucket'] is None): - raise ValueError("Missing the required parameter `bucket` when calling `post_write`") # noqa: E501 - # verify the required parameter 'body' is set - if ('body' not in local_var_params or - local_var_params['body'] is None): - raise ValueError("Missing the required parameter `body` when calling `post_write`") # noqa: E501 - - collection_formats = {} - - path_params = {} - - query_params = [] - if 'org' in local_var_params: - query_params.append(('org', local_var_params['org'])) # noqa: E501 - if 'org_id' in local_var_params: - query_params.append(('orgID', local_var_params['org_id'])) # noqa: E501 - if 'bucket' in local_var_params: - query_params.append(('bucket', local_var_params['bucket'])) # noqa: E501 - if 'precision' in local_var_params: - query_params.append(('precision', local_var_params['precision'])) # noqa: E501 - - header_params = {} - if 'zap_trace_span' in local_var_params: - header_params['Zap-Trace-Span'] = local_var_params['zap_trace_span'] # noqa: E501 - if 'content_encoding' in local_var_params: - header_params['Content-Encoding'] = local_var_params['content_encoding'] # noqa: E501 - if 'content_type' in local_var_params: - header_params['Content-Type'] = local_var_params['content_type'] # noqa: E501 - if 'content_length' in local_var_params: - header_params['Content-Length'] = local_var_params['content_length'] # noqa: E501 - if 'accept' in local_var_params: - header_params['Accept'] = local_var_params['accept'] # noqa: E501 - - form_params = [] - local_var_files = {} - - body_params = None - if 'body' in local_var_params: - body_params = local_var_params['body'] - # HTTP header `Accept` - header_params['Accept'] = self.api_client.select_header_accept( - ['application/json', 'text/html', ]) # noqa: E501 - - # HTTP header `Content-Type` - header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501 - ['text/plain']) # noqa: E501 - - # Authentication setting - auth_settings = [] # noqa: E501 - - # urlopen optional setting - urlopen_kw = None - if 'urlopen_kw' in kwargs: - urlopen_kw = kwargs['urlopen_kw'] + local_var_params, path_params, query_params, header_params, body_params = \ + self._post_write_prepare(org, bucket, body, **kwargs) return self.api_client.call_api( '/api/v2/write', 'POST', @@ -171,25 +95,22 @@ def post_write_with_http_info(self, org, bucket, body, **kwargs): # noqa: E501, query_params, header_params, body=body_params, - post_params=form_params, - files=local_var_files, + post_params=[], + files={}, response_type=None, # noqa: E501 - auth_settings=auth_settings, + auth_settings=[], async_req=local_var_params.get('async_req'), _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 _preload_content=local_var_params.get('_preload_content', True), _request_timeout=local_var_params.get('_request_timeout'), - collection_formats=collection_formats, - urlopen_kw=urlopen_kw) + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) async def post_write_async(self, org, bucket, body, **kwargs): # noqa: E501,D401,D403 """Write data. Writes data to a bucket. To write data into InfluxDB, you need the following: - **organization name or ID** – _See [View organizations](https://docs.influxdata.com/influxdb/v2.1/organizations/view-orgs/#view-your-organization-id) for instructions on viewing your organization ID._ - **bucket** – _See [View buckets](https://docs.influxdata.com/influxdb/v2.1/organizations/buckets/view-buckets/) for instructions on viewing your bucket ID._ - **API token** – _See [View tokens](https://docs.influxdata.com/influxdb/v2.1/security/tokens/view-tokens/) for instructions on viewing your API token._ - **InfluxDB URL** – _See [InfluxDB URLs](https://docs.influxdata.com/influxdb/v2.1/reference/urls/)_. - data in [line protocol](https://docs.influxdata.com/influxdb/v2.1/reference/syntax/line-protocol) format. InfluxDB Cloud enforces rate and size limits different from InfluxDB OSS. For details, see Responses. For more information and examples, see the following: - [Write data with the InfluxDB API](https://docs.influxdata.com/influxdb/v2.1/write-data/developer-tools/api). - [Optimize writes to InfluxDB](https://docs.influxdata.com/influxdb/v2.1/write-data/best-practices/optimize-writes/). - [Troubleshoot issues writing data](https://docs.influxdata.com/influxdb/v2.1/write-data/troubleshoot/) - This method makes a synchronous HTTP request by default. To make an - asynchronous HTTP request, please pass async_req=True - >>> thread = api.post_write_with_http_info(org, bucket, body, async_req=True) - >>> result = thread.get() + This method makes an asynchronous HTTP request. :param async_req bool :param str org: Destination organization for writes. The database writes all points in the batch to this organization. If you provide both `orgID` and `org` parameters, `org` takes precedence. (required) @@ -206,23 +127,31 @@ async def post_write_async(self, org, bucket, body, **kwargs): # noqa: E501,D40 If the method is called asynchronously, returns the request thread. """ # noqa: E501 + local_var_params, path_params, query_params, header_params, body_params = \ + self._post_write_prepare(org, bucket, body, **kwargs) + + return await self.api_client.call_api( + '/api/v2/write', 'POST', + path_params, + query_params, + header_params, + body=body_params, + post_params=[], + files={}, + response_type=None, # noqa: E501 + auth_settings=[], + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats={}, + urlopen_kw=kwargs.get('urlopen_kw', None)) + + def _post_write_prepare(self, org, bucket, body, **kwargs): # noqa: E501,D401,D403 local_var_params = locals() all_params = ['org', 'bucket', 'body', 'zap_trace_span', 'content_encoding', 'content_type', 'content_length', 'accept', 'org_id', 'precision'] # noqa: E501 - all_params.append('async_req') - all_params.append('_return_http_data_only') - all_params.append('_preload_content') - all_params.append('_request_timeout') - all_params.append('urlopen_kw') - - for key, val in six.iteritems(local_var_params['kwargs']): - if key not in all_params: - raise TypeError( - "Got an unexpected keyword argument '%s'" - " to method post_write" % key - ) - local_var_params[key] = val - del local_var_params['kwargs'] + self._check_operation_params('post_write', all_params, local_var_params) # verify the required parameter 'org' is set if ('org' not in local_var_params or local_var_params['org'] is None): @@ -236,8 +165,6 @@ async def post_write_async(self, org, bucket, body, **kwargs): # noqa: E501,D40 local_var_params['body'] is None): raise ValueError("Missing the required parameter `body` when calling `post_write`") # noqa: E501 - collection_formats = {} - path_params = {} query_params = [] @@ -262,9 +189,6 @@ async def post_write_async(self, org, bucket, body, **kwargs): # noqa: E501,D40 if 'accept' in local_var_params: header_params['Accept'] = local_var_params['accept'] # noqa: E501 - form_params = [] - local_var_files = {} - body_params = None if 'body' in local_var_params: body_params = local_var_params['body'] @@ -276,27 +200,4 @@ async def post_write_async(self, org, bucket, body, **kwargs): # noqa: E501,D40 header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501 ['text/plain']) # noqa: E501 - # Authentication setting - auth_settings = [] # noqa: E501 - - # urlopen optional setting - urlopen_kw = None - if 'urlopen_kw' in kwargs: - urlopen_kw = kwargs['urlopen_kw'] - - return await self.api_client.call_api( - '/api/v2/write', 'POST', - path_params, - query_params, - header_params, - body=body_params, - post_params=form_params, - files=local_var_files, - response_type=None, # noqa: E501 - auth_settings=auth_settings, - async_req=local_var_params.get('async_req'), - _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 - _preload_content=local_var_params.get('_preload_content', True), - _request_timeout=local_var_params.get('_request_timeout'), - collection_formats=collection_formats, - urlopen_kw=urlopen_kw) + return local_var_params, path_params, query_params, header_params, body_params From 50a1f6b2dc9ba62de08fb5a0b7571dc6fbebf367 Mon Sep 17 00:00:00 2001 From: Jakub Bednar Date: Mon, 14 Mar 2022 13:04:03 +0100 Subject: [PATCH 40/46] docs: add example how to use asynchronous management API --- .circleci/config.yml | 1 + examples/README.md | 3 ++ examples/asynchronous_management.py | 56 +++++++++++++++++++++++++++++ 3 files changed, 60 insertions(+) create mode 100644 examples/asynchronous_management.py diff --git a/.circleci/config.yml b/.circleci/config.yml index 2493314c..06ca3d0a 100644 --- a/.circleci/config.yml +++ b/.circleci/config.yml @@ -136,6 +136,7 @@ jobs: python examples/write_structured_data.py python examples/write_api_callbacks.py python examples/asynchronous.py + python examples/asynchronous_management.py check-sphinx: docker: - image: *default-python diff --git a/examples/README.md b/examples/README.md index 7c1a2ca8..bf53eba1 100644 --- a/examples/README.md +++ b/examples/README.md @@ -29,5 +29,8 @@ - [influxdb_18_example.py](influxdb_18_example.py) - How to connect to InfluxDB 1.8 - [nanosecond_precision.py](nanosecond_precision.py) - How to use nanoseconds precision - [invocable_scripts.py](invocable_scripts.py) - How to use Invocable scripts Cloud API to create custom endpoints that query data + +## Asynchronous - [asynchronous.py](asynchronous.py) - How to use Asyncio with InfluxDB client +- [asynchronous_management.py](asynchronous_management.py) - How to use asynchronous Management API diff --git a/examples/asynchronous_management.py b/examples/asynchronous_management.py new file mode 100644 index 00000000..65bea082 --- /dev/null +++ b/examples/asynchronous_management.py @@ -0,0 +1,56 @@ +""" +How to use asynchronous management API. +""" +import asyncio +import datetime + +from influxdb_client import OrganizationsService, BucketsService, PostBucketRequest, BucketRetentionRules +from influxdb_client.client.influxdb_client_async import InfluxDBClientAsync + +""" +Define credentials +""" +url = 'http://localhost:8086' +token = 'my-token' +bucket_name = 'my-bucket' +org_name = 'my-org' + + +async def main(): + async with InfluxDBClientAsync(url=url, token=token, org=org_name) as client: + unique_id = str(datetime.datetime.now()) + """ + Initialize async OrganizationsService + """ + organizations_service = OrganizationsService(api_client=client.api_client) + + """ + Find organization with name 'my-org' + """ + print(f"\n------- Find organization with name 'my-org' -------\n") + organizations = await organizations_service.get_orgs(org=org_name) + for organization in organizations.orgs: + print(f' > id: {organization.id}, name: {organization.name}') + + """ + Initialize async BucketsService + """ + buckets_service = BucketsService(api_client=client.api_client) + + """ + Create new Bucket with retention policy 1h + """ + print(f"\n------- Create new Bucket with retention policy 1h -------\n") + retention_rules = [BucketRetentionRules(type="expire", every_seconds=3600)] + bucket_request = PostBucketRequest(name=f"new_bucket_{unique_id}", + retention_rules=retention_rules, + description="Bucket created by async version of API.", + org_id=organizations.orgs[0].id) + created_bucket = await buckets_service.post_buckets(post_bucket_request=bucket_request) + print(" > created bucket: ") + print() + print(created_bucket) + + +if __name__ == "__main__": + asyncio.run(main()) From c2efbb31db4afb3a2a79dd6a4920726ff39d7e2d Mon Sep 17 00:00:00 2001 From: Jakub Bednar Date: Mon, 14 Mar 2022 13:13:00 +0100 Subject: [PATCH 41/46] docs: add asynchronous example into README.rst --- README.rst | 27 ++++++++++++++++ examples/asynchronous_management.py | 49 ++++------------------------- 2 files changed, 33 insertions(+), 43 deletions(-) diff --git a/README.rst b/README.rst index 7fa4fb4b..7c7a3adf 100644 --- a/README.rst +++ b/README.rst @@ -1341,6 +1341,7 @@ The ``async`` version of the client supports following asynchronous APIs: * :class:`~influxdb_client.client.write_api_async.WriteApiAsync` * :class:`~influxdb_client.client.query_api_async.QueryApiAsync` * :class:`~influxdb_client.client.delete_api_async.DeleteApiAsync` +* Management services into ``influxdb_client.service`` supports async operation and also check to readiness of the InfluxDB via ``/ping`` endpoint: @@ -1456,6 +1457,32 @@ Async Delete API asyncio.run(main()) +Management API +"""""""""""""" + + .. code-block:: python + + import asyncio + + from influxdb_client import OrganizationsService + from influxdb_client.client.influxdb_client_async import InfluxDBClientAsync + + + async def main(): + async with InfluxDBClientAsync(url='http://localhost:8086', token='my-token', org='my-org') as client: + # Initialize async OrganizationsService + organizations_service = OrganizationsService(api_client=client.api_client) + + # Find organization with name 'my-org' + organizations = await organizations_service.get_orgs(org='my-org') + for organization in organizations.orgs: + print(f'name: {organization.name}, id: {organization.id}') + + + if __name__ == "__main__": + asyncio.run(main()) + + .. marker-asyncio-end Local tests diff --git a/examples/asynchronous_management.py b/examples/asynchronous_management.py index 65bea082..1e36f37b 100644 --- a/examples/asynchronous_management.py +++ b/examples/asynchronous_management.py @@ -1,55 +1,18 @@ -""" -How to use asynchronous management API. -""" import asyncio -import datetime -from influxdb_client import OrganizationsService, BucketsService, PostBucketRequest, BucketRetentionRules +from influxdb_client import OrganizationsService from influxdb_client.client.influxdb_client_async import InfluxDBClientAsync -""" -Define credentials -""" -url = 'http://localhost:8086' -token = 'my-token' -bucket_name = 'my-bucket' -org_name = 'my-org' - async def main(): - async with InfluxDBClientAsync(url=url, token=token, org=org_name) as client: - unique_id = str(datetime.datetime.now()) - """ - Initialize async OrganizationsService - """ + async with InfluxDBClientAsync(url='http://localhost:8086', token='my-token', org='my-org') as client: + # Initialize async OrganizationsService organizations_service = OrganizationsService(api_client=client.api_client) - """ - Find organization with name 'my-org' - """ - print(f"\n------- Find organization with name 'my-org' -------\n") - organizations = await organizations_service.get_orgs(org=org_name) + # Find organization with name 'my-org' + organizations = await organizations_service.get_orgs(org='my-org') for organization in organizations.orgs: - print(f' > id: {organization.id}, name: {organization.name}') - - """ - Initialize async BucketsService - """ - buckets_service = BucketsService(api_client=client.api_client) - - """ - Create new Bucket with retention policy 1h - """ - print(f"\n------- Create new Bucket with retention policy 1h -------\n") - retention_rules = [BucketRetentionRules(type="expire", every_seconds=3600)] - bucket_request = PostBucketRequest(name=f"new_bucket_{unique_id}", - retention_rules=retention_rules, - description="Bucket created by async version of API.", - org_id=organizations.orgs[0].id) - created_bucket = await buckets_service.post_buckets(post_bucket_request=bucket_request) - print(" > created bucket: ") - print() - print(created_bucket) + print(f'name: {organization.name}, id: {organization.id}') if __name__ == "__main__": From 039c35accef334680818802ec7fad71e6e24cf5e Mon Sep 17 00:00:00 2001 From: Jakub Bednar Date: Tue, 15 Mar 2022 08:45:53 +0100 Subject: [PATCH 42/46] docs: add asynchronous batching --- .circleci/config.yml | 1 + examples/README.md | 1 + examples/asynchronous_batching.py | 69 +++++++++++++++++++++++++++++++ 3 files changed, 71 insertions(+) create mode 100644 examples/asynchronous_batching.py diff --git a/.circleci/config.yml b/.circleci/config.yml index 06ca3d0a..2bf1fc3b 100644 --- a/.circleci/config.yml +++ b/.circleci/config.yml @@ -137,6 +137,7 @@ jobs: python examples/write_api_callbacks.py python examples/asynchronous.py python examples/asynchronous_management.py + python examples/asynchronous_batching.py check-sphinx: docker: - image: *default-python diff --git a/examples/README.md b/examples/README.md index bf53eba1..f58f5d35 100644 --- a/examples/README.md +++ b/examples/README.md @@ -33,4 +33,5 @@ ## Asynchronous - [asynchronous.py](asynchronous.py) - How to use Asyncio with InfluxDB client - [asynchronous_management.py](asynchronous_management.py) - How to use asynchronous Management API +- [asynchronous_batching.py](asynchronous_batching.py) - HHow to use [RxPY](https://rxpy.readthedocs.io/en/latest/) to prepare batches for Asyncio client diff --git a/examples/asynchronous_batching.py b/examples/asynchronous_batching.py new file mode 100644 index 00000000..790fcac2 --- /dev/null +++ b/examples/asynchronous_batching.py @@ -0,0 +1,69 @@ +""" +How to use RxPY to prepare batches for asyncio client. +""" +import asyncio +from csv import DictReader + +import rx +from rx import operators as ops +from rx.scheduler.eventloop import AsyncIOScheduler + +from influxdb_client import Point +from influxdb_client.client.influxdb_client_async import InfluxDBClientAsync + + +def csv_to_generator(csv_file_path): + """ + Parse your CSV file into generator + """ + for row in DictReader(open(csv_file_path, 'r')): + point = Point('financial-analysis') \ + .tag('type', 'vix-daily') \ + .field('open', float(row['VIX Open'])) \ + .field('high', float(row['VIX High'])) \ + .field('low', float(row['VIX Low'])) \ + .field('close', float(row['VIX Close'])) \ + .time(row['Date']) + yield point + + +async def main(): + async with InfluxDBClientAsync(url='http://localhost:8086', token='my-token', org='my-org') as client: + write_api = client.write_api() + + """ + Async write + """ + + async def async_write(batch): + """ + Prepare async task + """ + await write_api.write(bucket='my-bucket', record=batch) + return batch + + """ + Prepare batches from generator + """ + batches = rx \ + .from_iterable(csv_to_generator('vix-daily.csv')) \ + .pipe(ops.buffer_with_count(500)) \ + .pipe(ops.map(lambda batch: rx.from_future(asyncio.ensure_future(async_write(batch)))), ops.merge_all()) + + done = asyncio.Future() + + """ + Write batches by subscribing to Rx generator + """ + batches.subscribe(on_next=lambda batch: print(f'Written batch... {len(batch)}'), + on_error=lambda ex: print(f'Unexpected error: {ex}'), + on_completed=lambda: done.set_result(0), + scheduler=AsyncIOScheduler(asyncio.get_event_loop())) + """ + Wait to finish all writes + """ + await done + + +if __name__ == "__main__": + asyncio.run(main()) From 914035f8908c0297b2dbe41906e74d8f7054abc4 Mon Sep 17 00:00:00 2001 From: Jakub Bednar Date: Tue, 15 Mar 2022 09:06:01 +0100 Subject: [PATCH 43/46] fix: running example on CircleCI --- .circleci/config.yml | 15 ++++++++------- 1 file changed, 8 insertions(+), 7 deletions(-) diff --git a/.circleci/config.yml b/.circleci/config.yml index 2bf1fc3b..b5adbf1d 100644 --- a/.circleci/config.yml +++ b/.circleci/config.yml @@ -131,13 +131,14 @@ jobs: pip install -e .\[async\] --user pip install -e .\[extra\] --user export PYTHONPATH="$PWD" - python examples/monitoring_and_alerting.py - python examples/buckets_management.py - python examples/write_structured_data.py - python examples/write_api_callbacks.py - python examples/asynchronous.py - python examples/asynchronous_management.py - python examples/asynchronous_batching.py + cd examples + python ./monitoring_and_alerting.py + python ./buckets_management.py + python ./write_structured_data.py + python ./write_api_callbacks.py + python ./asynchronous.py + python ./asynchronous_management.py + python ./asynchronous_batching.py check-sphinx: docker: - image: *default-python From 2f36b2d3dcaa3acb67991850f2e7bf97af6d6f1a Mon Sep 17 00:00:00 2001 From: Jakub Bednar Date: Tue, 15 Mar 2022 09:47:17 +0100 Subject: [PATCH 44/46] feat: add support to configure redirects --- README.rst | 31 +++++++++++++++++++ influxdb_client/_async/api_client.py | 4 +-- influxdb_client/_async/rest.py | 8 +++-- .../client/influxdb_client_async.py | 4 ++- 4 files changed, 42 insertions(+), 5 deletions(-) diff --git a/README.rst b/README.rst index 7c7a3adf..7a371189 100644 --- a/README.rst +++ b/README.rst @@ -1483,6 +1483,37 @@ Management API asyncio.run(main()) +Proxy and redirects +""""""""""""""""""" + +You can configure the client to tunnel requests through an HTTP proxy. +The following proxy options are supported: + +- ``proxy`` - Set this to configure the http proxy to be used, ex. ``http://localhost:3128`` +- ``proxy_headers`` - A dictionary containing headers that will be sent to the proxy. Could be used for proxy authentication. + +.. code-block:: python + + from influxdb_client.client.influxdb_client_async import InfluxDBClientAsync + + + async with InfluxDBClientAsync(url="http://localhost:8086", + token="my-token", + org="my-org", + proxy="http://localhost:3128") as client: + +.. note:: + + If your proxy notify the client with permanent redirect (``HTTP 301``) to **different host**. + The client removes ``Authorization`` header, because otherwise the contents of ``Authorization`` is sent to third parties + which is a security vulnerability. + +Client automatically follows HTTP redirects. The default redirect policy is to follow up to ``10`` consecutive requests. The redirects can be configured via: + +- ``allow_redirects`` - If set to ``False``, do not follow HTTP redirects. ``True`` by default. +- ``max_redirects`` - Maximum number of HTTP redirects to follow. ``10`` by default. + + .. marker-asyncio-end Local tests diff --git a/influxdb_client/_async/api_client.py b/influxdb_client/_async/api_client.py index d0139b95..7d1af096 100644 --- a/influxdb_client/_async/api_client.py +++ b/influxdb_client/_async/api_client.py @@ -63,14 +63,14 @@ class ApiClientAsync(object): _pool = None def __init__(self, configuration=None, header_name=None, header_value=None, - cookie=None, pool_threads=None, retries=False): + cookie=None, pool_threads=None, **kwargs): """Initialize generic API client.""" if configuration is None: configuration = Configuration() self.configuration = configuration self.pool_threads = pool_threads - self.rest_client = rest.RESTClientObjectAsync(configuration) + self.rest_client = rest.RESTClientObjectAsync(configuration, **kwargs) self.default_headers = {} if header_name is not None: self.default_headers[header_name] = header_value diff --git a/influxdb_client/_async/rest.py b/influxdb_client/_async/rest.py index 4fc87b1d..7344bb28 100644 --- a/influxdb_client/_async/rest.py +++ b/influxdb_client/_async/rest.py @@ -81,7 +81,7 @@ class RESTClientObjectAsync(object): Do not edit the class manually. """ - def __init__(self, configuration, pools_size=4, maxsize=None): + def __init__(self, configuration, pools_size=4, maxsize=None, **kwargs): """Initialize REST client.""" # maxsize is number of requests to host that are allowed in parallel if maxsize is None: @@ -104,6 +104,8 @@ def __init__(self, configuration, pools_size=4, maxsize=None): self.proxy = configuration.proxy self.proxy_headers = configuration.proxy_headers + self.allow_redirects = kwargs.get('allow_redirects', True) + self.max_redirects = kwargs.get('max_redirects', 10) # configure tracing trace_config = aiohttp.TraceConfig() @@ -169,7 +171,9 @@ async def request(self, method, url, query_params=None, headers=None, args = { "method": method, "url": url, - "headers": headers + "headers": headers, + "allow_redirects": self.allow_redirects, + "max_redirects": self.max_redirects } if self.proxy: diff --git a/influxdb_client/client/influxdb_client_async.py b/influxdb_client/client/influxdb_client_async.py index 91e450fc..6593f4c5 100644 --- a/influxdb_client/client/influxdb_client_async.py +++ b/influxdb_client/client/influxdb_client_async.py @@ -38,13 +38,15 @@ def __init__(self, url, token, org: str = None, debug=None, timeout=10_000, enab :key bool auth_basic: Set this to true to enable basic authentication when talking to a InfluxDB 1.8.x that does not use auth-enabled but is protected by a reverse proxy with basic authentication. (defaults to false, don't set to true when talking to InfluxDB 2) + :key bool allow_redirects: If set to ``False``, do not follow HTTP redirects. ``True`` by default. + :key int max_redirects: Maximum number of HTTP redirects to follow. ``10`` by default. :key list[str] profilers: list of enabled Flux profilers """ super().__init__(url=url, token=token, org=org, debug=debug, timeout=timeout, enable_gzip=enable_gzip, **kwargs) from .._async.api_client import ApiClientAsync self.api_client = ApiClientAsync(configuration=self.conf, header_name=self.auth_header_name, - header_value=self.auth_header_value, retries=self.retries) + header_value=self.auth_header_value, retries=self.retries, **kwargs) async def __aenter__(self) -> 'InfluxDBClientAsync': """ From 9a545ade315f9c129a14566c3faf0fa9f4980980 Mon Sep 17 00:00:00 2001 From: Jakub Bednar Date: Tue, 15 Mar 2022 10:24:14 +0100 Subject: [PATCH 45/46] chore: add support to configure retries --- .circleci/config.yml | 2 + examples/README.md | 3 +- examples/asynchronous_retry.py | 47 +++++++++++++++++++ influxdb_client/_async/rest.py | 7 ++- .../client/influxdb_client_async.py | 3 ++ 5 files changed, 59 insertions(+), 3 deletions(-) create mode 100644 examples/asynchronous_retry.py diff --git a/.circleci/config.yml b/.circleci/config.yml index b5adbf1d..a3c6a51e 100644 --- a/.circleci/config.yml +++ b/.circleci/config.yml @@ -130,6 +130,7 @@ jobs: pip install -e . --user pip install -e .\[async\] --user pip install -e .\[extra\] --user + pip install aiohttp-retry --user export PYTHONPATH="$PWD" cd examples python ./monitoring_and_alerting.py @@ -139,6 +140,7 @@ jobs: python ./asynchronous.py python ./asynchronous_management.py python ./asynchronous_batching.py + python ./asynchronous_retry.py check-sphinx: docker: - image: *default-python diff --git a/examples/README.md b/examples/README.md index f58f5d35..477dc005 100644 --- a/examples/README.md +++ b/examples/README.md @@ -33,5 +33,6 @@ ## Asynchronous - [asynchronous.py](asynchronous.py) - How to use Asyncio with InfluxDB client - [asynchronous_management.py](asynchronous_management.py) - How to use asynchronous Management API -- [asynchronous_batching.py](asynchronous_batching.py) - HHow to use [RxPY](https://rxpy.readthedocs.io/en/latest/) to prepare batches for Asyncio client +- [asynchronous_batching.py](asynchronous_batching.py) - How to use [RxPY](https://rxpy.readthedocs.io/en/latest/) to prepare batches +- [asynchronous_retry.py](asynchronous_retry.py) - How to use [aiohttp-retry](https://github.com/inyutin/aiohttp_retry) to configure retries diff --git a/examples/asynchronous_retry.py b/examples/asynchronous_retry.py new file mode 100644 index 00000000..bd627c29 --- /dev/null +++ b/examples/asynchronous_retry.py @@ -0,0 +1,47 @@ +""" +How to use `aiohttp-retry` with async client. + +This example depends on `aiohttp_retry `_. +Install ``aiohttp_retry`` by: pip install aiohttp-retry. + +""" +import asyncio + +from aiohttp_retry import ExponentialRetry, RetryClient + +from influxdb_client import Point +from influxdb_client.client.influxdb_client_async import InfluxDBClientAsync + + +async def main(): + """ + Configure Retries - for more info see https://github.com/inyutin/aiohttp_retry + """ + retry_options = ExponentialRetry(attempts=3) + async with InfluxDBClientAsync(url="http://localhost:8086", token="my-token", org="my-org", + client_session_type=RetryClient, + client_session_kwargs={"retry_options": retry_options}) as client: + """ + Write data: + """ + print(f"\n------- Written data: -------\n") + write_api = client.write_api() + _point1 = Point("async_m").tag("location", "Prague").field("temperature", 25.3) + _point2 = Point("async_m").tag("location", "New York").field("temperature", 24.3) + successfully = await write_api.write(bucket="my-bucket", record=[_point1, _point2]) + print(f" > successfully: {successfully}") + + """ + Query: Stream of FluxRecords + """ + print(f"\n------- Query: Stream of FluxRecords -------\n") + query_api = client.query_api() + records = await query_api.query_stream('from(bucket:"my-bucket") ' + '|> range(start: -10m) ' + '|> filter(fn: (r) => r["_measurement"] == "async_m")') + async for record in records: + print(record) + + +if __name__ == "__main__": + asyncio.run(main()) diff --git a/influxdb_client/_async/rest.py b/influxdb_client/_async/rest.py index 7344bb28..49bd54e7 100644 --- a/influxdb_client/_async/rest.py +++ b/influxdb_client/_async/rest.py @@ -122,11 +122,14 @@ def __init__(self, configuration, pools_size=4, maxsize=None, **kwargs): timeout = aiohttp.client.DEFAULT_TIMEOUT # https pool manager - self.pool_manager = aiohttp.ClientSession( + _client_session_type = kwargs.get('client_session_type', aiohttp.ClientSession) + _client_session_kwargs = kwargs.get('client_session_kwargs', {}) + self.pool_manager = _client_session_type( connector=connector, trust_env=True, timeout=timeout, - trace_configs=[trace_config] if configuration.debug else None + trace_configs=[trace_config] if configuration.debug else None, + **_client_session_kwargs ) async def close(self): diff --git a/influxdb_client/client/influxdb_client_async.py b/influxdb_client/client/influxdb_client_async.py index 6593f4c5..43465c7d 100644 --- a/influxdb_client/client/influxdb_client_async.py +++ b/influxdb_client/client/influxdb_client_async.py @@ -40,6 +40,9 @@ def __init__(self, url, token, org: str = None, debug=None, timeout=10_000, enab (defaults to false, don't set to true when talking to InfluxDB 2) :key bool allow_redirects: If set to ``False``, do not follow HTTP redirects. ``True`` by default. :key int max_redirects: Maximum number of HTTP redirects to follow. ``10`` by default. + :key dict client_session_kwargs: Additional configuration arguments for :class:`~aiohttp.ClientSession` + :key type client_session_type: Type of aiohttp client to use. Useful for third party wrappers like + ``aiohttp-retry``. :class:`~aiohttp.ClientSession` by default. :key list[str] profilers: list of enabled Flux profilers """ super().__init__(url=url, token=token, org=org, debug=debug, timeout=timeout, enable_gzip=enable_gzip, **kwargs) From b1f2e5d8c7326fdb4a4adb7bac44060af7f4223a Mon Sep 17 00:00:00 2001 From: Jakub Bednar Date: Mon, 28 Mar 2022 09:22:32 +0200 Subject: [PATCH 46/46] docs: clarify parsing a line of query response --- influxdb_client/client/flux_csv_parser.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/influxdb_client/client/flux_csv_parser.py b/influxdb_client/client/flux_csv_parser.py index 72330689..1e05652b 100644 --- a/influxdb_client/client/flux_csv_parser.py +++ b/influxdb_client/client/flux_csv_parser.py @@ -145,7 +145,7 @@ async def _parse_flux_response_async(self): def _parse_flux_response_row(self, metadata, csv): if len(csv) < 1: - # Response has HTTP status ok, but response is error. + # Skip empty line in results (new line is used as a delimiter between tables or table and error) pass elif "error" == csv[1] and "reference" == csv[2]: