fixing write points in unicode

Author: rhajek

influxdb2/client/__init__.py

@@ -1,30 +1,6 @@
 from __future__ import absolute_import
 
-# flake8: noqa
+from influxdb2.client.influxdb_client import InfluxDBClient
 
+# flake8: noqa
 # import apis into api package
-from influxdb2.service.authorizations_service import AuthorizationsService
-from influxdb2.service.buckets_service import BucketsService
-from influxdb2.service.cells_service import CellsService
-from influxdb2.service.checks_service import ChecksService
-from influxdb2.service.dashboards_service import DashboardsService
-from influxdb2.service.health_service import HealthService
-from influxdb2.service.labels_service import LabelsService
-from influxdb2.service.notification_endpoints_service import NotificationEndpointsService
-from influxdb2.service.notification_rules_service import NotificationRulesService
-from influxdb2.service.operation_logs_service import OperationLogsService
-from influxdb2.service.organizations_service import OrganizationsService
-from influxdb2.service.query_service import QueryService
-from influxdb2.service.ready_service import ReadyService
-from influxdb2.service.scraper_targets_service import ScraperTargetsService
-from influxdb2.service.secrets_service import SecretsService
-from influxdb2.service.setup_service import SetupService
-from influxdb2.service.sources_service import SourcesService
-from influxdb2.service.tasks_service import TasksService
-from influxdb2.service.telegrafs_service import TelegrafsService
-from influxdb2.service.templates_service import TemplatesService
-from influxdb2.service.users_service import UsersService
-from influxdb2.service.variables_service import VariablesService
-from influxdb2.service.views_service import ViewsService
-from influxdb2.service.write_service import WriteService
-from influxdb2.service.default_service import DefaultService

influxdb2/client/influxdb_client.py

@@ -1,7 +1,6 @@
 from __future__ import absolute_import
 
-import influxdb2
-from influxdb2 import Configuration
+from influxdb2 import Configuration, ApiClient, WriteService
 from influxdb2.client.authorizations_api import AuthorizationsApi
 from influxdb2.client.bucket_api import BucketsApi
 from influxdb2.client.labels_api import LabelsApi
@@ -14,26 +13,20 @@
 
 class InfluxDBClient(object):
 
-    def __init__(self,
-                 url,
-                 token,
-                 auth_scheme='token',
-                 username=None,
-                 password=None,
-                 debug=None,
-                 timeout=10000,
-                 enable_gzip=False,
-                 org=None) -> None:
+    def __init__(self, url, token, debug=None, timeout=10000, enable_gzip=False, org: str = None) -> None:
         """
-
+        Creates a new client instance
+        :param url: InfluxDB server API url (ex. http://localhost:9999/api/v2)
+        :param token: auth token
+        :param debug: enable verbose logging of http requests
+        :param timeout: default http client timeout
         :param enable_gzip: Enable Gzip compress for http requests. Currently only the "Write" and "Query" endpoints
                             supports the Gzip compression.
+        :param org: organization name (used as a default in query and write API)
+
         """
         self.url = url
-        self.auth_scheme = auth_scheme
         self.token = token
-        self.username = username
-        self.password = password
         self.timeout = timeout
         self.org = org
 
@@ -46,17 +39,29 @@ def __init__(self,
         auth_header_name = "Authorization"
         auth_header_value = "Token " + auth_token
 
-        self.api_client = influxdb2.ApiClient(configuration=conf, header_name=auth_header_name,
-                                              header_value=auth_header_value)
+        self.api_client = ApiClient(configuration=conf, header_name=auth_header_name,
+                                    header_value=auth_header_value)
 
-    def write_api(self, write_options=WriteOptions()):
-        service = influxdb2.service.write_service.WriteService(self.api_client)
+    def write_api(self, write_options=WriteOptions()) -> WriteApi:
+        """
+        Creates a Write API instance
+        :param write_options: write api configuration
+        :return: write api instance
+        """
+        service = WriteService(self.api_client)
         return WriteApi(service=service, write_options=write_options)
 
-    def query_api(self):
+    def query_api(self) -> QueryApi:
+        """
+        Creates a Query API instance
+        :return: Query api instance
+        """
         return QueryApi(self)
 
     def close(self):
+        """
+        Shutdowns the client
+        """
         self.__del__()
 
     def __del__(self):
@@ -65,26 +70,49 @@ def __del__(self):
             self.api_client = None
 
     def buckets_api(self) -> BucketsApi:
+        """
+        Creates the Bucket API instance
+        :return: buckets api
+        """
         return BucketsApi(self)
 
     def authorizations_api(self) -> AuthorizationsApi:
+        """
+        Creates the Authorizations API instance
+        :return: authorizations api
+        """
         return AuthorizationsApi(self)
 
     def users_api(self) -> UsersApi:
+        """
+        Creates the Users api
+        :return: users api
+        """
         return UsersApi(self)
 
     def organizations_api(self) -> OrganizationsApi:
+        """
+        Creates the Organizations api
+        :return: organizations api
+        """
         return OrganizationsApi(self)
 
     def tasks_api(self) -> TasksApi:
+        """
+        Creates the Tasks api
+        :return: tasks api
+        """
         return TasksApi(self)
 
     def labels_api(self) -> LabelsApi:
+        """
+        Creates the Labels api
+        :return: labels api
+        """
         return LabelsApi(self)
 
 
 class _Configuration(Configuration):
-
     def __init__(self):
         Configuration.__init__(self)
         self.enable_gzip = False
@@ -111,5 +139,9 @@ def update_request_body(self, path: str, body):
             # GZIP Request
             if path == '/write':
                 import gzip
-                return gzip.compress(bytes(_body, "utf-8"))
+                if isinstance(_body, bytes):
+                    return gzip.compress(data=_body)
+                else:
+                    return gzip.compress(bytes(_body, "utf-8"))
+
         return _body

influxdb2/client/labels_api.py

@@ -1,23 +1,33 @@
-from typing import List
+from typing import List, Dict
 
 from influxdb2 import LabelsService, LabelCreateRequest, Label, LabelUpdate
 
 
 class LabelsApi(object):
+    """
+    The client of the InfluxDB 2.0 that implements Labels HTTP API endpoint.
+    """
 
     def __init__(self, influxdb_client):
         self._influxdb_client = influxdb_client
         self._service = LabelsService(influxdb_client.api_client)
 
-    def create_label(self, name, org_id, properties=None) -> Label:
+    def create_label(self, name: str, org_id: str, properties: Dict[str, str] = None) -> Label:
+        """
+        Creates a new label.
+        :param name: label name
+        :param org_id: organization id
+        :param properties: optional label properties
+        :return: created label
+        """
         label_request = LabelCreateRequest(org_id=org_id, name=name, properties=properties)
         return self._service.post_labels(label_create_request=label_request).label
 
     def update_label(self, label: Label):
         """
-        Update a label
+        Updates an existing label name and properties.
         :param label: label
-        :return:
+        :return: the updated label
         """
         label_update = LabelUpdate()
         label_update.properties = label.properties
@@ -26,10 +36,9 @@ def update_label(self, label: Label):
 
     def delete_label(self, label):
         """
-        Delete the label
+        Deletes the label.
         :param label: label id or Label
         :type label str or Label
-        :return:
         """
         label_id = None
 
@@ -42,18 +51,37 @@ def delete_label(self, label):
         return self._service.delete_labels_id(label_id=label_id)
 
     def clone_label(self, cloned_name: str, label: Label) -> Label:
+        """
+        Creates the new instance of the label as a copy existing label.
+        :param cloned_name: new label name
+        :param label: existing label
+        :return:
+        """
         cloned_properties = None
         if label.properties is not None:
             cloned_properties = label.properties.copy()
 
         return self.create_label(name=cloned_name, properties=cloned_properties, org_id=label.org_id)
 
     def find_labels(self) -> List['Label']:
+        """
+        Gets all available labels.
+        :return: labels
+        """
         return self._service.get_labels().labels
 
     def find_label_by_id(self, label_id: str):
+        """
+        Retrieves the label by id
+        :param label_id:
+        :return: Label
+        """
         return self._service.get_labels_id(label_id=label_id).label
 
     def find_label_by_org(self, org_id) -> List['Label']:
-
+        """
+        Gets the list of all labels for given organization
+        :param org_id: organization id
+        :return: list of labels
+        """
         return self._service.get_labels(org_id=org_id).labels

influxdb2/client/organizations_api.py

@@ -2,6 +2,9 @@
 
 
 class OrganizationsApi(object):
+    """
+    The client of the InfluxDB 2.0 that implements Organizations HTTP API endpoint.
+    """
 
     def __init__(self, influxdb_client):
         self._influxdb_client = influxdb_client
@@ -12,16 +15,16 @@ def me(self):
         user = self._users_service.get_me()
         return user
 
-    def find_organization(self, id):
-        return self._organizations_service.get_orgs_id(org_id=id)
+    def find_organization(self, org_id):
+        return self._organizations_service.get_orgs_id(org_id=org_id)
 
     def find_organizations(self):
         return self._organizations_service.get_orgs()
 
-    def create_organization(self, name=None, organization=None) -> Organization:
+    def create_organization(self, name: str = None, organization: Organization = None) -> Organization:
         if organization is None:
             organization = Organization(name=name)
-        return self._organizations_service.post_orgs(organization)
+        return self._organizations_service.post_orgs(organization=organization)
 
     def delete_organization(self, org_id: str):
         return self._organizations_service.delete_orgs_id(org_id=org_id)

influxdb2/client/query_api.py

@@ -1,35 +1,63 @@
-from influxdb2 import Query, QueryService
 import codecs
 import csv
+from typing import List
 
 from influxdb2 import Dialect
+from influxdb2 import Query, QueryService
 from influxdb2.client.flux_csv_parser import FluxCsvParser, FluxResponseConsumerTable
+from influxdb2.client.flux_table import FluxTable
 
 
 class QueryApi(object):
     default_dialect = Dialect(header=True, delimiter=",", comment_prefix="#",
                               annotations=["datatype", "group", "default"], date_time_format="RFC3339")
 
     def __init__(self, influxdb_client):
+        """
+        Initialize query client
+        :param influxdb_client: influxdb client
+        """
         self._influxdb_client = influxdb_client
         self._query_api = QueryService(influxdb_client.api_client)
 
-    def query_csv(self, query, org=None, dialect=default_dialect):
+    def query_csv(self, query: str, org=None, dialect: Dialect = default_dialect):
+        """
+        Executes the Flux query and return results as a CSV iterator.
+        Each iteration returns a row of the CSV file
+        :param query: a Flux query
+        :param org: organization name (optional if already specified in InfluxDBClient)
+        :param dialect: csv dialect format
+        :return: returns CSV iterator
+        """
         if org is None:
             org = self._influxdb_client.org
         response = self._query_api.post_query(org=org, query=self._create_query(query, dialect), async_req=False,
                                               _preload_content=False)
         return csv.reader(codecs.iterdecode(response, 'utf-8'))
 
-    def query_raw(self, query, org=None, dialect=default_dialect):
+    def query_raw(self, query: str, org=None, dialect=default_dialect):
+        """
+        Synchronously executes the Flux query and return result as raw unprocessed result as a str
+        :param query: a Flux query
+        :param org: organization name (optional if already specified in InfluxDBClient)
+        :param dialect: csv dialect format
+        :return: str
+        """
         if org is None:
             org = self._influxdb_client.org
         result = self._query_api.post_query(org=org, query=self._create_query(query, dialect), async_req=False,
                                             _preload_content=False)
         return result
         # return codecs.iterdecode(result, 'utf-8')
 
-    def query(self, query, org=None, dialect=default_dialect):
+    def query(self, query, org=None, dialect=default_dialect) -> List['FluxTable']:
+        """
+        Synchronously executes the Flux query and return result as a List['FluxTable']
+        :param query: the Flux query
+        :param org: organization name (optional if already specified in InfluxDBClient)
+        :param dialect: csv dialect format
+        :return:
+        """
         if org is None:
             org = self._influxdb_client.org
         response = self._query_api.post_query(org=org, query=self._create_query(query, dialect), async_req=False,

influxdb2/client/write/point.py

@@ -6,7 +6,7 @@
 
 import dateutil.parser
 from pytz import UTC
-from six import iteritems, binary_type, PY2
+from six import iteritems
 
 from influxdb2.domain.write_precision import WritePrecision
 
@@ -104,7 +104,7 @@ def _append_time(time, write_precission):
 
 
 def _escape_tag(tag):
-    return _get_unicode(str(tag)).replace("\\", "\\\\").replace(" ", "\\ ").replace(",", "\\,").replace("=", "\\=")
+    return str(tag).replace("\\", "\\\\").replace(" ", "\\ ").replace(",", "\\,").replace("=", "\\=")
 
 
 def _escape_tag_value(value):
@@ -149,18 +149,3 @@ def _convert_timestamp(timestamp, precision=DEFAULT_WRITE_PRECISION):
         #     return ns / 1e9 / 3600
 
     raise ValueError(timestamp)
-
-
-def _get_unicode(data, force=False):
-    """Try to return a text aka unicode object from the given data."""
-    if isinstance(data, binary_type):
-        return data.decode('utf-8')
-    elif data is None:
-        return ''
-    elif force:
-        if PY2:
-            return unicode(data)
-        else:
-            return str(data)
-    else:
-        return data