quillsql 2.2.6__py3-none-any.whl → 2.2.7__py3-none-any.whl

quillsql/__init__.py

@@ -2,4 +2,13 @@
 
 from .core import Quill
 from .error import PgQueryError
-from .utils import Filter, FilterType, FieldType, StringOperator, DateOperator, NumberOperator, NullOperator
+from .utils import (
+    Filter,
+    FilterType,
+    FieldType,
+    StringOperator,
+    DateOperator,
+    NumberOperator,
+    NullOperator,
+    ParallelPostQuill,
+)

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"
@@ -396,24 +399,27 @@ class Quill:
                 return query
             return f"{query.rstrip(';')} limit {limit}"
 
-    def normalize_database_type(self, db_type):
-        if not db_type:
-            return None
-        lowered = db_type.lower()
-        if lowered in ("postgresql", "postgres"):
-            return "postgres"
-        return lowered
-
     def run_queries(
         self, queries, pkDatabaseType, databaseType=None, metadata=None, runQueryConfig=None
     ):
         results = {}
         if not queries:
             return {"queryResults": []}
-        normalized_pk = self.normalize_database_type(pkDatabaseType)
-        normalized_requested = self.normalize_database_type(databaseType)
-        should_enforce_match = normalized_requested is not None
-        if should_enforce_match and normalized_requested != normalized_pk:
+        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/db/bigquery.py

@@ -26,7 +26,8 @@ def format_bigquery_config(connection_string):
             "project": service_account.get("project_id"),
             "credentials": service_account,
         }
-    except (ValueError, TypeError):
+    except (ValueError, TypeError) as e:
+        print("Invalid service account JSON.", e)
     return connection_string
 
 

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/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/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.6.dist-info → quillsql-2.2.7.dist-info}/METADATA

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

{quillsql-2.2.6.dist-info → quillsql-2.2.7.dist-info}/RECORD

@@ -1,20 +1,21 @@
-quillsql/__init__.py,sha256=FiuoxaNZveKXOPB0hkpfGNlpZKmSn3pRwcqm9HKYbCQ,180
-quillsql/core.py,sha256=xQbg_gBDUkujJiWvj83jK2jgGgrS3VJvkRuM4friQbQ,23699
+quillsql/__init__.py,sha256=wjJfszle5vheUbgUfJMHQqtqhx2W3UaDN4ndcRIfmkQ,236
+quillsql/core.py,sha256=IQZlNdEAfiEuWF4PnA4hI6iK3Yk5OI8QKwKVklwW8GA,23943
 quillsql/error.py,sha256=n9VKHw4FAgg7ZEAz2YQ8L_8FdRG_1shwGngf2iWhUSM,175
 quillsql/assets/__init__.py,sha256=oXQ2ZS5XDXkXTYjADxNfGt55cIn_rqfgWL2EDqjTyoI,45
 quillsql/assets/pgtypes.py,sha256=-B_2wUaoAsdX7_HnJhUlx4ptZQ6x-cXwuST9ACgGFdE,33820
 quillsql/db/__init__.py,sha256=sPgYMF3eqKuc2k96i1Re8NHazLdGKCVN-rs15F1sovw,63
-quillsql/db/bigquery.py,sha256=AGGlrpH1UBtN1yyluTFcrtgF53DdM9I3BIg05DK1FjU,4764
-quillsql/db/cached_connection.py,sha256=Pp0R2XGY-QuQYh8ThiDxSwNb6SEuEKfZcQRcvzjeC28,2556
+quillsql/db/bigquery.py,sha256=XYQ-R1ktMpDrY8ycvrwRlp5Mvg8zcS5sS68Q6rdYHZ8,4819
+quillsql/db/cached_connection.py,sha256=ROGPt5jIZlI5KK9vaCVirMcw_dNVNGkbg-V06Odkl0Y,3270
 quillsql/db/db_helper.py,sha256=nK3E9zOW9YISXBdG4kkUBotHfY2sEq3XmUEjGJAAXmU,2257
 quillsql/db/postgres.py,sha256=ZTLtUVTJHkqAj7nZkcwbmkSOwR2ySN7vS5snoxqLRN0,4156
-quillsql/utils/__init__.py,sha256=C2k9Xe0sG5XrP0XJo9K_-iej1S9PLMRKOYMeLxj7NYE,210
+quillsql/utils/__init__.py,sha256=v8OmCZymnB4ZpS8N1KyYEcaUFlN7CFz_NPMNkHO8ZNo,261
 quillsql/utils/filters.py,sha256=REXOLIQZDHL4EDKtConXY9_GaqUmc2uTcyUa2_4MvAg,6786
 quillsql/utils/pivot_template.py,sha256=1U1ALJHn-4K1_ps8-Z6VDpqJ9dsyOJZNYxt80NDwtlQ,18217
+quillsql/utils/post_quill_executor.py,sha256=DB1RHNfqHPYarMM10vSv--UjpCZqe4qYTjqp3wL3v-s,2062
 quillsql/utils/run_query_processes.py,sha256=QwnMr5UwXdtO_W88lv5nBaf6pJ_h5oWQnYd8K9oHQ5s,1030
 quillsql/utils/schema_conversion.py,sha256=TFfMibN9nOsxNRhHw5YIFl3jGTvipG81bxX4LFDulUY,314
 quillsql/utils/tenants.py,sha256=ZD2FuKz0gjBVSsThHDv1P8PU6EL8E009NWihE5hAH-Q,2022
-quillsql-2.2.6.dist-info/METADATA,sha256=wZVOGz--kUM4xMWhXHCAsGp_kOgx8J37IeV1siy5ABs,1786
-quillsql-2.2.6.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-quillsql-2.2.6.dist-info/top_level.txt,sha256=eU2vHnVqwpYQJ3ADl1Q-DIBzbYejZRUhcMdN_4zMCz8,9
-quillsql-2.2.6.dist-info/RECORD,,
+quillsql-2.2.7.dist-info/METADATA,sha256=EE-TzuvH71mqurYprv3i-rzqd4_REL4bB14WEHqPCaA,1786
+quillsql-2.2.7.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+quillsql-2.2.7.dist-info/top_level.txt,sha256=eU2vHnVqwpYQJ3ADl1Q-DIBzbYejZRUhcMdN_4zMCz8,9
+quillsql-2.2.7.dist-info/RECORD,,