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

influxdb3_python-0.10.0/Examples/batching_example.py

@@ -0,0 +1,141 @@
+import datetime
+import random
+import time
+
+from bson import ObjectId
+
+import influxdb_client_3 as InfluxDBClient3
+from influxdb_client_3 import write_client_options, WritePrecision, WriteOptions, InfluxDBError
+
+from config import Config
+
+
+class BatchingCallback(object):
+
+    def __init__(self):
+        self.write_status_msg = None
+        self.write_count = 0
+        self.retry_count = 0
+        self.start = time.time_ns()
+
+    def success(self, conf, data: str):
+        print(f"Written batch: {conf}, data: {data}")
+        self.write_count += 1
+        self.write_status_msg = f"SUCCESS: {self.write_count} writes"
+
+    def error(self, conf, data: str, exception: InfluxDBError):
+        print(f"Cannot write batch: {conf}, data: {data} due: {exception}")
+        self.write_status_msg = f"FAILURE - cause: {exception}"
+
+    def retry(self, conf, data: str, exception: InfluxDBError):
+        print(f"Retryable error occurs for batch: {conf}, data: {data} retry: {exception}")
+        self.retry_count += 1
+
+    def elapsed(self) -> int:
+        return time.time_ns() - self.start
+
+
+def main() -> None:
+    conf = Config()
+
+    # 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
+    sample_window_days = 7
+    now = datetime.datetime.now()
+    now = now - datetime.timedelta(days=sample_window_days)
+    target_sample_count = sample_window_days * 24 * 60 * 6
+
+    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,
+                                 max_close_wait=600_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=conf.token,
+                                         host=conf.host,
+                                         org=conf.org,
+                                         database=conf.database,
+                                         enable_gzip=True,
+                                         write_client_options=wco) as _client:
+        # Creating iterator for one hour worth of data (6 sensor readings per
+        # minute)
+        print(f"Writing {target_sample_count} data points.")
+        for i in range(0, target_sample_count):
+            # 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)
+
+    print(callback.write_status_msg)
+    print(f"Write retries: {callback.retry_count}")
+    print(f"Wrote {target_sample_count} data points.")
+    print(f"Elapsed time ms: {int(callback.elapsed() / 1_000_000)}")
+
+
+if __name__ == "__main__":
+    main()

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: influxdb3-python
-Version: 0.9.0
+Version: 0.10.0
 Summary: Community Python client for InfluxDB 3.0
 Home-page: https://github.com/InfluxCommunity/influxdb3-python
 Author: InfluxData
@@ -13,6 +13,7 @@ Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
 Requires-Python: >=3.8
 Description-Content-Type: text/markdown
 License-File: LICENSE
@@ -127,7 +128,11 @@ from influxdb_client_3 import write_client_options, WritePrecision, WriteOptions
 
 class BatchingCallback(object):
 
+    def __init__(self):
+        self.write_count = 0
+
     def success(self, conf, data: str):
+        self.write_count += 1
         print(f"Written batch: {conf}, data: {data}")
 
     def error(self, conf, data: str, exception: InfluxDBError):
@@ -138,7 +143,7 @@ class BatchingCallback(object):
 
 callback = BatchingCallback()
 
-write_options = WriteOptions(batch_size=500,
+write_options = WriteOptions(batch_size=100,
                                         flush_interval=10_000,
                                         jitter_interval=2_000,
                                         retry_interval=5_000,
@@ -163,10 +168,7 @@ with  InfluxDBClient3.InfluxDBClient3(
         file='./out.csv',
         timestamp_column='time', tag_columns=["provider", "machineID"])
 
-    client.write_file(
-        file='./out.json',
-        timestamp_column='time', tag_columns=["provider", "machineID"], date_unit='ns' )
-
+print(f'DONE writing from csv in {callback.write_count} batch(es)')
 
 ```
 

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

@@ -92,7 +92,11 @@ from influxdb_client_3 import write_client_options, WritePrecision, WriteOptions
 
 class BatchingCallback(object):
 
+    def __init__(self):
+        self.write_count = 0
+
     def success(self, conf, data: str):
+        self.write_count += 1
         print(f"Written batch: {conf}, data: {data}")
 
     def error(self, conf, data: str, exception: InfluxDBError):
@@ -103,7 +107,7 @@ class BatchingCallback(object):
 
 callback = BatchingCallback()
 
-write_options = WriteOptions(batch_size=500,
+write_options = WriteOptions(batch_size=100,
                                         flush_interval=10_000,
                                         jitter_interval=2_000,
                                         retry_interval=5_000,
@@ -128,10 +132,7 @@ with  InfluxDBClient3.InfluxDBClient3(
         file='./out.csv',
         timestamp_column='time', tag_columns=["provider", "machineID"])
 
-    client.write_file(
-        file='./out.json',
-        timestamp_column='time', tag_columns=["provider", "machineID"], date_unit='ns' )
-
+print(f'DONE writing from csv in {callback.write_count} batch(es)')
 
 ```
 

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: influxdb3-python
-Version: 0.9.0
+Version: 0.10.0
 Summary: Community Python client for InfluxDB 3.0
 Home-page: https://github.com/InfluxCommunity/influxdb3-python
 Author: InfluxData
@@ -13,6 +13,7 @@ Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
 Requires-Python: >=3.8
 Description-Content-Type: text/markdown
 License-File: LICENSE
@@ -127,7 +128,11 @@ from influxdb_client_3 import write_client_options, WritePrecision, WriteOptions
 
 class BatchingCallback(object):
 
+    def __init__(self):
+        self.write_count = 0
+
     def success(self, conf, data: str):
+        self.write_count += 1
         print(f"Written batch: {conf}, data: {data}")
 
     def error(self, conf, data: str, exception: InfluxDBError):
@@ -138,7 +143,7 @@ class BatchingCallback(object):
 
 callback = BatchingCallback()
 
-write_options = WriteOptions(batch_size=500,
+write_options = WriteOptions(batch_size=100,
                                         flush_interval=10_000,
                                         jitter_interval=2_000,
                                         retry_interval=5_000,
@@ -163,10 +168,7 @@ with  InfluxDBClient3.InfluxDBClient3(
         file='./out.csv',
         timestamp_column='time', tag_columns=["provider", "machineID"])
 
-    client.write_file(
-        file='./out.json',
-        timestamp_column='time', tag_columns=["provider", "machineID"], date_unit='ns' )
-
+print(f'DONE writing from csv in {callback.write_count} batch(es)')
 
 ```
 

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

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

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

@@ -461,7 +461,8 @@ You can use native asynchronous version of the client:
                                  precision, **kwargs)
 
         elif 'polars' in str(type(data)):
-            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(data,
                                                    self._point_settings, precision,
                                                    self._write_options.batch_size, **kwargs)

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

@@ -65,5 +65,6 @@ setup(
         'Programming Language :: Python :: 3.10',
         'Programming Language :: Python :: 3.11',
         'Programming Language :: Python :: 3.12',
+        'Programming Language :: Python :: 3.13',
     ]
 )

influxdb3_python-0.10.0/tests/test_influxdb_client_3_integration.py

@@ -0,0 +1,186 @@
+import logging
+import os
+import random
+import string
+import time
+import unittest
+
+import pyarrow
+import pytest
+
+from influxdb_client_3 import InfluxDBClient3, InfluxDBError, write_client_options, WriteOptions
+
+
+def random_hex(len=6):
+    return ''.join(random.choice(string.hexdigits) for i in range(len))
+
+
+@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):
+
+    @pytest.fixture(autouse=True)
+    def inject_fixtures(self, caplog):
+        self._caplog = caplog
+
+    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):
+        self._caplog.clear()
+        self._caplog.set_level(logging.ERROR)
+        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')
+
+    def test_batch_write_callbacks(self):
+        write_success = False
+        write_error = False
+        write_count = 0
+
+        measurement = f'test{random_hex(6)}'
+        data_set_size = 40
+        batch_size = 10
+
+        def success(conf, data):
+            nonlocal write_success, write_count
+            write_success = True
+            write_count += 1
+
+        def error(conf, data, exception: InfluxDBError):
+            nonlocal write_error
+            write_error = True
+
+        w_opts = WriteOptions(
+            batch_size=batch_size,
+            flush_interval=1_000,
+            jitter_interval=500
+        )
+
+        wc_opts = write_client_options(
+            success_callback=success,
+            error_callback=error,
+            write_options=w_opts
+        )
+
+        now = time.time_ns()
+        with InfluxDBClient3(host=self.host,
+                             database=self.database,
+                             token=self.token,
+                             write_client_options=wc_opts) as w_client:
+
+            for i in range(0, data_set_size):
+                w_client.write(f'{measurement},location=harfa val={i}i {now - (i * 1_000_000_000)}')
+
+        self.assertEqual(data_set_size / batch_size, write_count)
+        self.assertTrue(write_success)
+        self.assertFalse(write_error)
+
+        with InfluxDBClient3(host=self.host,
+                             database=self.database,
+                             token=self.token,
+                             write_client_options=wc_opts) as r_client:
+
+            query = f"SELECT * FROM \"{measurement}\" WHERE time >= now() - interval '3 minute'"
+            reader: pyarrow.Table = r_client.query(query)
+            list_results = reader.to_pylist()
+            self.assertEqual(data_set_size, len(list_results))
+
+    def test_batch_write_closed(self):
+
+        self._caplog.set_level(logging.DEBUG)
+        # writing measurement for last cca 3hrs
+        # so repeat runs in that time frame could
+        # result in clashed result data if always
+        # using same measurement name
+        measurement = f'test{random_hex()}'
+        data_size = 10_000
+        w_opts = WriteOptions(
+            batch_size=100,
+            flush_interval=3_000,
+            jitter_interval=500
+        )
+
+        wc_opts = write_client_options(
+            write_options=w_opts
+        )
+
+        now = time.time_ns()
+        with InfluxDBClient3(host=self.host,
+                             database=self.database,
+                             token=self.token,
+                             write_client_options=wc_opts,
+                             debug=True) as w_client:
+
+            for i in range(0, data_size):
+                w_client.write(f'{measurement},location=harfa val={i}i {now - (i * 1_000_000_000)}')
+
+        lines = self._caplog.text.splitlines()
+        self.assertRegex(lines[len(lines) - 1], ".*the batching processor was disposed$")
+
+        logging.info("WRITING DONE")
+        with InfluxDBClient3(host=self.host,
+                             database=self.database,
+                             token=self.token,
+                             write_client_options=wc_opts) as r_client:
+
+            logging.info("PREPARING QUERY")
+
+            query = f"SELECT * FROM \"{measurement}\" WHERE time >= now() - interval '3 hours'"
+            reader: pyarrow.Table = r_client.query(query, mode="")
+            list_results = reader.to_pylist()
+            self.assertEqual(data_size, len(list_results))

{influxdb3_python-0.9.0 → influxdb3_python-0.10.0}/tests/test_polars.py

@@ -2,7 +2,7 @@ import importlib.util
 import unittest
 from unittest.mock import Mock
 
-from influxdb_client_3 import PointSettings, InfluxDBClient3
+from influxdb_client_3 import PointSettings, InfluxDBClient3, write_client_options, WriteOptions
 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
 
@@ -61,3 +61,31 @@ class TestWritePolars(unittest.TestCase):
         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)
+
+    def test_write_polars_batching(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 = InfluxDBClient3(
+            host="localhost",
+            org="my_org",
+            database="my_db",
+            token="my_token", write_client_options=write_client_options(
+                write_options=WriteOptions(batch_size=2)
+            )
+        )
+        self.client._write_api._write_options = WriteOptions(batch_size=2)
+        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.9.0/Examples/batching_example.py

@@ -1,114 +0,0 @@
-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/tests/test_influxdb_client_3_integration.py

@@ -1,74 +0,0 @@
-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')