influxdb3-python 0.17.0__tar.gz → 0.18.0__tar.gz

influxdb3_python-0.18.0/Examples/query_with_middleware.py

@@ -0,0 +1,33 @@
+from pyarrow import flight
+
+from config import Config
+from influxdb_client_3 import InfluxDBClient3, flight_client_options
+
+
+# This middleware will add an additional attribute `some-attribute` to the header
+class ModifyHeaderClientMiddleware(flight.ClientMiddleware):
+    def sending_headers(self):
+        return {
+            "some-attribute": "some-value",
+        }
+
+    def received_headers(self, headers):
+        pass
+
+
+class ModifyHeaderClientMiddlewareFactory(flight.ClientMiddlewareFactory):
+    def start_call(self, info):
+        return ModifyHeaderClientMiddleware()
+
+
+config = Config()
+middleware = [ModifyHeaderClientMiddlewareFactory()]
+client = InfluxDBClient3(
+    host=config.host,
+    token=config.token,
+    database=config.database,
+    flight_client_options=flight_client_options(middleware=middleware)
+)
+
+df = client.query(query="select * from cpu11 limit 10", mode="pandas")
+print(len(df))

{influxdb3_python-0.17.0 → influxdb3_python-0.18.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: influxdb3-python
-Version: 0.17.0
+Version: 0.18.0
 Summary: Community Python client for InfluxDB 3.0
 Home-page: https://github.com/InfluxCommunity/influxdb3-python
 Author: InfluxData
@@ -53,6 +53,9 @@ Dynamic: summary
 </p>
 
 <p align="center">
+    <a href="https://influxdb3-python.readthedocs.io/en/latest/">
+        <img src="https://img.shields.io/readthedocs/influxdb3-python/latest" alt="Readthedocs document">
+    </a>
     <a href="https://pypi.org/project/influxdb3-python/">
         <img src="https://img.shields.io/pypi/v/influxdb3-python.svg" alt="PyPI version">
     </a>

{influxdb3_python-0.17.0 → influxdb3_python-0.18.0}/README.md

@@ -4,6 +4,9 @@
 </p>
 
 <p align="center">
+    <a href="https://influxdb3-python.readthedocs.io/en/latest/">
+        <img src="https://img.shields.io/readthedocs/influxdb3-python/latest" alt="Readthedocs document">
+    </a>
     <a href="https://pypi.org/project/influxdb3-python/">
         <img src="https://img.shields.io/pypi/v/influxdb3-python.svg" alt="PyPI version">
     </a>

{influxdb3_python-0.17.0 → influxdb3_python-0.18.0}/influxdb3_python.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: influxdb3-python
-Version: 0.17.0
+Version: 0.18.0
 Summary: Community Python client for InfluxDB 3.0
 Home-page: https://github.com/InfluxCommunity/influxdb3-python
 Author: InfluxData
@@ -53,6 +53,9 @@ Dynamic: summary
 </p>
 
 <p align="center">
+    <a href="https://influxdb3-python.readthedocs.io/en/latest/">
+        <img src="https://img.shields.io/readthedocs/influxdb3-python/latest" alt="Readthedocs document">
+    </a>
     <a href="https://pypi.org/project/influxdb3-python/">
         <img src="https://img.shields.io/pypi/v/influxdb3-python.svg" alt="PyPI version">
     </a>

{influxdb3_python-0.17.0 → influxdb3_python-0.18.0}/influxdb3_python.egg-info/SOURCES.txt

@@ -14,6 +14,7 @@ Examples/handle_query_error.py
 Examples/pandas_write.py
 Examples/query_async.py
 Examples/query_type.py
+Examples/query_with_middleware.py
 Examples/timeouts.py
 influxdb3_python.egg-info/PKG-INFO
 influxdb3_python.egg-info/SOURCES.txt

{influxdb3_python-0.17.0 → influxdb3_python-0.18.0}/influxdb_client_3/exceptions/exceptions.py

@@ -63,9 +63,41 @@ class InfluxDBError(InfluxDB3ClientError):
             def get(d, key):
                 if not key or d is None:
                     return d
+                if not isinstance(d, dict):
+                    return None
                 return get(d.get(key[0]), key[1:])
             try:
                 node = json.loads(response.data)
+                if isinstance(node, dict):
+                    # InfluxDB v3 error format: { "code": "...", "message": "..." }
+                    code = node.get("code")
+                    message = node.get("message")
+                    if message:
+                        return f"{code}: {message}" if code else message
+                    # InfluxDB v3 write error format:
+                    # {
+                    #   "error": "...",
+                    #   "data": [ { "error_message": "...", "line_number": 2, "original_line": "..." }, ... ]
+                    # }
+                    error_text = node.get("error")
+                    data = node.get("data")
+                    if error_text and isinstance(data, list):
+                        details = []
+                        for item in data:
+                            if not isinstance(item, dict):
+                                continue
+                            line_number = item.get("line_number")
+                            error_message = item.get("error_message")
+                            original_line = item.get("original_line")
+                            if line_number is not None and error_message and original_line:
+                                details.append(
+                                    f"\tline {line_number}: {error_message} ({original_line})"
+                                )
+                            elif error_message:
+                                details.append(f"\t{error_message}")
+                        if details:
+                            return error_text + ":\n" + "\n".join(details)
+                        return error_text
                 for key in [['message'], ['data', 'error_message'], ['error']]:
                     value = get(node, key)
                     if value is not None:

{influxdb3_python-0.17.0 → influxdb3_python-0.18.0}/influxdb_client_3/query/query_api.py

@@ -20,6 +20,7 @@ class QueryApiOptions(object):
     flight_client_options (dict): base set of flight client options passed to internal pyarrow.flight.FlightClient
     timeout(float): timeout in seconds to wait for a response
     disable_grpc_compression (bool): disable gRPC compression for query responses
+    middleware (list): list of middleware functions to be applied to Flight calls
     """
     _DEFAULT_TIMEOUT = 300.0
     tls_root_certs: bytes = None
@@ -28,13 +29,15 @@ class QueryApiOptions(object):
     flight_client_options: dict = None
     timeout: float = None
     disable_grpc_compression: bool = False
+    middleware: list = None
 
     def __init__(self, root_certs_path: str,
                  verify: bool,
                  proxy: str,
                  flight_client_options: dict,
                  timeout: float = _DEFAULT_TIMEOUT,
-                 disable_grpc_compression: bool = False):
+                 disable_grpc_compression: bool = False,
+                 middleware: list = None):
         """
         Initialize a set of QueryApiOptions
 
@@ -45,6 +48,7 @@ class QueryApiOptions(object):
                to be passed to internal pyarrow.flight.FlightClient.
         :param timeout: timeout in seconds to wait for a response.
         :param disable_grpc_compression: disable gRPC compression for query responses.
+        :param middleware: list of middleware functions to be applied to Flight calls.
         """
         if root_certs_path:
             self.tls_root_certs = self._read_certs(root_certs_path)
@@ -53,6 +57,7 @@ class QueryApiOptions(object):
         self.flight_client_options = flight_client_options
         self.timeout = timeout
         self.disable_grpc_compression = disable_grpc_compression
+        self.middleware = middleware
 
     def _read_certs(self, path: str) -> bytes:
         with open(path, "rb") as certs_file:
@@ -81,6 +86,7 @@ class QueryApiOptionsBuilder(object):
     _flight_client_options: dict = None
     _timeout: float = None
     _disable_grpc_compression: bool = False
+    _middleware: list = None
 
     def root_certs(self, path: str):
         self._root_certs_path = path
@@ -107,6 +113,10 @@ class QueryApiOptionsBuilder(object):
         self._disable_grpc_compression = disable
         return self
 
+    def middleware(self, middleware: list):
+        self._middleware = middleware
+        return self
+
     def build(self) -> QueryApiOptions:
         """Build a QueryApiOptions object with previously set values"""
         return QueryApiOptions(
@@ -116,6 +126,7 @@ class QueryApiOptionsBuilder(object):
             flight_client_options=self._flight_client_options,
             timeout=self._timeout,
             disable_grpc_compression=self._disable_grpc_compression,
+            middleware=self._middleware
         )
 
 
@@ -181,6 +192,8 @@ class QueryApi(object):
                 self._flight_client_options["generic_options"].append(
                     ("grpc.compression_enabled_algorithms_bitset", 1)
                 )
+            if options.middleware:
+                self._flight_client_options["middleware"] = options.middleware
         if self._proxy:
             self._flight_client_options["generic_options"].append(("grpc.http_proxy", self._proxy))
         self._flight_client = FlightClient(connection_string, **self._flight_client_options)

{influxdb3_python-0.17.0 → influxdb3_python-0.18.0}/influxdb_client_3/version.py

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

{influxdb3_python-0.17.0 → influxdb3_python-0.18.0}/influxdb_client_3/write_client/client/write_api.py

@@ -296,9 +296,7 @@ class WriteApi(_BaseWriteApi):
 
         if self._write_options.write_type is WriteType.asynchronous:
             message = """The 'WriteType.asynchronous' is deprecated and will be removed in future major version.
-
-You can use native asynchronous version of the client:
-- https://influxdb-client.readthedocs.io/en/stable/usage.html#how-to-use-asyncio
+            You can use native asynchronous version of the client:
         """
             # TODO above message has link to Influxdb2 API __NOT__ Influxdb3 API !!! - illustrates different API
             warnings.warn(message, DeprecationWarning)
@@ -393,12 +391,9 @@ You can use native asynchronous version of the client:
 
         _async_req = True if self._write_options.write_type == WriteType.asynchronous else False
 
-        # Filter out serializer-specific kwargs before passing to _post_write
-        http_kwargs = {k: v for k, v in kwargs.items() if k not in SERIALIZER_KWARGS}
-
         def write_payload(payload):
             final_string = b'\n'.join(payload[1])
-            return self._post_write(_async_req, bucket, org, final_string, payload[0], no_sync, **http_kwargs)
+            return self._post_write(_async_req, bucket, org, final_string, payload[0], no_sync, **kwargs)
 
         results = list(map(write_payload, payloads.items()))
         if not _async_req:
@@ -588,11 +583,13 @@ You can use native asynchronous version of the client:
         return _BatchResponse(data=batch_item)
 
     def _post_write(self, _async_req, bucket, org, body, precision, no_sync, **kwargs):
+        # Filter out serializer-specific kwargs before passing to _post_write
+        http_kwargs = {k: v for k, v in kwargs.items() if k not in SERIALIZER_KWARGS}
         return self._write_service.post_write(org=org, bucket=bucket, body=body, precision=precision,
                                               no_sync=no_sync,
                                               async_req=_async_req,
                                               content_type="text/plain; charset=utf-8",
-                                              **kwargs)
+                                              **http_kwargs)
 
     def _to_response(self, data: _BatchItem, delay: timedelta):
 

{influxdb3_python-0.17.0 → influxdb3_python-0.18.0}/tests/test_api_client.py

@@ -124,6 +124,58 @@ class ApiClientTests(unittest.TestCase):
             self._test_api_error(response_body)
         self.assertEqual(response_body, err.exception.message)
 
+    def test_api_error_v3_with_detail(self):
+        cases = [
+            # all details available
+            (
+                "two-line details",
+                '{"error":"partial write of line protocol occurred","data":['
+                '{"error_message":"invalid column type for column \'v\', expected iox::column_type::field::float, '
+                'got iox::column_type::field::uinteger","line_number":2,"original_line":"**.DBG.remote_***"},'
+                '{"error_message":"invalid column type for column \'v\', expected iox::column_type::field::float, '
+                'got iox::column_type::field::uinteger","line_number":3,"original_line":"***.INF.remote_***"}'
+                ']}',
+                "partial write of line protocol occurred:\n"
+                "\tline 2: invalid column type for column 'v', expected iox::column_type::field::float, "
+                "got iox::column_type::field::uinteger (**.DBG.remote_***)\n"
+                "\tline 3: invalid column type for column 'v', expected iox::column_type::field::float, "
+                "got iox::column_type::field::uinteger (***.INF.remote_***)",
+            ),
+            # error_message only (no line_number/original_line)
+            (
+                "message-only detail",
+                '{"error":"partial write of line protocol occurred","data":['
+                '{"error_message":"only error message"}]}',
+                "partial write of line protocol occurred:\n"
+                "\tonly error message",
+            ),
+            # non-dict item in data list is skipped
+            (
+                "non-dict item skipped",
+                '{"error":"partial write of line protocol occurred","data":[null,'
+                '{"error_message":"bad line","line_number":2,"original_line":"bad lp"}]}',
+                "partial write of line protocol occurred:\n"
+                "\tline 2: bad line (bad lp)",
+            ),
+            # details empty -> return error_text
+            (
+                "no detail fields",
+                '{"error":"partial write of line protocol occurred","data":[{"line_number":2}]}',
+                "partial write of line protocol occurred",
+            ),
+            # data is not a dict when resolving fallback keys
+            (
+                "data not dict for fallback",
+                '{"error":"data not list","data":"oops"}',
+                "data not list",
+            ),
+        ]
+        for name, response_body, expected in cases:
+            with self.subTest(name):
+                with self.assertRaises(InfluxDBError) as err:
+                    self._test_api_error(response_body)
+                self.assertEqual(expected, err.exception.message)
+
     def test_api_error_headers(self):
         body = '{"error": "test error"}'
         body_dic = json.loads(body)

{influxdb3_python-0.17.0 → influxdb3_python-0.18.0}/tests/test_influxdb_client_3_integration.py

@@ -1,16 +1,18 @@
 import logging
 import os
-import pyarrow
-import pytest
 import random
 import string
 import time
 import unittest
 
+import pandas as pd
+import pyarrow
+import pytest
 from urllib3.exceptions import MaxRetryError, TimeoutError as Url3TimeoutError
 
 from influxdb_client_3 import InfluxDBClient3, write_client_options, WriteOptions, \
     WriteType, InfluxDB3ClientQueryError
+from influxdb_client_3.write_client.rest import ApiException
 from influxdb_client_3.exceptions import InfluxDBError
 from tests.util import asyncio_run, lp_to_py_object
 
@@ -48,6 +50,68 @@ class TestInfluxDBClient3Integration(unittest.TestCase):
         if self.client:
             self.client.close()
 
+    def test_write_dataframe(self):
+        measurement = f'test{random_hex(3)}'.lower()
+        df = pd.DataFrame({
+            'time': pd.to_datetime(['2024-01-01', '2024-01-02']),
+            'city': ['London', 'Paris'],
+            'temperature': [15.0, 18.5]
+        })
+        self.client.write_dataframe(df, measurement=measurement, timestamp_column='time', tags=['city'])
+        self.client.flush()
+
+        result = self.client.query(query=f"select * from {measurement}", mode="pandas")
+
+        self.assertIsNotNone(result)
+        self.assertEqual(2, len(result.get('city')))
+        self.assertEqual(2, len(result.get('temperature')))
+
+    def test_write_dataframe_with_batch(self):
+        self.client = InfluxDBClient3(host=self.host,
+                                      database=self.database,
+                                      token=self.token,
+                                      write_client_options=write_client_options(
+                                          write_options=WriteOptions(batch_size=100)
+                                      ))
+        measurement = f'test{random_hex(3)}'.lower()
+        df = pd.DataFrame({
+            'time': pd.to_datetime(['2024-01-01', '2024-01-02']),
+            'city': ['London', 'Paris'],
+            'temperature': [15.0, 18.5]
+        })
+        self.client.write_dataframe(
+            df,
+            measurement=measurement,
+            timestamp_column='time',
+            tags=['city']
+        )
+        self.client.flush()
+
+        result = self.client.query(query=f"select * from {measurement}", mode="pandas")
+
+        self.assertIsNotNone(result)
+        self.assertEqual(2, len(result.get('city')))
+        self.assertEqual(2, len(result.get('temperature')))
+
+    def test_write_csv_file_with_batch(self):
+        client = InfluxDBClient3(host=self.host,
+                                 database=self.database,
+                                 token=self.token,
+                                 write_client_options=write_client_options(
+                                     write_options=WriteOptions(batch_size=100)
+                                 ))
+        measurement = f'test{random_hex(3)}'.lower()
+        client.write_file(
+            measurement_name=measurement,
+            file='tests/data/iot.csv',
+            timestamp_column='time', tag_columns=["name"])
+        client.flush()
+
+        result = client.query(query=f"select * from {measurement}", mode="pandas")
+        self.assertIsNotNone(result)
+        self.assertEqual(3, len(result.get('building')))
+        self.assertEqual(3, len(result.get('temperature')))
+
     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")
@@ -61,6 +125,39 @@ class TestInfluxDBClient3Integration(unittest.TestCase):
         self.assertEqual(test_id, df['test_id'][0])
         self.assertEqual(123.0, df['value'][0])
 
+    def test_v3_error(self):
+        measurement = f'test{random_hex(3)}'.lower()
+        lp = "\n".join([
+            f"{measurement} v=1i 1770291280",
+            f"{measurement} v=1 1770291281",
+        ])
+
+        with InfluxDBClient3(
+            host=self.host,
+            database=self.database,
+            token=self.token,
+            write_client_options=write_client_options(
+                write_options=WriteOptions(
+                    write_type=WriteType.synchronous,
+                    no_sync=True
+                )
+            )
+        ) as client:
+            try:
+                client.write(lp)
+                self.fail("Expected InfluxDBError from invalid line protocol.")
+            except ApiException as err:
+                if "Server doesn't support write with no_sync=true" in str(err):
+                    self.skipTest("no_sync not supported by this server.")
+                msg = err.message
+                self.assertIn("partial write of line protocol occurred", msg)
+                self.assertIn((
+                    "invalid column type for column 'v', expected iox::column_type::field::integer, "
+                    "got iox::column_type::field::float"
+                ), msg)
+                self.assertIn("line 2", msg)
+                self.assertIn(measurement, msg)
+
     def test_auth_error_token(self):
         self.client = InfluxDBClient3(host=self.host, database=self.database, token='fake token')
         test_id = time.time_ns()

{influxdb3_python-0.17.0 → influxdb3_python-0.18.0}/tests/test_polars.py

@@ -96,6 +96,4 @@ class TestWritePolars(unittest.TestCase):
             async_req=ANY,
             content_type=ANY,
             urlopen_kw=ANY,
-            data_frame_measurement_name='measurement',
-            data_frame_timestamp_column='time',
             body=b'measurement temperature=22.4 1722470400000000000\nmeasurement temperature=21.8 1722474000000000000')

{influxdb3_python-0.17.0 → influxdb3_python-0.18.0}/tests/test_query.py

@@ -12,7 +12,7 @@ from pyarrow.flight import (
     Ticket
 )
 
-from influxdb_client_3 import InfluxDBClient3
+from influxdb_client_3 import InfluxDBClient3, flight_client_options
 from influxdb_client_3.query.query_api import QueryApiOptionsBuilder, QueryApi
 from influxdb_client_3.version import USER_AGENT
 from tests.util import asyncio_run
@@ -25,7 +25,8 @@ from tests.util.mocks import (
     HeaderCheckServerMiddlewareFactory,
     NoopAuthHandler,
     get_req_headers,
-    set_req_headers
+    set_req_headers, ModifyHeaderClientMiddlewareFactory,
+    HeaderCheckServerMiddlewareFactory1
 )
 
 
@@ -175,11 +176,13 @@ Aw==
         cert_chain = 'mTLS_explicit_chain'
         self.create_cert_file(cert_file)
         test_flight_client_options = {'private_key': private_key, 'cert_chain': cert_chain}
+        middleware = [ModifyHeaderClientMiddlewareFactory()]
         options = QueryApiOptionsBuilder()\
             .proxy(proxy_name) \
             .root_certs(cert_file) \
             .tls_verify(False) \
             .flight_client_options(test_flight_client_options) \
+            .middleware(middleware) \
             .build()
 
         client = QueryApi(connection,
@@ -195,6 +198,7 @@ Aw==
             assert client._flight_client_options['private_key'] == private_key
             assert client._flight_client_options['cert_chain'] == cert_chain
             assert client._proxy == proxy_name
+            assert client._flight_client_options['middleware'] == middleware
             fc_opts = client._flight_client_options
             assert dict(fc_opts['generic_options'])['grpc.secondary_user_agent'].startswith('influxdb3-python/')
             assert dict(fc_opts['generic_options'])['grpc.http_proxy'] == proxy_name
@@ -311,6 +315,41 @@ Aw==
                 assert _req_headers['authorization'] == [f"Bearer {token}"]
                 set_req_headers({})
 
+    def test_query_with_middleware_success(self):
+        with HeaderCheckFlightServer(
+                auth_handler=NoopAuthHandler(),
+                middleware={"check": HeaderCheckServerMiddlewareFactory1()}) as server:
+
+            middleware = [ModifyHeaderClientMiddlewareFactory()]
+            client = InfluxDBClient3(
+                host=f'http://localhost:{server.port}',
+                org='test_org',
+                databse='test_db',
+                token='TEST_TOKEN',
+                flight_client_options=flight_client_options(middleware=middleware)
+            )
+
+            df = client.query(query='SELECT * FROM test', mode="pandas")
+            self.assertIsNotNone(df)
+
+    def test_query_with_missing_middleware(self):
+        with HeaderCheckFlightServer(
+                auth_handler=NoopAuthHandler(),
+                middleware={"check": HeaderCheckServerMiddlewareFactory1()}) as server:
+
+            client = InfluxDBClient3(
+                host=f'http://localhost:{server.port}',
+                org='test_org',
+                databse='test_db',
+                token='TEST_TOKEN'
+            )
+
+            try:
+                client.query(query='SELECT * FROM test', mode="pandas")
+                self.fail("Should have failed due to missing middleware")
+            except Exception as e:
+                assert "Invalid header value from middleware" in str(e)
+
     @asyncio_run
     async def test_query_async_pandas(self):
         with ConstantFlightServer() as server: