quillsql 2.2.5__tar.gz → 2.2.7__tar.gz

{quillsql-2.2.5/quillsql.egg-info → quillsql-2.2.7}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.2
 Name: quillsql
-Version: 2.2.5
+Version: 2.2.7
 Summary: Quill SDK for Python.
 Home-page: https://github.com/quill-sql/quill-python
 Author: Quill

quillsql-2.2.7/quillsql/__init__.py

@@ -0,0 +1,14 @@
+# __init__.py
+
+from .core import Quill
+from .error import PgQueryError
+from .utils import (
+    Filter,
+    FilterType,
+    FieldType,
+    StringOperator,
+    DateOperator,
+    NumberOperator,
+    NullOperator,
+    ParallelPostQuill,
+)

{quillsql-2.2.5 → quillsql-2.2.7}/quillsql/core.py

@@ -144,10 +144,14 @@ class Quill:
                         None
                     )
 
-                    distinct_values = parse_distinct_values(
-                        distinct_value_results["queryResults"][0],
-                        config.get("databaseType")
-                    )
+                    distinct_value_query_results = (
+                        distinct_value_results or {}
+                    ).get("queryResults") or []
+                    if distinct_value_query_results:
+                        distinct_values = parse_distinct_values(
+                            distinct_value_query_results[0],
+                            config.get("databaseType")
+                        )
 
                 try:
                     final_query = hydrate_pivot_template(template, distinct_values, config)
@@ -261,17 +265,16 @@ class Quill:
                 else:
                     tenant_flags = flags
 
-            pre_query_results = (
-                self.run_queries(
+            if metadata.get("preQueries"):
+                pre_query_results = self.run_queries(
                     metadata.get("preQueries"),
                     self.target_connection.database_type,
                     metadata.get("databaseType"),
                     metadata,
                     metadata.get("runQueryConfig"),
                 )
-                if metadata.get("preQueries")
-                else {}
-            )
+            else:
+                pre_query_results = {}
 
             if metadata.get("runQueryConfig") and metadata.get("runQueryConfig").get(
                 "overridePost"
@@ -402,7 +405,21 @@ class Quill:
         results = {}
         if not queries:
             return {"queryResults": []}
-        if databaseType and databaseType.lower() != pkDatabaseType.lower():
+        def _normalize_db_type(db_type):
+            if not db_type:
+                return None
+            lowered = db_type.lower()
+            if lowered in ("postgresql", "postgres"):
+                return "postgres"
+            return lowered
+
+        normalized_metadata_db = _normalize_db_type(databaseType)
+        normalized_backend_db = _normalize_db_type(pkDatabaseType)
+        if (
+            normalized_metadata_db
+            and normalized_backend_db
+            and normalized_metadata_db != normalized_backend_db
+        ):
             return {"dbMismatched": True, "backendDatabaseType": pkDatabaseType}
         if runQueryConfig and runQueryConfig.get("arrayToMap"):
             mapped_array = array_to_map(

{quillsql-2.2.5 → quillsql-2.2.7}/quillsql/db/bigquery.py

@@ -27,7 +27,7 @@ def format_bigquery_config(connection_string):
             "credentials": service_account,
         }
     except (ValueError, TypeError) as e:
-        print("Invalid JSON string: ", e)
+        print("Invalid service account JSON.", e)
     return connection_string
 
 

{quillsql-2.2.5 → quillsql-2.2.7}/quillsql/db/cached_connection.py

@@ -29,20 +29,43 @@ class CachedConnection:
             )
         return None
 
+    def _is_connection_closed(self):
+        return self.connection is None or getattr(self.connection, "closed", True)
+
+    def _open_connection(self):
+        self.connection = connect_to_db(
+            self.database_type, self.config, self.using_connection_string
+        )
+        return self.connection
+
+    def _close_connection(self):
+        if self.connection is None:
+            return
+        try:
+            self.connection.close()
+        except Exception:
+            pass
+        finally:
+            self.connection = None
+
     def exec_with_reconnect(self, sql):
         reconnect_count = 0
-        while True:
-            self.connection = connect_to_db(
-                self.database_type, self.config, self.using_connection_string
-            )
+        last_error = None
+        while reconnect_count < 10:
             try:
+                if self._is_connection_closed():
+                    self._open_connection()
                 return run_query_by_db(self.database_type, sql, self.connection)
             except psycopg2.Error as err:
-                reconnect_count = reconnect_count + 1
-                if reconnect_count < 10:
-                    continue
-                else:
-                    raise PgQueryError(err, sql, err.diag.statement_position)
+                last_error = err
+                reconnect_count += 1
+                self._close_connection()
+            except Exception:
+                self._close_connection()
+                raise
+        diag = getattr(last_error, "diag", None)
+        position = getattr(diag, "statement_position", None)
+        raise PgQueryError(last_error or "Failed to execute query", sql, position)
 
     def exec(self, sql):
         try:

{quillsql-2.2.5 → quillsql-2.2.7}/quillsql/db/db_helper.py

@@ -15,47 +15,51 @@ from quillsql.db.bigquery import (
 )
 
 
+def _is_postgres(database_type):
+    return database_type and database_type.lower() in ("postgresql", "postgres")
+
+
 def get_db_credentials(database_type, connection_string):
-    if database_type.lower() == "postgresql":
+    if _is_postgres(database_type):
         return format_postgres(connection_string)
-    elif database_type.lower() == "bigquery":
+    elif database_type and database_type.lower() == "bigquery":
         return format_bigquery_config(connection_string)
     return {}
 
 
 def connect_to_db(database_type, config, using_connection_string):
-    if database_type.lower() == "postgresql":
+    if _is_postgres(database_type):
         return connect_to_postgres(config, using_connection_string)
-    elif database_type.lower() == "bigquery":
+    elif database_type and database_type.lower() == "bigquery":
         return connect_to_bigquery(config, using_connection_string)
     return None
 
 
 def run_query_by_db(database_type, query, connection):
-    if database_type.lower() == "postgresql":
+    if _is_postgres(database_type):
         return run_query_postgres(query, connection)
-    elif database_type.lower() == "bigquery":
+    elif database_type and database_type.lower() == "bigquery":
         return run_query_big_query(query, connection)
     return None
 
 
 def disconnect_from_db(database_type, connection):
-    if database_type.lower() == "postgresql":
+    if _is_postgres(database_type):
         return disconnect_from_postgres(connection)
     return None
 
 
 def get_schema_tables_by_db(database_type, connection, schema_name):
-    if database_type.lower() == "postgresql":
+    if _is_postgres(database_type):
         return get_tables_by_schema_postgres(connection, schema_name)
-    elif database_type.lower() == "bigquery":
+    elif database_type and database_type.lower() == "bigquery":
         return get_tables_by_schema_big_query(connection, schema_name)
     return None
 
 
 def get_schema_column_info_by_db(database_type, connection, schema_name, table_names):
-    if database_type.lower() == "postgresql":
+    if _is_postgres(database_type):
         return get_schema_column_info_postgres(connection, schema_name, table_names)
-    elif database_type.lower() == "bigquery":
+    elif database_type and database_type.lower() == "bigquery":
         return get_schema_column_info_big_query(connection, schema_name, table_names)
     return None

{quillsql-2.2.5 → quillsql-2.2.7}/quillsql/utils/__init__.py

@@ -2,3 +2,4 @@
 
 from .run_query_processes import remove_fields, array_to_map
 from .filters import Filter, FilterType, FieldType, StringOperator, NumberOperator, NullOperator, DateOperator, convert_custom_filter
+from .post_quill_executor import ParallelPostQuill

{quillsql-2.2.5 → quillsql-2.2.7}/quillsql/utils/pivot_template.py

@@ -198,7 +198,6 @@ def parse_distinct_values(query_result: Dict[str, Any], database_type: str) -> L
             distinct_values = [v.strip() for v in row["string_values"].split(",")]
     
     else:
-        print(f"Warning: Unknown database type: {database_type}")
         distinct_values = []
     
     # Filter out null/undefined/empty values

quillsql-2.2.7/quillsql/utils/post_quill_executor.py

@@ -0,0 +1,69 @@
+from __future__ import annotations
+
+import threading
+from concurrent.futures import Future, ThreadPoolExecutor
+from typing import Callable, Optional
+
+
+class ParallelPostQuill:
+    """
+    Provides a thread-pooled, drop-in replacement for Quill.post_quill.
+
+    Example
+    -------
+        parallel_post = ParallelPostQuill(
+            quill_factory=lambda: Quill(...),
+            max_workers=4,
+        )
+
+        # Synchronous (behaves like the original post_quill)
+        response = parallel_post("report", payload)
+
+        # Async-style execution
+        future = parallel_post("report", payload, wait=False)
+        response = future.result()
+    """
+
+    def __init__(
+        self,
+        quill_factory: Callable[[], "Quill"],
+        max_workers: int = 5,
+        executor: Optional[ThreadPoolExecutor] = None,
+    ):
+        if executor is None:
+            self._executor = ThreadPoolExecutor(
+                max_workers=max_workers,
+                thread_name_prefix="post-quill",
+            )
+            self._owns_executor = True
+        else:
+            self._executor = executor
+            self._owns_executor = False
+
+        if not callable(quill_factory):
+            raise ValueError("quill_factory must be callable and create Quill instances.")
+
+        self._quill_factory = quill_factory
+        self._thread_local = threading.local()
+
+    def __call__(self, path: str, payload: dict, wait: bool = True):
+        future: Future = self._executor.submit(self._invoke, path, payload)
+        if wait:
+            return future.result()
+        return future
+
+    def shutdown(self, wait: bool = True):
+        if self._owns_executor:
+            self._executor.shutdown(wait=wait)
+
+    def _get_quill(self):
+        quill = getattr(self._thread_local, "quill", None)
+        if quill is None:
+            quill = self._quill_factory()
+            self._thread_local.quill = quill
+        return quill
+
+    def _invoke(self, path: str, payload: dict):
+        quill = self._get_quill()
+        return quill.post_quill(path, payload)
+

{quillsql-2.2.5 → quillsql-2.2.7/quillsql.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: quillsql
-Version: 2.2.5
+Version: 2.2.7
 Summary: Quill SDK for Python.
 Home-page: https://github.com/quill-sql/quill-python
 Author: Quill

{quillsql-2.2.5 → quillsql-2.2.7}/quillsql.egg-info/SOURCES.txt

@@ -18,6 +18,7 @@ quillsql/db/postgres.py
 quillsql/utils/__init__.py
 quillsql/utils/filters.py
 quillsql/utils/pivot_template.py
+quillsql/utils/post_quill_executor.py
 quillsql/utils/run_query_processes.py
 quillsql/utils/schema_conversion.py
 quillsql/utils/tenants.py

{quillsql-2.2.5 → quillsql-2.2.7}/setup.py

@@ -2,7 +2,7 @@ from setuptools import setup, find_packages
 
 setup(
     name="quillsql",
-    version="2.2.5",
+    version="2.2.7",
     packages=find_packages(),
     install_requires=[
         "psycopg2-binary",

quillsql-2.2.5/quillsql/__init__.py

@@ -1,5 +0,0 @@
-# __init__.py
-
-from .core import Quill
-from .error import PgQueryError
-from .utils import Filter, FilterType, FieldType, StringOperator, DateOperator, NumberOperator, NullOperator