influxdb3-python 0.1.8__tar.gz → 0.2.0__tar.gz

{influxdb3-python-0.1.8 → influxdb3-python-0.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: influxdb3-python
-Version: 0.1.8
+Version: 0.2.0
 Summary: Community Python client for InfluxDB 3.0
 Home-page: https://github.com/InfluxCommunity/influxdb3-python
 Author: InfluxData

{influxdb3-python-0.1.8 → influxdb3-python-0.2.0}/influxdb3_python.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: influxdb3-python
-Version: 0.1.8
+Version: 0.2.0
 Summary: Community Python client for InfluxDB 3.0
 Home-page: https://github.com/InfluxCommunity/influxdb3-python
 Author: InfluxData

{influxdb3-python-0.1.8 → influxdb3-python-0.2.0}/influxdb_client_3/__init__.py

@@ -1,22 +1,43 @@
-import json
-import urllib.parse
+import urllib.parse, json
 import pyarrow as pa
 from influxdb_client import InfluxDBClient as _InfluxDBClient, WriteOptions, Point
 from influxdb_client.client.write_api import WriteApi as _WriteApi, SYNCHRONOUS, ASYNCHRONOUS, PointSettings
 from influxdb_client.domain.write_precision import WritePrecision
 from influxdb_client.client.exceptions import InfluxDBError
 from pyarrow.flight import FlightClient, Ticket, FlightCallOptions
-from influxdb_client_3.read_file import upload_file
+from influxdb_client_3.read_file import UploadFile
 
 
 def write_client_options(**kwargs):
+    """
+    Function for providing additional arguments for the WriteApi client.
+
+    :param kwargs: Additional arguments for the WriteApi client.
+    :return: dict with the arguments.
+    """
     return kwargs
 
 def default_client_options(**kwargs):
     return kwargs
 
 def flight_client_options(**kwargs):
-    return kwargs  # You can replace this with a specific data structure if needed
+    """
+    Function for providing additional arguments for the FlightClient.
+
+    :param kwargs: Additional arguments for the FlightClient.
+    :return: dict with the arguments.
+    """
+    return kwargs
+
+def file_parser_options(**kwargs):
+    """
+    Function for providing additional arguments for the file parser.
+
+    :param kwargs: Additional arguments for the file parser.
+    :return: dict with the arguments.
+    """
+    return kwargs  
+
 
 class InfluxDBClient3:
     def __init__(
@@ -39,14 +60,15 @@ class InfluxDBClient3:
         :type database: str
         :param token: The authentication token for accessing the InfluxDB server.
         :type token: str
-        :param write_client_options: Options for the WriteAPI.
-        :type write_client_options: dict
-        :param flight_client_options: Options for the FlightClient.
-        :type flight_client_options: dict
+        :param write_client_options: Function for providing additional arguments for the WriteApi client.
+        :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.
         """
-        self._org = org
+        self._org = org if org is not None else "default"
         self._database = database
+        self._token = token
         self._write_client_options = write_client_options if write_client_options is not None else default_client_options(write_options=SYNCHRONOUS)
 
         # Extracting the hostname from URL if provided
@@ -55,7 +77,7 @@ class InfluxDBClient3:
 
         self._client = _InfluxDBClient(
             url=f"https://{host}",
-            token=token,
+            token=self._token,
             org=self._org,
             **kwargs)
         
@@ -63,24 +85,28 @@ class InfluxDBClient3:
         self._flight_client_options = flight_client_options or {}
         self._flight_client = FlightClient(f"grpc+tls://{host}:443", **self._flight_client_options)
         
-        # Create an authorization header
-        self._options = FlightCallOptions(headers=[(b"authorization", f"Bearer {token}".encode('utf-8'))])
 
-    def write(self, record=None, **kwargs):
+
+    def write(self, record=None, database=None ,**kwargs):
         """
         Write data to InfluxDB.
 
         :param record: The data point(s) to write.
-        :type record: Point or list of Point objects
+        :type record: object or list of objects
+        :param database: The database to write to. If not provided, uses the database provided during initialization.
+        :type database: str
         :param kwargs: Additional arguments to pass to the write API.
         """
+        if database is None:
+            database = self._database
+
         try:
-            self._write_api.write(bucket=self._database, record=record, **kwargs)
+            self._write_api.write(bucket=database, record=record, **kwargs)
         except InfluxDBError as e:
             raise e
           
 
-    def write_file(self, file, measurement_name=None, tag_columns=None, timestamp_column='time', **kwargs):
+    def write_file(self, file, measurement_name=None, tag_columns=None, timestamp_column='time', database=None, file_parser_options=None ,**kwargs):
         """
         Write data from a file to InfluxDB.
 
@@ -92,17 +118,24 @@ class InfluxDBClient3:
         :type tag_columns: list
         :param timestamp_column: Timestamp column name. Defaults to 'time'.
         :type timestamp_column: str
+        :param database: The database to write to. If not provided, uses the database provided during initialization.
+        :type database: str
+        :param file_parser_options: Function for providing additional arguments for the file parser.
+        :type file_parser_options: callable
         :param kwargs: Additional arguments to pass to the write API.
         """
+        if database is None:
+            database = self._database
+
         try:
-            table = upload_file(file).load_file()
+            table = UploadFile(file, file_parser_options).load_file()
             df = table.to_pandas() if isinstance(table, pa.Table) else table
-            self._process_dataframe(df, measurement_name, tag_columns or [], timestamp_column)
+            self._process_dataframe(df, measurement_name, tag_columns or [], timestamp_column, database=database, **kwargs)
         except Exception as e:
             raise e
             
 
-    def _process_dataframe(self, df, measurement_name, tag_columns, timestamp_column):
+    def _process_dataframe(self, df, measurement_name, tag_columns, timestamp_column, database, **kwargs):
         # This function is factored out for clarity.
         # It processes a DataFrame before writing to InfluxDB.
 
@@ -120,27 +153,35 @@ class InfluxDBClient3:
                 print("'measurement' column not found in the dataframe.")
         else:
             df = df.drop(columns=['measurement'], errors='ignore')
-            self._write_api.write(bucket=self._database, record=df,
+            self._write_api.write(bucket=database, record=df,
                                   data_frame_measurement_name=measurement_name,
                                   data_frame_tag_columns=tag_columns,
-                                  data_frame_timestamp_column=timestamp_column)
+                                  data_frame_timestamp_column=timestamp_column, **kwargs)
 
-    def query(self, query, language="sql", mode="all"):
+    def query(self, query, language="sql", mode="all", database=None, **kwargs ):
         """
         Query data from InfluxDB.
 
         :param query: The query string.
         :type query: str
-        :param language: The query language (default is "sql").
+        :param language: The query language; "sql" or "influxql" (default is "sql").
         :type language: str
         :param mode: The mode of fetching data (all, pandas, chunk, reader, schema).
         :type mode: str
+        :param database: The database to query from. If not provided, uses the database provided during initialization.
+        :type database: str
+        :param kwargs: Additional arguments for the query.
         :return: The queried data.
         """
+        if database is None:
+            database = self._database
+        
         try:
-            ticket_data = {"database": self._database, "sql_query": query, "query_type": language}
+            # Create an authorization header
+            _options = FlightCallOptions(headers=[(b"authorization", f"Bearer {self._token}".encode('utf-8'))], **kwargs)
+            ticket_data = {"database": database, "sql_query": query, "query_type": language}
             ticket = Ticket(json.dumps(ticket_data).encode('utf-8'))
-            flight_reader = self._flight_client.do_get(ticket, self._options)
+            flight_reader = self._flight_client.do_get(ticket, _options)
 
             mode_func = {
                 "all": flight_reader.read_all,
@@ -176,5 +217,6 @@ __all__ = [
     "WritePrecision",
     "WriteOptions",
     "write_client_options",
-    "flight_client_options"
+    "flight_client_options",
+    "file_parser_options"
 ]

influxdb3-python-0.2.0/influxdb_client_3/read_file.py

@@ -0,0 +1,99 @@
+import os
+import pyarrow.csv as csv
+import pyarrow.feather as feather
+import pyarrow.parquet as parquet
+import pandas as pd
+
+# Check if the OS is not Windows
+if os.name != 'nt':
+    import pyarrow.orc as orc
+
+
+class UploadFile:
+    """
+    Class for uploading and reading different types of files.
+    """
+    def __init__(self, file, file_parser_options=None):
+        """
+        Initialize an UploadFile instance.
+
+        :param file: The file to upload.
+        :type file: str
+        :param kwargs: Additional arguments for file loading functions.
+        """
+        self._file = file
+        self._kwargs = file_parser_options if file_parser_options is not None else {}
+
+    def load_file(self):
+        """
+        Load a file based on its extension.
+
+        :return: The loaded file.
+        :raises ValueError: If the file type is not supported.
+        """
+        if self._file.endswith(".feather"):
+            return self.load_feather(self._file)
+        elif self._file.endswith(".parquet"):
+            return self.load_parquet(self._file)
+        elif self._file.endswith(".csv"):
+            return self.load_csv(self._file)
+        elif self._file.endswith(".json"):
+            return self.load_json(self._file)
+        elif self._file.endswith(".orc"):
+            return self.load_orc(self._file)
+        else:
+            raise ValueError("Unsupported file type")
+
+    def load_feather(self, file ):
+        """
+        Load a Feather file.
+
+        :param file: The Feather file to load.
+        :type file: str
+        :return: The loaded Feather file.
+        """
+        return feather.read_table(file, **self._kwargs)
+
+    def load_parquet(self, file):
+        """
+        Load a Parquet file.
+
+        :param file: The Parquet file to load.
+        :type file: str
+        :return: The loaded Parquet file.
+        """
+        return parquet.read_table(file, **self._kwargs)
+
+    def load_csv(self, file):
+        """
+        Load a CSV file.
+
+        :param file: The CSV file to load.
+        :type file: str
+        :return: The loaded CSV file.
+        """
+        return csv.read_csv(file, **self._kwargs)
+
+    def load_orc(self, file):
+        """
+        Load an ORC file.
+
+        :param file: The ORC file to load.
+        :type file: str
+        :return: The loaded ORC file.
+        :raises ValueError: If the OS is Windows.
+        """
+        if os.name == 'nt':
+            raise ValueError("Unsupported file type for this OS")
+        else:
+            return orc.read_table(file, **self._kwargs)
+
+    def load_json(self, file):
+        """
+        Load a JSON file.
+
+        :param file: The JSON file to load.
+        :type file: str
+        :return: The loaded JSON file.
+        """
+        return pd.read_json(file, **self._kwargs)

influxdb3-python-0.1.8/influxdb_client_3/read_file.py

@@ -1,51 +0,0 @@
-from pyarrow import json as pa_json
-import pyarrow.csv as csv
-import pyarrow.feather as feather
-import pyarrow.parquet as parquet
-import os
-
-# Check if the OS is not Windows
-if os.name != 'nt':
-    import pyarrow.orc as orc
-
-import pandas as pd
-
-class upload_file:
-    def __init__(self, file, **kwargs):
-        self._file = file
-        self._kwargs = kwargs
-
-    def load_file(self):
-            if self._file.endswith(".feather"):
-                return self.load_feather(self._file, **self._kwargs)
-            elif self._file.endswith(".parquet"):
-                return self.load_parquet(self._file)
-            elif self._file.endswith(".csv"):
-                return self.load_csv(self._file)
-            elif self._file.endswith(".json"):
-                return self.load_json(self._file)
-            elif self._file.endswith(".orc"):
-
-                return self.load_orc(self._file)
-            else:
-                raise ValueError("Unsupported file type")
-
-    def load_feather(self, file):
-        return feather.read_table(file, **self._kwargs)
-        
-    def load_parquet(self, file):
-        return parquet.read_table(file, **self._kwargs)
-        
-    def load_csv(self, file):
-        return csv.read_csv(file, **self._kwargs)
-    
-    def load_orc(self, file):
-        if os.name == 'nt':
-            raise ValueError("Unsupported file type for this OS")
-        else:
-            return orc.read_table(file, **self._kwargs)
-    
-    #TODO: Use pyarrow.json.read_json() instead of pandas.read_json()
-    def load_json(self, file):
-        return pd.read_json(file, **self._kwargs)
-