influxdb3-python 0.7.0__tar.gz → 0.9.0__tar.gz

influxdb3_python-0.9.0/Examples/__init__.py

@@ -0,0 +1 @@
+# used mainly to resolve local utility helpers like config.py

influxdb3_python-0.9.0/Examples/batching_example.py

@@ -0,0 +1,114 @@
+import datetime
+import random
+
+from bson import ObjectId
+
+import influxdb_client_3 as InfluxDBClient3
+from influxdb_client_3 import write_client_options, WritePrecision, WriteOptions, InfluxDBError
+
+
+class BatchingCallback(object):
+
+    def success(self, conf, data: str):
+        print(f"Written batch: {conf}, data: {data}")
+
+    def error(self, conf, data: str, exception: InfluxDBError):
+        print(f"Cannot write batch: {conf}, data: {data} due: {exception}")
+
+    def retry(self, conf, data: str, exception: InfluxDBError):
+        print(f"Retryable error occurs for batch: {conf}, data: {data} retry: {exception}")
+
+
+# Creating 5.000 gatewayId values as MongoDB ObjectIDs
+gatewayIds = [ObjectId() for x in range(0, 100)]
+
+# Setting decimal precision to 2
+precision = 2
+
+# Setting timestamp for first sensor reading
+now = datetime.datetime.now()
+now = now - datetime.timedelta(days=30)
+teststart = datetime.datetime.now()
+
+# InfluxDB connection details
+token = ""
+org = ""
+database = ""
+url = "eu-central-1-1.aws.cloud2.influxdata.com"
+
+callback = BatchingCallback()
+
+write_options = WriteOptions(batch_size=5_000,
+                             flush_interval=10_000,
+                             jitter_interval=2_000,
+                             retry_interval=5_000,
+                             max_retries=5,
+                             max_retry_delay=30_000,
+                             exponential_base=2)
+
+wco = write_client_options(success_callback=callback.success,
+                           error_callback=callback.error,
+                           retry_callback=callback.retry,
+                           write_options=write_options
+                           )
+# Opening InfluxDB client with a batch size of 5k points or flush interval
+# of 10k ms and gzip compression
+with InfluxDBClient3.InfluxDBClient3(token=token,
+                                     host=url,
+                                     org=org,
+                                     database=database, enable_gzip=True, write_client_options=wco) as _client:
+    # Creating iterator for one hour worth of data (6 sensor readings per
+    # minute)
+    for i in range(0, 525600):
+        # Adding 10 seconds to timestamp of previous sensor reading
+        now = now + datetime.timedelta(seconds=10)
+        # Iterating over gateways
+        for gatewayId in gatewayIds:
+            # Creating random test data for 12 fields to be stored in
+            # timeseries database
+            bcW = random.randrange(1501)
+            bcWh = round(random.uniform(0, 4.17), precision)
+            bdW = random.randrange(71)
+            bdWh = round(random.uniform(0, 0.12), precision)
+            cPvWh = round(random.uniform(0.51, 27.78), precision)
+            cW = random.randrange(172, 10001)
+            cWh = round(random.uniform(0.51, 27.78), precision)
+            eWh = round(random.uniform(0, 41.67), precision)
+            iWh = round(random.uniform(0, 16.67), precision)
+            pW = random.randrange(209, 20001)
+            pWh = round(random.uniform(0.58, 55.56), precision)
+            scWh = round(random.uniform(0.58, 55.56), precision)
+            # Creating point to be ingested into InfluxDB
+            p = InfluxDBClient3.Point("stream").tag(
+                "gatewayId",
+                str(gatewayId)).field(
+                "bcW",
+                bcW).field(
+                "bcWh",
+                bcWh).field(
+                "bdW",
+                bdW).field(
+                "bdWh",
+                bdWh).field(
+                "cPvWh",
+                cPvWh).field(
+                "cW",
+                cW).field(
+                "cWh",
+                cWh).field(
+                "eWh",
+                eWh).field(
+                "iWh",
+                iWh).field(
+                "pW",
+                pW).field(
+                "pWh",
+                pWh).field(
+                "scWh",
+                scWh).time(
+                now.strftime('%Y-%m-%dT%H:%M:%SZ'),
+                WritePrecision.S)
+
+            # Writing point (InfluxDB automatically batches writes into sets of
+            # 5k points)
+            _client.write(record=p)

influxdb3_python-0.9.0/Examples/cloud_dedicated_query.py

@@ -0,0 +1,16 @@
+from config import Config
+import influxdb_client_3 as InfluxDBClient3
+
+config = Config()
+
+client = InfluxDBClient3.InfluxDBClient3(
+    token=config.token,
+    host=config.host,
+    org=config.org,
+    database=config.database)
+
+table = client.query(
+    query="SELECT * FROM flight WHERE time > now() - 4h",
+    language="influxql")
+
+print(table.to_pandas())

influxdb3_python-0.9.0/Examples/cloud_dedicated_write.py

@@ -0,0 +1,49 @@
+from config import Config
+import influxdb_client_3 as InfluxDBClient3
+from influxdb_client_3 import WriteOptions
+import pandas as pd
+import numpy as np
+
+config = Config()
+
+client = InfluxDBClient3.InfluxDBClient3(
+    token=config.token,
+    host=config.host,
+    org=config.org,
+    database=config.database,
+    write_options=WriteOptions(
+        batch_size=500,
+        flush_interval=10_000,
+        jitter_interval=2_000,
+        retry_interval=5_000,
+        max_retries=5,
+        max_retry_delay=30_000,
+        max_close_wait=300_000,
+        exponential_base=2,
+        write_type='batching'))
+
+
+# Create a dataframe
+df = pd.DataFrame({'a': [1, 2, 3], 'b': [4, 5, 6]})
+
+
+# Create a range of datetime values
+dates = pd.date_range(start='2024-09-08', end='2024-09-09', freq='5min')
+
+# Create a DataFrame with random data and datetime index
+df = pd.DataFrame(
+    np.random.randn(
+        len(dates),
+        3),
+    index=dates,
+    columns=[
+        'Column 1',
+        'Column 2',
+        'Column 3'])
+df['tagkey'] = 'Hello World'
+
+print(df)
+
+# Write the DataFrame to InfluxDB
+client.write(df, data_frame_measurement_name='table',
+             data_frame_tag_columns=['tagkey'])

influxdb3_python-0.9.0/Examples/config.py

@@ -0,0 +1,13 @@
+import os
+import json
+
+
+class Config:
+    def __init__(self):
+        self.host = os.getenv('INFLUXDB_HOST') or 'https://us-east-1-1.aws.cloud2.influxdata.com/'
+        self.token = os.getenv('INFLUXDB_TOKEN') or 'my-token'
+        self.org = os.getenv('INFLUXDB_ORG') or 'my-org'
+        self.database = os.getenv('INFLUXDB_DATABASE') or 'my-db'
+
+    def __str__(self):
+        return json.dumps(self.__dict__)

influxdb3_python-0.9.0/Examples/flight_options_example.py

@@ -0,0 +1,23 @@
+import influxdb_client_3 as InfluxDBClient3
+from influxdb_client_3 import flight_client_options
+
+
+with open("./cert.pem", 'rb') as f:
+    cert = f.read()
+print(cert)
+
+
+client = InfluxDBClient3.InfluxDBClient3(
+    token="",
+    host="b0c7cce5-8dbc-428e-98c6-7f996fb96467.a.influxdb.io",
+    org="6a841c0c08328fb1",
+    database="flightdemo",
+    flight_client_options=flight_client_options(
+        tls_root_certs=cert))
+
+
+table = client.query(
+    query="SELECT * FROM flight WHERE time > now() - 4h",
+    language="influxql")
+
+print(table.to_pandas())

influxdb3_python-0.9.0/Examples/handle_http_error.py

@@ -0,0 +1,43 @@
+"""
+Demonstrates handling response error headers on error.
+"""
+import logging
+from config import Config
+
+import influxdb_client_3 as InfluxDBClient3
+
+
+def main() -> None:
+    """
+    Main function
+    :return:
+    """
+    config = Config()
+    logging.basicConfig(format='%(asctime)s %(message)s', level=logging.INFO)
+
+    client = InfluxDBClient3.InfluxDBClient3(
+        host=config.host,
+        token=config.token,
+        org=config.org,
+        database=config.database
+    )
+
+    # write with empty field results in HTTP 400 error
+    # Other cases might be HTTP 503 or HTTP 429 too many requests
+    lp = 'drone,location=harfa,id=A16E22 speed=18.7,alt=97.6,shutter='
+
+    try:
+        client.write(lp)
+    except InfluxDBClient3.InfluxDBError as idberr:
+        logging.log(logging.ERROR, 'WRITE ERROR: %s (%s)',
+                    idberr.response.status,
+                    idberr.message)
+        headers_string = 'Response Headers:\n'
+        headers = idberr.getheaders()
+        for h in headers:
+            headers_string += f'   {h}: {headers[h]}\n'
+        logging.log(logging.INFO, headers_string)
+
+
+if __name__ == "__main__":
+    main()

influxdb3_python-0.9.0/Examples/pandas_write.py

@@ -0,0 +1,35 @@
+import influxdb_client_3 as InfluxDBClient3
+import pandas as pd
+import numpy as np
+
+client = InfluxDBClient3.InfluxDBClient3(
+    token="",
+    host="eu-central-1-1.aws.cloud2.influxdata.com",
+    org="",
+    database="")
+
+
+# Create a dataframe
+df = pd.DataFrame({'a': [1, 2, 3], 'b': [4, 5, 6]})
+
+
+# Create a range of datetime values
+dates = pd.date_range(start='2023-03-01', end='2023-03-29', freq='5min')
+
+# Create a DataFrame with random data and datetime index
+df = pd.DataFrame(
+    np.random.randn(
+        len(dates),
+        3),
+    index=dates,
+    columns=[
+        'Column 1',
+        'Column 2',
+        'Column 3'])
+df['tagkey'] = 'Hello World'
+
+print(df)
+
+# Write the DataFrame to InfluxDB
+client.write(df, data_frame_measurement_name='table',
+             data_frame_tag_columns=['tagkey'])

influxdb3_python-0.9.0/Examples/query_type.py

@@ -0,0 +1,55 @@
+import influxdb_client_3 as InfluxDBClient3
+
+client = InfluxDBClient3.InfluxDBClient3(
+    token="",
+    host="eu-central-1-1.aws.cloud2.influxdata.com",
+    org="6a841c0c08328fb1",
+    database="factory")
+
+
+# Chunk mode provides a FlightReader object that can be used to read chunks of data.
+reader = client.query(
+    query="SELECT * FROM machine_data WHERE time > now() - 2h",
+    language="influxql", mode="chunk")
+
+try:
+    while True:
+        batch, buff = reader.read_chunk()
+        print("batch:")
+        print(batch.to_pandas())
+except StopIteration:
+    print("No more chunks to read")
+
+
+# Pandas mode provides a Pandas DataFrame object.
+df = client.query(
+    query="SELECT * FROM machine_data WHERE time > now() - 2h",
+    language="influxql", mode="pandas")
+
+print("pandas:")
+print(df)
+
+# All mode provides an Arrow Table object.
+table = client.query(
+    query="SELECT * FROM machine_data WHERE time > now() - 2h",
+    language="influxql", mode="all")
+
+print("table:")
+print(table)
+
+# Print the schema of the table
+table = client.query(
+    query="SELECT * FROM machine_data WHERE time > now() - 2h",
+    language="influxql", mode="schema")
+
+print("schema:")
+print(table)
+
+# Convert this reader into a regular RecordBatchReader
+reader = client.query(
+    query="SELECT * FROM machine_data WHERE time > now() - 2h",
+    language="influxql", mode="reader")
+
+print("reader:")
+for batch in reader:
+    print(batch.to_pandas())

{influxdb3_python-0.7.0 → influxdb3_python-0.9.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: influxdb3-python
-Version: 0.7.0
+Version: 0.9.0
 Summary: Community Python client for InfluxDB 3.0
 Home-page: https://github.com/InfluxCommunity/influxdb3-python
 Author: InfluxData
@@ -93,7 +93,7 @@ from influxdb_client_3 import InfluxDBClient3, Point
 ## Initialization
 If you are using InfluxDB Cloud, then you should note that:
 1. You will need to supply your org id, this is not necessary for InfluxDB Dedicated.
-2. Use a bucketname for the database argument.
+2. Use bucket name for the `database` argument.
 
 ```python
 client = InfluxDBClient3(token="your-token",

{influxdb3_python-0.7.0 → influxdb3_python-0.9.0}/README.md

@@ -58,7 +58,7 @@ from influxdb_client_3 import InfluxDBClient3, Point
 ## Initialization
 If you are using InfluxDB Cloud, then you should note that:
 1. You will need to supply your org id, this is not necessary for InfluxDB Dedicated.
-2. Use a bucketname for the database argument.
+2. Use bucket name for the `database` argument.
 
 ```python
 client = InfluxDBClient3(token="your-token",

{influxdb3_python-0.7.0 → influxdb3_python-0.9.0}/influxdb3_python.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: influxdb3-python
-Version: 0.7.0
+Version: 0.9.0
 Summary: Community Python client for InfluxDB 3.0
 Home-page: https://github.com/InfluxCommunity/influxdb3-python
 Author: InfluxData
@@ -93,7 +93,7 @@ from influxdb_client_3 import InfluxDBClient3, Point
 ## Initialization
 If you are using InfluxDB Cloud, then you should note that:
 1. You will need to supply your org id, this is not necessary for InfluxDB Dedicated.
-2. Use a bucketname for the database argument.
+2. Use bucket name for the `database` argument.
 
 ```python
 client = InfluxDBClient3(token="your-token",

{influxdb3_python-0.7.0 → influxdb3_python-0.9.0}/influxdb3_python.egg-info/SOURCES.txt

@@ -1,6 +1,15 @@
 LICENSE
 README.md
 setup.py
+Examples/__init__.py
+Examples/batching_example.py
+Examples/cloud_dedicated_query.py
+Examples/cloud_dedicated_write.py
+Examples/config.py
+Examples/flight_options_example.py
+Examples/handle_http_error.py
+Examples/pandas_write.py
+Examples/query_type.py
 influxdb3_python.egg-info/PKG-INFO
 influxdb3_python.egg-info/SOURCES.txt
 influxdb3_python.egg-info/dependency_links.txt
@@ -51,6 +60,6 @@ tests/test_influxdb_client_3.py
 tests/test_influxdb_client_3_integration.py
 tests/test_merge_options.py
 tests/test_point.py
-tests/test_polars_dataframe_serializer.py
+tests/test_polars.py
 tests/test_query.py
 tests/test_write_file.py

{influxdb3_python-0.7.0 → influxdb3_python-0.9.0}/influxdb3_python.egg-info/top_level.txt

@@ -1 +1,2 @@
+Examples
 influxdb_client_3

{influxdb3_python-0.7.0 → influxdb3_python-0.9.0}/influxdb_client_3/__init__.py

@@ -110,7 +110,28 @@ class InfluxDBClient3:
         :type write_client_options: callable
         :param flight_client_options: Function for providing additional arguments for the FlightClient.
         :type flight_client_options: callable
-        :param kwargs: Additional arguments for the InfluxDB Client.
+        :key auth_scheme: token authentication scheme. Set to "Bearer" for Edge.
+        :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 cert_file: Path to the certificate that will be used for mTLS authentication.
+        :key str cert_key_file: Path to the file contains private key for mTLS certificate.
+        :key str cert_key_password: String or function which returns password for decrypting the mTLS private key.
+        :key ssl.SSLContext ssl_context: Specify a custom Python SSL Context for the TLS/ mTLS handshake.
+                                         Be aware that only delivered certificate/ key files or an SSL Context are
+                                         possible.
+        :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: Number of connections to save that can be reused by urllib3.
+                                          Defaults to "multiprocessing.cpu_count() * 5".
+        :key urllib3.util.retry.Retry retries: Set the default retry strategy that is used for all HTTP requests
+                                               except batching writes. As a default there is no one retry strategy.
+        :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 str username: ``username`` to authenticate via username and password credentials to the InfluxDB 2.x
+        :key str password: ``password`` to authenticate via username and password credentials to the InfluxDB 2.x
+        :key list[str] profilers: list of enabled Flux profilers
         """
         self._org = org if org is not None else "default"
         self._database = database

{influxdb3_python-0.7.0 → influxdb3_python-0.9.0}/influxdb_client_3/version.py

@@ -1,4 +1,4 @@
 """Version of the Client that is used in User-Agent header."""
 
-VERSION = '0.7.0'
+VERSION = '0.9.0'
 USER_AGENT = f'influxdb3-python/{VERSION}'

{influxdb3_python-0.7.0 → influxdb3_python-0.9.0}/influxdb_client_3/write_client/client/_base.py

@@ -37,7 +37,6 @@ class _BaseClient(object):
     def __init__(self, url, token, debug=None, timeout=10_000, enable_gzip=False, org: str = None,
                  default_tags: dict = None, http_client_logger: str = None, **kwargs) -> None:
         self.url = url
-        self.token = token
         self.org = org
 
         self.default_tags = default_tags
@@ -70,9 +69,10 @@ class _BaseClient(object):
         self.auth_header_name = None
         self.auth_header_value = None
         # by token
-        if self.token:
+        if token:
+            auth_scheme = kwargs.get('auth_scheme', "Token")
             self.auth_header_name = "Authorization"
-            self.auth_header_value = "Token " + self.token
+            self.auth_header_value = f"{auth_scheme} {token}"
         # by HTTP basic
         auth_basic = kwargs.get('auth_basic', False)
         if auth_basic:
@@ -248,7 +248,8 @@ class _BaseWriteApi(object):
             self._serialize(Point.from_dict(record, write_precision=write_precision, **kwargs),
                             write_precision, payload, **kwargs)
         elif 'polars' in str(type(record)):
-            from influxdb_client_3.write_client.client.write.dataframe_serializer import PolarsDataframeSerializer
+            from influxdb_client_3.write_client.client.write.polars_dataframe_serializer import \
+                PolarsDataframeSerializer
             serializer = PolarsDataframeSerializer(record, self._point_settings, write_precision, **kwargs)
             self._serialize(serializer.serialize(), write_precision, payload, **kwargs)
 

{influxdb3_python-0.7.0 → influxdb3_python-0.9.0}/influxdb_client_3/write_client/client/exceptions.py

@@ -26,8 +26,18 @@ class InfluxDBError(Exception):
         # Body
         if response.data:
             import json
+
+            def get(d, key):
+                if not key or d is None:
+                    return d
+                return get(d.get(key[0]), key[1:])
             try:
-                return json.loads(response.data)["message"]
+                node = json.loads(response.data)
+                for key in [['message'], ['data', 'error_message'], ['error']]:
+                    value = get(node, key)
+                    if value is not None:
+                        return value
+                return response.data
             except Exception as e:
                 logging.debug(f"Cannot parse error response to JSON: {response.data}, {e}")
                 return response.data
@@ -40,3 +50,7 @@ class InfluxDBError(Exception):
 
         # Http Status
         return response.reason
+
+    def getheaders(self):
+        """Helper method to make response headers more accessible."""
+        return self.response.getheaders()

{influxdb3_python-0.7.0 → influxdb3_python-0.9.0}/influxdb_client_3/write_client/client/influxdb_client.py

@@ -27,6 +27,7 @@ class InfluxDBClient(_BaseClient):
         :param enable_gzip: Enable Gzip compression for http requests. Currently, only the "Write" and "Query" endpoints
                             supports the Gzip compression.
         :param org: organization name (used as a default in Query, Write and Delete API)
+        :key auth_scheme: token authentication scheme. Set to "Bearer" for Edge.
         :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 cert_file: Path to the certificate that will be used for mTLS authentication.

{influxdb3_python-0.7.0 → influxdb3_python-0.9.0}/influxdb_client_3/write_client/client/write_api.py

@@ -566,7 +566,7 @@ You can use native asynchronous version of the client:
 
     def _on_complete(self):
         self._disposable.dispose()
-        logger.info("the batching processor was disposed")
+        logger.debug("the batching processor was disposed")
 
     def __getstate__(self):
         """Return a dict of attributes that you want to pickle."""

{influxdb3_python-0.7.0 → influxdb3_python-0.9.0}/setup.py

@@ -47,6 +47,7 @@ setup(
     author_email='contact@influxdata.com',
     url='https://github.com/InfluxCommunity/influxdb3-python',
     packages=find_packages(exclude=['tests', 'tests.*', 'examples', 'examples.*']),
+    package_data={'influxdb_client_3': ['py.typed']},
     extras_require={
         'pandas': ['pandas'],
         'polars': ['polars'],

influxdb3_python-0.9.0/tests/test_api_client.py

@@ -0,0 +1,141 @@
+import json
+import unittest
+import uuid
+from unittest import mock
+from urllib3 import response
+
+from influxdb_client_3.write_client._sync.api_client import ApiClient
+from influxdb_client_3.write_client.configuration import Configuration
+from influxdb_client_3.write_client.client.exceptions import InfluxDBError
+from influxdb_client_3.write_client.service import WriteService
+from influxdb_client_3.version import VERSION
+
+_package = "influxdb3-python"
+_sentHeaders = {}
+
+
+def mock_rest_request(method,
+                      url,
+                      query_params=None,
+                      headers=None,
+                      body=None,
+                      post_params=None,
+                      _preload_content=True,
+                      _request_timeout=None,
+                      **urlopen_kw):
+    class MockResponse:
+        def __init__(self, data, status_code):
+            self.data = data
+            self.status_code = status_code
+
+        def data(self):
+            return self.data
+
+    global _sentHeaders
+    _sentHeaders = headers
+
+    return MockResponse(None, 200)
+
+
+class ApiClientTests(unittest.TestCase):
+
+    def test_default_headers(self):
+        global _package
+        conf = Configuration()
+        client = ApiClient(conf,
+                           header_name="Authorization",
+                           header_value="Bearer TEST_TOKEN")
+        self.assertIsNotNone(client.default_headers["User-Agent"])
+        self.assertIsNotNone(client.default_headers["Authorization"])
+        self.assertEqual(f"{_package}/{VERSION}", client.default_headers["User-Agent"])
+        self.assertEqual("Bearer TEST_TOKEN", client.default_headers["Authorization"])
+
+    @mock.patch("influxdb_client_3.write_client._sync.rest.RESTClientObject.request",
+                side_effect=mock_rest_request)
+    def test_call_api(self, mock_post):
+        global _package
+        global _sentHeaders
+        _sentHeaders = {}
+
+        conf = Configuration()
+        client = ApiClient(conf,
+                           header_name="Authorization",
+                           header_value="Bearer TEST_TOKEN")
+        service = WriteService(client)
+        service.post_write("TEST_ORG", "TEST_BUCKET", "data,foo=bar val=3.14")
+        self.assertEqual(4, len(_sentHeaders.keys()))
+        self.assertIsNotNone(_sentHeaders["Accept"])
+        self.assertEqual("application/json", _sentHeaders["Accept"])
+        self.assertIsNotNone(_sentHeaders["Content-Type"])
+        self.assertEqual("text/plain", _sentHeaders["Content-Type"])
+        self.assertIsNotNone(_sentHeaders["Authorization"])
+        self.assertEqual("Bearer TEST_TOKEN", _sentHeaders["Authorization"])
+        self.assertIsNotNone(_sentHeaders["User-Agent"])
+        self.assertEqual(f"{_package}/{VERSION}", _sentHeaders["User-Agent"])
+
+    def _test_api_error(self, body):
+        conf = Configuration()
+        client = ApiClient(conf)
+        client.rest_client.pool_manager.request \
+            = mock.Mock(return_value=response.HTTPResponse(status=400,
+                                                           reason='Bad Request',
+                                                           body=body.encode()))
+        service = WriteService(client)
+        service.post_write("TEST_ORG", "TEST_BUCKET", "data,foo=bar val=3.14")
+
+    def test_api_error_cloud(self):
+        response_body = '{"message": "parsing failed for write_lp endpoint"}'
+        with self.assertRaises(InfluxDBError) as err:
+            self._test_api_error(response_body)
+        self.assertEqual('parsing failed for write_lp endpoint', err.exception.message)
+
+    def test_api_error_oss_without_detail(self):
+        response_body = '{"error": "parsing failed for write_lp endpoint"}'
+        with self.assertRaises(InfluxDBError) as err:
+            self._test_api_error(response_body)
+        self.assertEqual('parsing failed for write_lp endpoint', err.exception.message)
+
+    def test_api_error_oss_with_detail(self):
+        response_body = ('{"error":"parsing failed for write_lp endpoint","data":{"error_message":"invalid field value '
+                         'in line protocol for field \'val\' on line 1"}}')
+        with self.assertRaises(InfluxDBError) as err:
+            self._test_api_error(response_body)
+        self.assertEqual('invalid field value in line protocol for field \'val\' on line 1', err.exception.message)
+
+    def test_api_error_unknown(self):
+        response_body = '{"detail":"no info"}'
+        with self.assertRaises(InfluxDBError) as err:
+            self._test_api_error(response_body)
+        self.assertEqual(response_body, err.exception.message)
+
+    def test_api_error_headers(self):
+        body = '{"error": "test error"}'
+        body_dic = json.loads(body)
+        conf = Configuration()
+        local_client = ApiClient(conf)
+        traceid = "123456789ABCDEF0"
+        requestid = uuid.uuid4().__str__()
+
+        local_client.rest_client.pool_manager.request = mock.Mock(
+            return_value=response.HTTPResponse(
+                status=400,
+                reason='Bad Request',
+                headers={
+                    'Trace-Id': traceid,
+                    'Trace-Sampled': 'false',
+                    'X-Influxdb-Request-Id': requestid,
+                    'X-Influxdb-Build': 'Mock'
+                },
+                body=body.encode()
+            )
+        )
+        with self.assertRaises(InfluxDBError) as err:
+            service = WriteService(local_client)
+            service.post_write("TEST_ORG", "TEST_BUCKET", "data,foo=bar val=3.14")
+        self.assertEqual(body_dic['error'], err.exception.message)
+        headers = err.exception.getheaders()
+        self.assertEqual(4, len(headers))
+        self.assertEqual(headers['Trace-Id'], traceid)
+        self.assertEqual(headers['Trace-Sampled'], 'false')
+        self.assertEqual(headers['X-Influxdb-Request-Id'], requestid)
+        self.assertEqual(headers['X-Influxdb-Build'], 'Mock')

{influxdb3_python-0.7.0 → influxdb3_python-0.9.0}/tests/test_influxdb_client_3.py

@@ -27,6 +27,27 @@ class TestInfluxDBClient3(unittest.TestCase):
         self.assertEqual(self.client._write_api, self.mock_write_api.return_value)
         self.assertEqual(self.client._query_api, self.mock_query_api.return_value)
 
+    # test default token auth_scheme
+    def test_token_auth_scheme_default(self):
+        client = InfluxDBClient3(
+            host="localhost",
+            org="my_org",
+            database="my_db",
+            token="my_token",
+        )
+        self.assertEqual(client._client.auth_header_value, "Token my_token")
+
+    # test explicit token auth_scheme
+    def test_token_auth_scheme_explicit(self):
+        client = InfluxDBClient3(
+            host="localhost",
+            org="my_org",
+            database="my_db",
+            token="my_token",
+            auth_scheme="my_scheme"
+        )
+        self.assertEqual(client._client.auth_header_value, "my_scheme my_token")
+
 
 if __name__ == '__main__':
     unittest.main()

influxdb3_python-0.9.0/tests/test_influxdb_client_3_integration.py

@@ -0,0 +1,74 @@
+import os
+import time
+import unittest
+
+import pytest
+
+from influxdb_client_3 import InfluxDBClient3, InfluxDBError
+
+
+@pytest.mark.integration
+@pytest.mark.skipif(
+    not all(
+        [
+            os.getenv('TESTING_INFLUXDB_URL'),
+            os.getenv('TESTING_INFLUXDB_TOKEN'),
+            os.getenv('TESTING_INFLUXDB_DATABASE'),
+        ]
+    ),
+    reason="Integration test environment variables not set.",
+)
+class TestInfluxDBClient3Integration(unittest.TestCase):
+
+    def setUp(self):
+        self.host = os.getenv('TESTING_INFLUXDB_URL')
+        self.token = os.getenv('TESTING_INFLUXDB_TOKEN')
+        self.database = os.getenv('TESTING_INFLUXDB_DATABASE')
+        self.client = InfluxDBClient3(host=self.host, database=self.database, token=self.token)
+
+    def tearDown(self):
+        if self.client:
+            self.client.close()
+
+    def test_write_and_query(self):
+        test_id = time.time_ns()
+        self.client.write(f"integration_test_python,type=used value=123.0,test_id={test_id}i")
+
+        sql = 'SELECT * FROM integration_test_python where type=$type and test_id=$test_id'
+
+        df = self.client.query(sql, mode="pandas", query_parameters={'type': 'used', 'test_id': test_id})
+
+        self.assertIsNotNone(df)
+        self.assertEqual(1, len(df))
+        self.assertEqual(test_id, df['test_id'][0])
+        self.assertEqual(123.0, df['value'][0])
+
+    def test_auth_error_token(self):
+        self.client = InfluxDBClient3(host=self.host, database=self.database, token='fake token')
+        test_id = time.time_ns()
+        with self.assertRaises(InfluxDBError) as err:
+            self.client.write(f"integration_test_python,type=used value=123.0,test_id={test_id}i")
+        self.assertEqual('unauthorized access', err.exception.message)  # Cloud
+
+    def test_auth_error_auth_scheme(self):
+        self.client = InfluxDBClient3(host=self.host, database=self.database, token=self.token, auth_scheme='Any')
+        test_id = time.time_ns()
+        with self.assertRaises(InfluxDBError) as err:
+            self.client.write(f"integration_test_python,type=used value=123.0,test_id={test_id}i")
+        self.assertEqual('unauthorized access', err.exception.message)  # Cloud
+
+    def test_error_headers(self):
+        self.client = InfluxDBClient3(host=self.host, database=self.database, token=self.token)
+        with self.assertRaises(InfluxDBError) as err:
+            self.client.write("integration_test_python,type=used value=123.0,test_id=")
+        self.assertIn("Could not parse entire line. Found trailing content:", err.exception.message)
+        headers = err.exception.getheaders()
+        try:
+            self.assertIsNotNone(headers)
+            self.assertRegex(headers['trace-id'], '[0-9a-f]{16}')
+            self.assertEqual('false', headers['trace-sampled'])
+            self.assertIsNotNone(headers['Strict-Transport-Security'])
+            self.assertRegex(headers['X-Influxdb-Request-ID'], '[0-9a-f]+')
+            self.assertIsNotNone(headers['X-Influxdb-Build'])
+        except KeyError as ke:
+            self.fail(f'Header {ke} not found')

influxdb3_python-0.7.0/tests/test_polars_dataframe_serializer.py → influxdb3_python-0.9.0/tests/test_polars.py

@@ -1,7 +1,9 @@
-import unittest
 import importlib.util
+import unittest
+from unittest.mock import Mock
 
-from influxdb_client_3 import PointSettings
+from influxdb_client_3 import PointSettings, InfluxDBClient3
+from influxdb_client_3.write_client import WriteService
 from influxdb_client_3.write_client.client.write.polars_dataframe_serializer import polars_data_frame_to_list_of_points
 
 
@@ -29,3 +31,33 @@ class TestPolarsDataFrameSerializer(unittest.TestCase):
             'iot-devices,building=5a name="iot-devices",temperature=72.2 1664798460000000000'
         ]
         self.assertEqual(expected, actual)
+
+
+@unittest.skipIf(importlib.util.find_spec("polars") is None, 'Polars package not installed')
+class TestWritePolars(unittest.TestCase):
+    def setUp(self):
+        self.client = InfluxDBClient3(
+            host="localhost",
+            org="my_org",
+            database="my_db",
+            token="my_token"
+        )
+
+    def test_write_polars(self):
+        import polars as pl
+        df = pl.DataFrame({
+            "time": pl.Series(["2024-08-01 00:00:00", "2024-08-01 01:00:00"]).str.to_datetime(time_unit='ns'),
+            "temperature": [22.4, 21.8],
+        })
+        self.client._write_api._write_service = Mock(spec=WriteService)
+
+        self.client.write(
+            database="database",
+            record=df,
+            data_frame_measurement_name="measurement",
+            data_frame_timestamp_column="time",
+        )
+
+        actual = self.client._write_api._write_service.post_write.call_args[1]['body']
+        self.assertEqual(b'measurement temperature=22.4 1722470400000000000\n'
+                         b'measurement temperature=21.8 1722474000000000000', actual)

influxdb3_python-0.7.0/tests/test_api_client.py

@@ -1,71 +0,0 @@
-import unittest
-from unittest import mock
-
-from influxdb_client_3.write_client._sync.api_client import ApiClient
-from influxdb_client_3.write_client.configuration import Configuration
-from influxdb_client_3.write_client.service import WriteService
-from influxdb_client_3.version import VERSION
-
-
-_package = "influxdb3-python"
-_sentHeaders = {}
-
-
-def mock_rest_request(method,
-                      url,
-                      query_params=None,
-                      headers=None,
-                      body=None,
-                      post_params=None,
-                      _preload_content=True,
-                      _request_timeout=None,
-                      **urlopen_kw):
-    class MockResponse:
-        def __init__(self, data, status_code):
-            self.data = data
-            self.status_code = status_code
-
-        def data(self):
-            return self.data
-
-    global _sentHeaders
-    _sentHeaders = headers
-
-    return MockResponse(None, 200)
-
-
-class ApiClientTests(unittest.TestCase):
-
-    def test_default_headers(self):
-        global _package
-        conf = Configuration()
-        client = ApiClient(conf,
-                           header_name="Authorization",
-                           header_value="Bearer TEST_TOKEN")
-        self.assertIsNotNone(client.default_headers["User-Agent"])
-        self.assertIsNotNone(client.default_headers["Authorization"])
-        self.assertEqual(f"{_package}/{VERSION}", client.default_headers["User-Agent"])
-        self.assertEqual("Bearer TEST_TOKEN", client.default_headers["Authorization"])
-
-    @mock.patch("influxdb_client_3.write_client._sync.rest.RESTClientObject.request",
-                side_effect=mock_rest_request)
-    def test_call_api(self, mock_post):
-        global _package
-        global _sentHeaders
-        _sentHeaders = {}
-
-        conf = Configuration()
-        client = ApiClient(conf,
-                           header_name="Authorization",
-                           header_value="Bearer TEST_TOKEN")
-        service = WriteService(client)
-        service.post_write("TEST_ORG", "TEST_BUCKET", "data,foo=bar val=3.14")
-        self.assertEqual(4, len(_sentHeaders.keys()))
-        self.assertIsNotNone(_sentHeaders["Accept"])
-        self.assertEqual("application/json", _sentHeaders["Accept"])
-        self.assertIsNotNone(_sentHeaders["Content-Type"])
-        self.assertEqual("text/plain", _sentHeaders["Content-Type"])
-        self.assertIsNotNone(_sentHeaders["Authorization"])
-        self.assertEqual("Bearer TEST_TOKEN", _sentHeaders["Authorization"])
-        self.assertIsNotNone(_sentHeaders["User-Agent"])
-        self.assertEqual(f"{_package}/{VERSION}", _sentHeaders["User-Agent"])

influxdb3_python-0.7.0/tests/test_influxdb_client_3_integration.py

@@ -1,45 +0,0 @@
-import os
-import time
-import unittest
-
-import pytest
-
-from influxdb_client_3 import InfluxDBClient3
-
-
-@pytest.mark.integration
-@pytest.mark.skipif(
-    not all(
-        [
-            os.getenv('TESTING_INFLUXDB_URL'),
-            os.getenv('TESTING_INFLUXDB_TOKEN'),
-            os.getenv('TESTING_INFLUXDB_DATABASE'),
-        ]
-    ),
-    reason="Integration test environment variables not set.",
-)
-class TestInfluxDBClient3Integration(unittest.TestCase):
-
-    def setUp(self):
-        host = os.getenv('TESTING_INFLUXDB_URL')
-        token = os.getenv('TESTING_INFLUXDB_TOKEN')
-        database = os.getenv('TESTING_INFLUXDB_DATABASE')
-
-        self.client = InfluxDBClient3(host=host, database=database, token=token)
-
-    def tearDown(self):
-        if self.client:
-            self.client.close()
-
-    def test_write_and_query(self):
-        test_id = time.time_ns()
-        self.client.write(f"integration_test_python,type=used value=123.0,test_id={test_id}i")
-
-        sql = 'SELECT * FROM integration_test_python where type=$type and test_id=$test_id'
-
-        df = self.client.query(sql, mode="pandas", query_parameters={'type': 'used', 'test_id': test_id})
-
-        self.assertIsNotNone(df)
-        self.assertEqual(1, len(df))
-        self.assertEqual(test_id, df['test_id'][0])
-        self.assertEqual(123.0, df['value'][0])