quillsql 2.2.6__tar.gz → 2.2.7__tar.gz

{quillsql-2.2.6/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.6
+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.6 → 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"
@@ -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-2.2.6 → quillsql-2.2.7}/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-2.2.6 → 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.6 → 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.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.6 → quillsql-2.2.7/quillsql.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 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 → 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.6 → quillsql-2.2.7}/setup.py

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

quillsql-2.2.6/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