influxdb3-python 0.6.1__tar.gz → 0.8.0__tar.gz

{influxdb3_python-0.6.1 → influxdb3_python-0.8.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: influxdb3-python
-Version: 0.6.1
+Version: 0.8.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.6.1 → influxdb3_python-0.8.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.6.1 → influxdb3_python-0.8.0}/influxdb3_python.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: influxdb3-python
-Version: 0.6.1
+Version: 0.8.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.6.1 → influxdb3_python-0.8.0}/influxdb3_python.egg-info/SOURCES.txt

@@ -34,6 +34,7 @@ influxdb_client_3/write_client/client/util/multiprocessing_helper.py
 influxdb_client_3/write_client/client/write/__init__.py
 influxdb_client_3/write_client/client/write/dataframe_serializer.py
 influxdb_client_3/write_client/client/write/point.py
+influxdb_client_3/write_client/client/write/polars_dataframe_serializer.py
 influxdb_client_3/write_client/client/write/retry.py
 influxdb_client_3/write_client/domain/__init__.py
 influxdb_client_3/write_client/domain/write_precision.py
@@ -50,4 +51,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_query.py
+tests/test_polars.py
+tests/test_query.py
+tests/test_write_file.py

{influxdb3_python-0.6.1 → influxdb3_python-0.8.0}/influxdb_client_3/__init__.py

@@ -1,5 +1,4 @@
 import urllib.parse
-
 import pyarrow as pa
 import importlib.util
 
@@ -111,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.6.1 → influxdb3_python-0.8.0}/influxdb_client_3/version.py

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

{influxdb3_python-0.6.1 → influxdb3_python-0.8.0}/influxdb_client_3/write_client/client/_base.py

@@ -7,8 +7,7 @@ import logging
 import os
 from typing import Iterable
 
-from influxdb_client_3.write_client.client.write.dataframe_serializer import DataframeSerializer, \
-    PolarsDataframeSerializer
+from influxdb_client_3.write_client.client.write.dataframe_serializer import DataframeSerializer
 from influxdb_client_3.write_client.configuration import Configuration
 from influxdb_client_3.write_client.rest import _UTF_8_encoding
 from influxdb_client_3.write_client.service.write_service import WriteService
@@ -38,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
@@ -71,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:
@@ -249,6 +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.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.6.1 → influxdb3_python-0.8.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

{influxdb3_python-0.6.1 → influxdb3_python-0.8.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.6.1 → influxdb3_python-0.8.0}/influxdb_client_3/write_client/client/write/dataframe_serializer.py

@@ -132,7 +132,7 @@ class DataframeSerializer:
         keys = []
         # tags holds a list of tag f-string segments ordered alphabetically by tag key.
         tags = []
-        # fields holds a list of field f-string segments  ordered alphebetically by field key
+        # fields holds a list of field f-string segments ordered alphabetically by field key
         fields = []
         # field_indexes holds the index into each row of all the fields.
         field_indexes = []
@@ -160,6 +160,11 @@ class DataframeSerializer:
         # null_columns has a bool value for each column holding
         # whether that column contains any null (NaN or None) values.
         null_columns = data_frame.isnull().any()
+
+        # inf_columns has a bool value for each column holding
+        # whether that column contains any Inf values.
+        inf_columns = data_frame.isin([np.inf, -np.inf]).any()
+
         timestamp_index = 0
 
         # Iterate through the columns building up the expression for each column.
@@ -175,9 +180,10 @@ class DataframeSerializer:
 
             if key in data_frame_tag_columns:
                 # This column is a tag column.
-                if null_columns.iloc[index]:
+                if null_columns.iloc[index] or inf_columns.iloc[index]:
                     key_value = f"""{{
-                            '' if {val_format} == '' or pd.isna({val_format}) else
+                            '' if {val_format} == '' or pd.isna({val_format}) or
+                            ({inf_columns.iloc[index]} and np.isinf({val_format})) else
                             f',{key_format}={{str({val_format}).translate(_ESCAPE_STRING)}}'
                         }}"""
                 else:
@@ -199,16 +205,17 @@ class DataframeSerializer:
             if (issubclass(value.type, np.integer) or issubclass(value.type, np.floating) or
                     issubclass(value.type, np.bool_)):
                 suffix = 'i' if issubclass(value.type, np.integer) else ''
-                if null_columns.iloc[index]:
+                if null_columns.iloc[index] or inf_columns.iloc[index]:
                     field_value = (
-                        f"""{{"" if pd.isna({val_format}) else f"{sep}{key_format}={{{val_format}}}{suffix}"}}"""
+                        f"""{{"" if pd.isna({val_format}) or ({inf_columns.iloc[index]} and np.isinf({val_format})) else
+                        f"{sep}{key_format}={{{val_format}}}{suffix}"}}"""
                     )
                 else:
                     field_value = f'{sep}{key_format}={{{val_format}}}{suffix}'
             else:
-                if null_columns.iloc[index]:
+                if null_columns.iloc[index] or inf_columns.iloc[index]:
                     field_value = f"""{{
-                            '' if pd.isna({val_format}) else
+                            '' if pd.isna({val_format}) or ({inf_columns.iloc[index]} and np.isinf({val_format})) else
                             f'{sep}{key_format}="{{str({val_format}).translate(_ESCAPE_STRING)}}"'
                         }}"""
                 else:
@@ -234,11 +241,12 @@ class DataframeSerializer:
             '_ESCAPE_STRING': _ESCAPE_STRING,
             'keys': keys,
             'pd': pd,
+            'np': np,
         })
 
         for k, v in dict(data_frame.dtypes).items():
             if k in data_frame_tag_columns:
-                data_frame[k].replace('', np.nan, inplace=True)
+                data_frame[k] = data_frame[k].apply(lambda x: np.nan if x == '' else x)
 
         self.data_frame = data_frame
         self.f = f
@@ -284,137 +292,6 @@ class DataframeSerializer:
         return self.number_of_chunks
 
 
-class PolarsDataframeSerializer:
-    """Serialize DataFrame into LineProtocols."""
-
-    def __init__(self, data_frame, point_settings, precision=DEFAULT_WRITE_PRECISION, chunk_size: int = None,
-                 **kwargs) -> None:
-        """
-        Init serializer.
-
-        :param data_frame: Polars DataFrame to serialize
-        :param point_settings: Default Tags
-        :param precision: The precision for the unix timestamps within the body line-protocol.
-        :param chunk_size: The size of chunk for serializing into chunks.
-        :key data_frame_measurement_name: name of measurement for writing Polars DataFrame
-        :key data_frame_tag_columns: list of DataFrame columns which are tags, rest columns will be fields
-        :key data_frame_timestamp_column: name of DataFrame column which contains a timestamp.
-        :key data_frame_timestamp_timezone: name of the timezone which is used for timestamp column
-        """
-
-        self.data_frame = data_frame
-        self.point_settings = point_settings
-        self.precision = precision
-        self.chunk_size = chunk_size
-        self.measurement_name = kwargs.get("data_frame_measurement_name", "measurement")
-        self.tag_columns = kwargs.get("data_frame_tag_columns", [])
-        self.timestamp_column = kwargs.get("data_frame_timestamp_column", None)
-        self.timestamp_timezone = kwargs.get("data_frame_timestamp_timezone", None)
-
-        self.column_indices = {name: index for index, name in enumerate(data_frame.columns)}
-
-        if self.timestamp_column is None or self.timestamp_column not in self.column_indices:
-            raise ValueError(
-                f"Timestamp column {self.timestamp_column} not found in DataFrame. Please define a valid timestamp "
-                f"column.")
-
-        #
-        # prepare chunks
-        #
-        if chunk_size is not None:
-            self.number_of_chunks = int(math.ceil(len(data_frame) / float(chunk_size)))
-            self.chunk_size = chunk_size
-        else:
-            self.number_of_chunks = None
-
-    def escape_key(self, value):
-        return str(value).translate(_ESCAPE_KEY)
-
-    def escape_value(self, value):
-        return str(value).translate(_ESCAPE_STRING)
-
-    def to_line_protocol(self, row):
-        # Filter out None or empty values for tags
-        tags = ""
-
-        tags = ",".join(
-            f'{self.escape_key(col)}={self.escape_key(row[self.column_indices[col]])}'
-            for col in self.tag_columns
-            if row[self.column_indices[col]] is not None and row[self.column_indices[col]] != ""
-        )
-
-        if self.point_settings.defaultTags:
-            default_tags = ",".join(
-                f'{self.escape_key(key)}={self.escape_key(value)}'
-                for key, value in self.point_settings.defaultTags.items()
-            )
-            # Ensure there's a comma between existing tags and default tags if both are present
-            if tags and default_tags:
-                tags += ","
-            tags += default_tags
-
-        # add escape symbols for special characters to tags
-
-        fields = ",".join(
-            f"{col}=\"{self.escape_value(row[self.column_indices[col]])}\"" if isinstance(row[self.column_indices[col]],
-                                                                                          str)
-            else f"{col}={str(row[self.column_indices[col]]).lower()}" if isinstance(row[self.column_indices[col]],
-                                                                                     bool)  # Check for bool first
-            else f"{col}={row[self.column_indices[col]]}i" if isinstance(row[self.column_indices[col]], int)
-            else f"{col}={row[self.column_indices[col]]}"
-            for col in self.column_indices
-            if col not in self.tag_columns + [self.timestamp_column] and
-            row[self.column_indices[col]] is not None and row[self.column_indices[col]] != ""
-        )
-
-        # Access the Unix timestamp
-        timestamp = row[self.column_indices[self.timestamp_column]]
-        if tags != "":
-            line_protocol = f"{self.measurement_name},{tags} {fields} {timestamp}"
-        else:
-            line_protocol = f"{self.measurement_name} {fields} {timestamp}"
-
-        return line_protocol
-
-    def serialize(self, chunk_idx: int = None):
-        from ...extras import pl
-
-        df = self.data_frame
-
-        # Check if the timestamp column is already an integer
-        if df[self.timestamp_column].dtype in [pl.Int32, pl.Int64]:
-            # The timestamp column is already an integer, assuming it's in Unix format
-            pass
-        else:
-            # Convert timestamp to Unix timestamp based on specified precision
-            if self.precision in [None, 'ns']:
-                df = df.with_columns(
-                    pl.col(self.timestamp_column).dt.epoch(time_unit="ns").alias(self.timestamp_column))
-            elif self.precision == 'us':
-                df = df.with_columns(
-                    pl.col(self.timestamp_column).dt.epoch(time_unit="us").alias(self.timestamp_column))
-            elif self.precision == 'ms':
-                df = df.with_columns(
-                    pl.col(self.timestamp_column).dt.epoch(time_unit="ms").alias(self.timestamp_column))
-            elif self.precision == 's':
-                df = df.with_columns(pl.col(self.timestamp_column).dt.epoch(time_unit="s").alias(self.timestamp_column))
-            else:
-                raise ValueError(f"Unsupported precision: {self.precision}")
-
-        if chunk_idx is None:
-            chunk = df
-        else:
-            logger.debug("Serialize chunk %s/%s ...", chunk_idx + 1, self.number_of_chunks)
-            chunk = df[chunk_idx * self.chunk_size:(chunk_idx + 1) * self.chunk_size]
-
-        # Apply the UDF to each row
-        line_protocol_expr = chunk.apply(self.to_line_protocol, return_dtype=pl.Object)
-
-        lp = line_protocol_expr['map'].to_list()
-
-        return lp
-
-
 def data_frame_to_list_of_points(data_frame, point_settings, precision=DEFAULT_WRITE_PRECISION, **kwargs):
     """
     Serialize DataFrame into LineProtocols.
@@ -430,20 +307,3 @@ def data_frame_to_list_of_points(data_frame, point_settings, precision=DEFAULT_W
     :key data_frame_timestamp_timezone: name of the timezone which is used for timestamp column - ``DataFrame``
     """  # noqa: E501
     return DataframeSerializer(data_frame, point_settings, precision, **kwargs).serialize()
-
-
-def polars_data_frame_to_list_of_points(data_frame, point_settings, precision=DEFAULT_WRITE_PRECISION, **kwargs):
-    """
-    Serialize DataFrame into LineProtocols.
-
-    :param data_frame: Pandas DataFrame to serialize
-    :param point_settings: Default Tags
-    :param precision: The precision for the unix timestamps within the body line-protocol.
-    :key data_frame_measurement_name: name of measurement for writing Pandas DataFrame
-    :key data_frame_tag_columns: list of DataFrame columns which are tags, rest columns will be fields
-    :key data_frame_timestamp_column: name of DataFrame column which contains a timestamp. The column can be defined as a :class:`~str` value
-                                      formatted as `2018-10-26`, `2018-10-26 12:00`, `2018-10-26 12:00:00-05:00`
-                                      or other formats and types supported by `pandas.to_datetime <https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.to_datetime.html#pandas.to_datetime>`_ - ``DataFrame``
-    :key data_frame_timestamp_timezone: name of the timezone which is used for timestamp column - ``DataFrame``
-    """  # noqa: E501
-    return PolarsDataframeSerializer(data_frame, point_settings, precision, **kwargs).serialize()

influxdb3_python-0.8.0/influxdb_client_3/write_client/client/write/polars_dataframe_serializer.py

@@ -0,0 +1,160 @@
+"""
+Functions for serialize Polars DataFrame.
+
+Much of the code here is inspired by that in the aioinflux packet found here: https://github.com/gusutabopb/aioinflux
+"""
+
+import logging
+import math
+
+from influxdb_client_3.write_client.client.write.point import _ESCAPE_KEY, _ESCAPE_STRING, DEFAULT_WRITE_PRECISION
+
+logger = logging.getLogger('influxdb_client.client.write.polars_dataframe_serializer')
+
+
+class PolarsDataframeSerializer:
+    """Serialize DataFrame into LineProtocols."""
+
+    def __init__(self, data_frame, point_settings, precision=DEFAULT_WRITE_PRECISION, chunk_size: int = None,
+                 **kwargs) -> None:
+        """
+        Init serializer.
+
+        :param data_frame: Polars DataFrame to serialize
+        :param point_settings: Default Tags
+        :param precision: The precision for the unix timestamps within the body line-protocol.
+        :param chunk_size: The size of chunk for serializing into chunks.
+        :key data_frame_measurement_name: name of measurement for writing Polars DataFrame
+        :key data_frame_tag_columns: list of DataFrame columns which are tags, rest columns will be fields
+        :key data_frame_timestamp_column: name of DataFrame column which contains a timestamp.
+        :key data_frame_timestamp_timezone: name of the timezone which is used for timestamp column
+        """
+
+        self.data_frame = data_frame
+        self.point_settings = point_settings
+        self.precision = precision
+        self.chunk_size = chunk_size
+        self.measurement_name = kwargs.get("data_frame_measurement_name", "measurement")
+        self.tag_columns = kwargs.get("data_frame_tag_columns", [])
+        self.timestamp_column = kwargs.get("data_frame_timestamp_column", None)
+        self.timestamp_timezone = kwargs.get("data_frame_timestamp_timezone", None)
+
+        self.column_indices = {name: index for index, name in enumerate(data_frame.columns)}
+
+        if self.timestamp_column is None or self.timestamp_column not in self.column_indices:
+            raise ValueError(
+                f"Timestamp column {self.timestamp_column} not found in DataFrame. Please define a valid timestamp "
+                f"column.")
+
+        #
+        # prepare chunks
+        #
+        if chunk_size is not None:
+            self.number_of_chunks = int(math.ceil(len(data_frame) / float(chunk_size)))
+            self.chunk_size = chunk_size
+        else:
+            self.number_of_chunks = None
+
+    def escape_key(self, value):
+        return str(value).translate(_ESCAPE_KEY)
+
+    def escape_value(self, value):
+        return str(value).translate(_ESCAPE_STRING)
+
+    def to_line_protocol(self, row):
+        # Filter out None or empty values for tags
+        tags = ""
+
+        tags = ",".join(
+            f'{self.escape_key(col)}={self.escape_key(row[self.column_indices[col]])}'
+            for col in self.tag_columns
+            if row[self.column_indices[col]] is not None and row[self.column_indices[col]] != ""
+        )
+
+        if self.point_settings.defaultTags:
+            default_tags = ",".join(
+                f'{self.escape_key(key)}={self.escape_key(value)}'
+                for key, value in self.point_settings.defaultTags.items()
+            )
+            # Ensure there's a comma between existing tags and default tags if both are present
+            if tags and default_tags:
+                tags += ","
+            tags += default_tags
+
+        # add escape symbols for special characters to tags
+
+        fields = ",".join(
+            f"{col}=\"{self.escape_value(row[self.column_indices[col]])}\"" if isinstance(row[self.column_indices[col]],
+                                                                                          str)
+            else f"{col}={str(row[self.column_indices[col]]).lower()}" if isinstance(row[self.column_indices[col]],
+                                                                                     bool)  # Check for bool first
+            else f"{col}={row[self.column_indices[col]]}i" if isinstance(row[self.column_indices[col]], int)
+            else f"{col}={row[self.column_indices[col]]}"
+            for col in self.column_indices
+            if col not in self.tag_columns + [self.timestamp_column] and
+            row[self.column_indices[col]] is not None and row[self.column_indices[col]] != ""
+        )
+
+        # Access the Unix timestamp
+        timestamp = row[self.column_indices[self.timestamp_column]]
+        if tags != "":
+            line_protocol = f"{self.measurement_name},{tags} {fields} {timestamp}"
+        else:
+            line_protocol = f"{self.measurement_name} {fields} {timestamp}"
+
+        return line_protocol
+
+    def serialize(self, chunk_idx: int = None):
+        import polars as pl
+
+        df = self.data_frame
+
+        # Check if the timestamp column is already an integer
+        if df[self.timestamp_column].dtype in [pl.Int32, pl.Int64]:
+            # The timestamp column is already an integer, assuming it's in Unix format
+            pass
+        else:
+            # Convert timestamp to Unix timestamp based on specified precision
+            if self.precision in [None, 'ns']:
+                df = df.with_columns(
+                    pl.col(self.timestamp_column).dt.epoch(time_unit="ns").alias(self.timestamp_column))
+            elif self.precision == 'us':
+                df = df.with_columns(
+                    pl.col(self.timestamp_column).dt.epoch(time_unit="us").alias(self.timestamp_column))
+            elif self.precision == 'ms':
+                df = df.with_columns(
+                    pl.col(self.timestamp_column).dt.epoch(time_unit="ms").alias(self.timestamp_column))
+            elif self.precision == 's':
+                df = df.with_columns(pl.col(self.timestamp_column).dt.epoch(time_unit="s").alias(self.timestamp_column))
+            else:
+                raise ValueError(f"Unsupported precision: {self.precision}")
+
+        if chunk_idx is None:
+            chunk = df
+        else:
+            logger.debug("Serialize chunk %s/%s ...", chunk_idx + 1, self.number_of_chunks)
+            chunk = df[chunk_idx * self.chunk_size:(chunk_idx + 1) * self.chunk_size]
+
+        # Apply the UDF to each row
+        line_protocol_expr = chunk.map_rows(self.to_line_protocol, return_dtype=pl.Object)
+
+        lp = line_protocol_expr['map'].to_list()
+
+        return lp
+
+
+def polars_data_frame_to_list_of_points(data_frame, point_settings, precision=DEFAULT_WRITE_PRECISION, **kwargs):
+    """
+    Serialize DataFrame into LineProtocols.
+
+    :param data_frame: Pandas DataFrame to serialize
+    :param point_settings: Default Tags
+    :param precision: The precision for the unix timestamps within the body line-protocol.
+    :key data_frame_measurement_name: name of measurement for writing Pandas DataFrame
+    :key data_frame_tag_columns: list of DataFrame columns which are tags, rest columns will be fields
+    :key data_frame_timestamp_column: name of DataFrame column which contains a timestamp. The column can be defined as a :class:`~str` value
+                                      formatted as `2018-10-26`, `2018-10-26 12:00`, `2018-10-26 12:00:00-05:00`
+                                      or other formats and types supported by `pandas.to_datetime <https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.to_datetime.html#pandas.to_datetime>`_ - ``DataFrame``
+    :key data_frame_timestamp_timezone: name of the timezone which is used for timestamp column - ``DataFrame``
+    """  # noqa: E501
+    return PolarsDataframeSerializer(data_frame, point_settings, precision, **kwargs).serialize()

{influxdb3_python-0.6.1 → influxdb3_python-0.8.0}/influxdb_client_3/write_client/client/write_api.py

@@ -19,8 +19,7 @@ from reactivex.subject import Subject
 from influxdb_client_3.write_client.domain import WritePrecision
 from influxdb_client_3.write_client.client._base import _BaseWriteApi, _HAS_DATACLASS
 from influxdb_client_3.write_client.client.util.helpers import get_org_query_param
-from influxdb_client_3.write_client.client.write.dataframe_serializer import (DataframeSerializer,
-                                                                              PolarsDataframeSerializer)
+from influxdb_client_3.write_client.client.write.dataframe_serializer import DataframeSerializer
 from influxdb_client_3.write_client.client.write.point import Point, DEFAULT_WRITE_PRECISION
 from influxdb_client_3.write_client.client.write.retry import WritesRetry
 from influxdb_client_3.write_client.rest import _UTF_8_encoding
@@ -462,6 +461,7 @@ 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
             serializer = PolarsDataframeSerializer(data,
                                                    self._point_settings, precision,
                                                    self._write_options.batch_size, **kwargs)

{influxdb3_python-0.6.1 → influxdb3_python-0.8.0}/influxdb_client_3/write_client/extras.py

@@ -10,9 +10,4 @@ try:
 except ModuleNotFoundError as err:
     raise ImportError(f"`data_frame` requires numpy which couldn't be imported due: {err}")
 
-try:
-    import polars as pl
-except ModuleNotFoundError as err:
-    raise ImportError(f"`polars_frame` requires polars which couldn't be imported due: {err}")
-
-__all__ = ['pd', 'np', 'pl']
+__all__ = ['pd', 'np']

{influxdb3_python-0.6.1 → influxdb3_python-0.8.0}/tests/test_api_client.py

@@ -1,12 +1,13 @@
 import unittest
 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 = {}
 
@@ -69,3 +70,38 @@ class ApiClientTests(unittest.TestCase):
         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)