Revert "feat: support-basic-env"

This reverts commit cf910c0.

Author: NguyenHoangSon96

influxdb_client_3/__init__.py

@@ -1,27 +1,17 @@
-import importlib.util
-import os
 import urllib.parse
-from typing import Any
-
 import pyarrow as pa
+import importlib.util
 
 from influxdb_client_3.query.query_api import QueryApi as _QueryApi, QueryApiOptionsBuilder
 from influxdb_client_3.read_file import UploadFile
 from influxdb_client_3.write_client import InfluxDBClient as _InfluxDBClient, WriteOptions, Point
 from influxdb_client_3.write_client.client.exceptions import InfluxDBError
 from influxdb_client_3.write_client.client.write_api import WriteApi as _WriteApi, SYNCHRONOUS, ASYNCHRONOUS, \
-    PointSettings, WriteType, DefaultWriteOptions
+    PointSettings
 from influxdb_client_3.write_client.domain.write_precision import WritePrecision
 
 polars = importlib.util.find_spec("polars") is not None
 
-INFLUX_HOST = "INFLUX_HOST"
-INFLUX_TOKEN = "INFLUX_TOKEN"
-INFLUX_DATABASE = "INFLUX_DATABASE"
-INFLUX_ORG = "INFLUX_ORG"
-INFLUX_PRECISION = "INFLUX_PRECISION"
-INFLUX_AUTH_SCHEME = "INFLUX_AUTH_SCHEME"
-
 
 def write_client_options(**kwargs):
     """
@@ -93,27 +83,6 @@ def _merge_options(defaults, exclude_keys=None, custom=None):
     return _deep_merge(defaults, {key: value for key, value in custom.items() if key not in exclude_keys})
 
 
-def _parse_precision(precision):
-    """
-    Parses the precision value and ensures it is valid.
-
-    This function checks that the given `precision` is one of the allowed
-    values defined in `WritePrecision`. If the precision is invalid, it
-    raises a `ValueError`. The function returns the valid precision value
-    if it passes validation.
-
-    :param precision: The precision value to be validated.
-                      Must be one of WritePrecision.NS, WritePrecision.MS,
-                      WritePrecision.S, or WritePrecision.US.
-    :return: The valid precision value.
-    :rtype: WritePrecision
-    :raises ValueError: If the provided precision is not valid.
-    """
-    if precision not in [WritePrecision.NS, WritePrecision.MS, WritePrecision.S, WritePrecision.US]:
-        raise ValueError(f"Invalid precision value: {precision}")
-    return precision
-
-
 class InfluxDBClient3:
     def __init__(
             self,
@@ -167,23 +136,8 @@ def __init__(
         self._org = org if org is not None else "default"
         self._database = database
         self._token = token
-
-        write_type = DefaultWriteOptions.write_type.value
-        write_precision = DefaultWriteOptions.write_precision.value
-        if isinstance(write_client_options, dict) and write_client_options.get('write_options') is not None:
-            write_opts = write_client_options['write_options']
-            write_type = getattr(write_opts, 'write_type', write_type)
-            write_precision = getattr(write_opts, 'write_precision', write_precision)
-
-        write_options = WriteOptions(
-            write_type=write_type,
-            write_precision=write_precision
-        )
-
-        self._write_client_options = {
-            "write_options": write_options,
-            **(write_client_options or {})
-        }
+        self._write_client_options = write_client_options if write_client_options is not None \
+            else default_client_options(write_options=SYNCHRONOUS)
 
         # Parse the host input
         parsed_url = urllib.parse.urlparse(host)
@@ -224,63 +178,6 @@ def __init__(
                                     flight_client_options=flight_client_options,
                                     proxy=kwargs.get("proxy", None), options=q_opts_builder.build())
 
-    @classmethod
-    def from_env(cls, **kwargs: Any) -> 'InfluxDBClient3':
-
-        """
-        Creates an instance of InfluxDBClient3 configured by specific environment
-        variables. This method automatically loads configuration settings,
-        such as connection details, security parameters, and performance
-        options, from environment variables and initializes the client
-        accordingly.
-
-        :param cls:
-            The class used to create the client instance.
-        :param kwargs:
-            Additional optional parameters that can be passed to customize the
-            configuration or override specific settings derived from the
-            environment variables.
-
-        :raises ValueError:
-            If any required environment variables are missing or have empty
-            values.
-
-        :return:
-            An initialized instance of the `InfluxDBClient3` class with all the
-            configuration settings applied.
-        :rtype:
-            InfluxDBClient3
-        """
-
-        required_vars = {
-            INFLUX_HOST: os.getenv(INFLUX_HOST),
-            INFLUX_TOKEN: os.getenv(INFLUX_TOKEN),
-            INFLUX_DATABASE: os.getenv(INFLUX_DATABASE)
-        }
-        missing_vars = [var for var, value in required_vars.items() if value is None or value == ""]
-        if missing_vars:
-            raise ValueError(f"Missing required environment variables: {', '.join(missing_vars)}")
-
-        write_options = WriteOptions(write_type=WriteType.synchronous)
-
-        precision = os.getenv(INFLUX_PRECISION)
-        if precision is not None:
-            write_options.write_precision = _parse_precision(precision)
-        write_client_option = {'write_options': write_options}
-
-        if os.getenv(INFLUX_AUTH_SCHEME) is not None:
-            kwargs['auth_scheme'] = os.getenv(INFLUX_AUTH_SCHEME)
-
-        org = os.getenv(INFLUX_ORG, "default")
-        return InfluxDBClient3(
-            host=required_vars[INFLUX_HOST],
-            token=required_vars[INFLUX_TOKEN],
-            database=required_vars[INFLUX_DATABASE],
-            write_client_options=write_client_option,
-            org=org,
-            **kwargs
-        )
-
     def write(self, record=None, database=None, **kwargs):
         """
         Write data to InfluxDB.

influxdb_client_3/write_client/client/write_api.py

@@ -39,11 +39,6 @@ class WriteType(Enum):
     synchronous = 3
 
 
-class DefaultWriteOptions(Enum):
-    write_type = WriteType.synchronous
-    write_precision = WritePrecision.NS
-
-
 class WriteOptions(object):
     """Write configuration."""
 
@@ -56,7 +51,6 @@ def __init__(self, write_type: WriteType = WriteType.batching,
                  max_retry_time=180_000,
                  exponential_base=2,
                  max_close_wait=300_000,
-                 write_precision=DEFAULT_WRITE_PRECISION,
                  write_scheduler=ThreadPoolScheduler(max_workers=1)) -> None:
         """
         Create write api configuration.
@@ -72,8 +66,7 @@ def __init__(self, write_type: WriteType = WriteType.batching,
         :param max_retry_delay: the maximum delay between each retry attempt in milliseconds
         :param max_retry_time: total timeout for all retry attempts in milliseconds, if 0 retry is disabled
         :param exponential_base: base for the exponential retry delay
-        :param max_close_wait: the maximum time to wait for writes to be flushed if close() is called
-        :param write_precision: the time precision for the data written to InfluxDB.
+        :parama max_close_wait: the maximum time to wait for writes to be flushed if close() is called
         :param write_scheduler:
         """
         self.write_type = write_type
@@ -87,7 +80,6 @@ def __init__(self, write_type: WriteType = WriteType.batching,
         self.exponential_base = exponential_base
         self.write_scheduler = write_scheduler
         self.max_close_wait = max_close_wait
-        self.write_precision = write_precision
 
     def to_retry_strategy(self, **kwargs):
         """
@@ -298,7 +290,7 @@ def write(self, bucket: str, org: str = None,
                   str, Iterable['str'], Point, Iterable['Point'], dict, Iterable['dict'], bytes, Iterable['bytes'],
                   Observable, NamedTuple, Iterable['NamedTuple'], 'dataclass', Iterable['dataclass']
               ] = None,
-              write_precision: WritePrecision = None, **kwargs) -> Any:
+              write_precision: WritePrecision = DEFAULT_WRITE_PRECISION, **kwargs) -> Any:
         """
         Write time-series data into InfluxDB.
 
@@ -369,9 +361,6 @@ def write(self, bucket: str, org: str = None,
 
         self._append_default_tags(record)
 
-        if write_precision is None:
-            write_precision = self._write_options.write_precision
-
         if self._write_options.write_type is WriteType.batching:
             return self._write_batching(bucket, org, record,
                                         write_precision, **kwargs)
@@ -454,11 +443,8 @@ def __del__(self):
         pass
 
     def _write_batching(self, bucket, org, data,
-                        precision=None,
+                        precision=DEFAULT_WRITE_PRECISION,
                         **kwargs):
-        if precision is None:
-            precision = self._write_options.write_precision
-
         if isinstance(data, bytes):
             _key = _BatchItemKey(bucket, org, precision)
             self._subject.on_next(_BatchItem(key=_key, data=data))
@@ -468,8 +454,7 @@ def _write_batching(self, bucket, org, data,
                                  precision, **kwargs)
 
         elif isinstance(data, Point):
-            write_precision = data.write_precision if data.write_precision is not None else precision
-            self._write_batching(bucket, org, data.to_line_protocol(), write_precision, **kwargs)
+            self._write_batching(bucket, org, data.to_line_protocol(), data.write_precision, **kwargs)
 
         elif isinstance(data, dict):
             self._write_batching(bucket, org, Point.from_dict(data, write_precision=precision, **kwargs),

tests/test_influxdb_client_3.py

@@ -1,7 +1,7 @@
 import unittest
 from unittest.mock import patch
 
-from influxdb_client_3 import InfluxDBClient3, WritePrecision, DefaultWriteOptions
+from influxdb_client_3 import InfluxDBClient3
 from tests.util import asyncio_run
 from tests.util.mocks import ConstantFlightServer, ConstantData
 
@@ -74,59 +74,6 @@ async def test_query_async(self):
             assert {'data': 'sql_query', 'reference': query, 'value': -1.0} in result_list
             assert {'data': 'query_type', 'reference': 'sql', 'value': -1.0} in result_list
 
-    def test_default_client(self):
-        expected_precision = DefaultWriteOptions.write_precision.value
-        expected_write_type = DefaultWriteOptions.write_type.value
-
-        def verify_client_write_options(c):
-            write_options = c._write_client_options.get('write_options')
-            self.assertEqual(write_options.write_precision, expected_precision)
-            self.assertEqual(write_options.write_type, expected_write_type)
-
-            self.assertEqual(c._write_api._write_options.write_precision, expected_precision)
-            self.assertEqual(c._write_api._write_options.write_type, expected_write_type)
-
-        env_client = InfluxDBClient3.from_env()
-        verify_client_write_options(env_client)
-
-        default_client = InfluxDBClient3()
-        verify_client_write_options(default_client)
-
-    @patch.dict('os.environ', {'INFLUX_HOST': 'localhost', 'INFLUX_TOKEN': 'test_token',
-                               'INFLUX_DATABASE': 'test_db', 'INFLUX_ORG': 'test_org',
-                               'INFLUX_PRECISION': WritePrecision.MS})
-    def test_from_env_all_env_vars_set(self):
-        client = InfluxDBClient3.from_env()
-        self.assertIsInstance(client, InfluxDBClient3)
-        self.assertEqual(client._client.url, "https://localhost:443")
-        self.assertEqual(client._database, "test_db")
-        self.assertEqual(client._org, "test_org")
-        self.assertEqual(client._token, "test_token")
-        write_options = client._write_client_options.get("write_options")
-        self.assertEqual(write_options.write_precision, WritePrecision.MS)
-        client._write_api._point_settings = {}
-
-    @patch.dict('os.environ', {'INFLUX_HOST': "", 'INFLUX_TOKEN': "",
-                               'INFLUX_DATABASE': "", 'INFLUX_ORG': ""})
-    def test_from_env_missing_variables(self):
-        with self.assertRaises(ValueError) as context:
-            InfluxDBClient3.from_env()
-        self.assertIn("Missing required environment variables", str(context.exception))
-
-    @patch.dict('os.environ', {'INFLUX_HOST': 'localhost', 'INFLUX_TOKEN': 'test_token',
-                               'INFLUX_DATABASE': 'test_db', 'INFLUX_PRECISION': WritePrecision.MS})
-    def test_parse_valid_write_precision(self):
-        client = InfluxDBClient3.from_env()
-        self.assertIsInstance(client, InfluxDBClient3)
-        self.assertEqual(client._write_client_options.get('write_options').write_precision, WritePrecision.MS)
-
-    @patch.dict('os.environ', {'INFLUX_HOST': 'localhost', 'INFLUX_TOKEN': 'test_token',
-                               'INFLUX_DATABASE': 'test_db', 'INFLUX_PRECISION': 'invalid_value'})
-    def test_parse_invalid_write_precision(self):
-        with self.assertRaises(ValueError) as context:
-            InfluxDBClient3.from_env()
-        self.assertIn("Invalid precision value: invalid_value", str(context.exception))
-
 
 if __name__ == '__main__':
     unittest.main()

tests/test_influxdb_client_3_integration.py

@@ -4,7 +4,6 @@
 import string
 import time
 import unittest
-from unittest.mock import patch
 
 import pyarrow
 import pytest
@@ -275,23 +274,3 @@ async def test_verify_query_async(self):
         result_list = result.to_pylist()
         for item in data:
             assert lp_to_py_object(item) in result_list, f"original lp data \"{item}\" should be in result list"
-
-    def test_from_env(self):
-        with InfluxDBClient3.from_env() as client:
-            id_test = time.time_ns()
-            client.write(f"integration_test_python,type=used value=123.0,id_test={id_test}i")
-
-            sql = 'SELECT * FROM integration_test_python where type=$type and id_test=$id_test'
-            data = client.query(sql, mode="pandas", query_parameters={'type': 'used', 'id_test': id_test})
-
-            self.assertIsNotNone(data)
-            self.assertEqual(1, len(data))
-            self.assertEqual(id_test, data['id_test'][0])
-            self.assertEqual(123.0, data['value'][0])
-
-    @patch.dict('os.environ', {'INFLUX_AUTH_SCHEME': 'invalid_schema'})
-    def test_from_env_invalid_auth_schema(self):
-        with InfluxDBClient3.from_env() as client:
-            with self.assertRaises(InfluxDBError) as err:
-                client.write("integration_test_python,type=used value=123.0")
-            self.assertEqual('unauthorized access', err.exception.message)

tests/test_polars.py

@@ -43,7 +43,6 @@ def setUp(self):
             database="my_db",
             token="my_token"
         )
-        self.client._write_api._point_settings = PointSettings()
 
     def test_write_polars(self):
         import polars as pl
@@ -78,7 +77,6 @@ def test_write_polars_batching(self):
                 write_options=WriteOptions(batch_size=2)
             )
         )
-        self.client._write_api._point_settings = PointSettings()
         self.client._write_api._write_options = WriteOptions(batch_size=2)
         self.client._write_api._write_service = Mock(spec=WriteService)