quillsql 2.2.3__tar.gz → 2.2.5__tar.gz

{quillsql-2.2.3 → quillsql-2.2.5}/PKG-INFO

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

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

@@ -91,8 +91,6 @@ class Quill:
     ):
         if not tenants:
             raise ValueError("You may not pass an empty tenants array.")
-        if flags and not flags:
-            raise ValueError("You may not pass an empty flags array.")
 
         responseMetadata = {}
         if not metadata:
@@ -108,7 +106,6 @@ class Quill:
 
             # Handle pivot-template task
             if task == "pivot-template":
-                # Step 1: Get pivot template and queries from server
                 pivot_payload = {
                     **metadata,
                     "tenants": tenants,
@@ -137,7 +134,6 @@ class Quill:
                 distinct_values_query = pivot_template_response.get("metadata", {}).get("distinctValuesQuery")
                 row_count_query = pivot_template_response.get("metadata", {}).get("rowCountQuery")
 
-                # Step 2: Run the distinct values query to get unique values
                 distinct_values = []
                 if distinct_values_query:
                     distinct_value_results = self.run_queries(
@@ -148,13 +144,11 @@ class Quill:
                         None
                     )
 
-                    # Parse distinct values from database results
                     distinct_values = parse_distinct_values(
                         distinct_value_results["queryResults"][0],
                         config.get("databaseType")
                     )
 
-                # Step 3: Hydrate the template with the distinct values
                 try:
                     final_query = hydrate_pivot_template(template, distinct_values, config)
                 except Exception as err:
@@ -164,10 +158,8 @@ class Quill:
                         "data": {},
                     }
 
-                # Step 4: Run queries - pivot query and optional row count query
                 queries_to_run = [final_query]
                 if row_count_query:
-                    # Hydrate the rowCountQuery with the same distinct values
                     hydrated_row_count_query = hydrate_pivot_template(
                         row_count_query,
                         distinct_values,
@@ -184,7 +176,6 @@ class Quill:
                 )
 
                 responseMetadata = pivot_template_response.get("metadata") or {}
-                # Set rows and fields from first query result (the pivot query)
                 if final_results.get("queryResults") and len(final_results["queryResults"]) >= 1:
                     query_results = final_results["queryResults"][0]
                     if query_results.get("rows"):
@@ -192,7 +183,6 @@ class Quill:
                     if query_results.get("fields"):
                         responseMetadata["fields"] = query_results["fields"]
 
-                # Remove internal SDK fields before returning to frontend
                 if "template" in responseMetadata:
                     del responseMetadata["template"]
                 if "distinctValuesQuery" in responseMetadata:
@@ -237,21 +227,34 @@ class Quill:
                 )
                 
                 tenant_flags = []
-                query_order = response.get('metadata', {}).get('queryOrder') or []
+                query_order = (response.get('metadata') or {}).get('queryOrder') or []
                 query_results = (flag_query_results or {}).get('queryResults') or []
-                for tenant_field, query_result in zip(query_order, query_results):
-                    rows = []
-                    if isinstance(query_result, dict):
-                        rows = query_result.get('rows') or []
-                    flags = {
-                        row.get('quill_flag')
-                        for row in rows
-                        if isinstance(row, dict) and row.get('quill_flag') is not None
-                    }
+                for index, tenant_field in enumerate(query_order):
+                    query_result = (
+                        query_results[index]
+                        if index < len(query_results)
+                        else {}
+                    )
+                    rows = (
+                        query_result.get('rows')
+                        if isinstance(query_result, dict)
+                        else []
+                    )
+                    ordered_flags = []
+                    seen = set()
+                    for row in rows or []:
+                        if not isinstance(row, dict):
+                            continue
+                        flag = row.get('quill_flag')
+                        if flag is None or flag in seen:
+                            continue
+                        seen.add(flag)
+                        ordered_flags.append(flag)
                     tenant_flags.append({
                         'tenantField': tenant_field,
-                        'flags': list(flags),
+                        'flags': ordered_flags,
                     })
+
             elif tenants[0] == SINGLE_TENANT and flags:
                 if flags and isinstance(flags[0], dict):
                     tenant_flags = [{'tenantField': SINGLE_TENANT, 'flags': flags}]
@@ -283,13 +286,14 @@ class Quill:
                 and metadata.get("runQueryConfig").get("getColumns")
                 else None
             )
-            payload: dict = {
+            payload = {
                 **metadata,
                 "tenants": tenants,
                 "flags": tenant_flags,
                 "viewQuery": view_query,
-                "preQueryResultsColumns": pre_query_columns,
             }
+            if pre_query_columns is not None:
+                payload["preQueryResultsColumns"] = pre_query_columns
             if admin_enabled is not None:
                 payload["adminEnabled"] = admin_enabled
             if filters is not None:
@@ -336,21 +340,25 @@ class Quill:
                     normalized_results.get("queryResults") or []
                 )
 
-            run_query_config = responseMetadata.get("runQueryConfig") or {}
-            array_to_map = run_query_config.get("arrayToMap")
-            if normalized_results.get("mapped_array") and array_to_map:
-                target_collection = responseMetadata.get(array_to_map.get("arrayName"))
+            if (
+                normalized_results.get("mapped_array")
+                and metadata.get("runQueryConfig", {}).get("arrayToMap")
+            ):
+                array_to_map = metadata["runQueryConfig"]["arrayToMap"]
+                target_collection = responseMetadata.get(array_to_map["arrayName"])
                 if isinstance(target_collection, list):
-                    for index, mapped_rows in enumerate(normalized_results["mapped_array"]):
+                    for index, array in enumerate(normalized_results["mapped_array"]):
                         if index >= len(target_collection):
                             continue
                         target_entry = target_collection[index]
-                        if isinstance(target_entry, dict):
-                            target_entry[array_to_map.get("field")] = mapped_rows
-                normalized_results.pop("mapped_array", None)
+                        if not isinstance(target_entry, dict):
+                            target_entry = {}
+                            target_collection[index] = target_entry
+                        target_entry[array_to_map["field"]] = array if array is not None else []
+                del normalized_results["mapped_array"]
 
             query_results_list = normalized_results.get("queryResults") or []
-            if len(query_results_list) == 1:
+            if len(query_results_list) == 1 and isinstance(query_results_list[0], dict):
                 query_result = query_results_list[0]
                 quill_results["metadata"]["rows"] = query_result.get("rows")
                 quill_results["metadata"]["fields"] = query_result.get("fields")

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

@@ -483,3 +483,4 @@ def validate_template(template: str, config: PivotConfig) -> Dict[str, Any]:
         "errors": errors
     }
 
+

quillsql-2.2.5/quillsql/utils/run_query_processes.py

@@ -0,0 +1,30 @@
+def remove_fields(query_result, fields_to_remove):
+    if not isinstance(query_result, dict):
+        return query_result
+    fields = [
+        {"name": field["name"], "dataTypeID": field["dataTypeID"]}
+        for field in (query_result.get("fields") or [])
+        if field.get("name") not in fields_to_remove
+    ]
+    rows = []
+    for row in query_result.get("rows") or []:
+        if not isinstance(row, dict):
+            rows.append(row)
+            continue
+        filtered = dict(row)
+        for field in fields_to_remove:
+            if field in filtered:
+                del filtered[field]
+        rows.append(filtered)
+    return {"fields": fields, "rows": rows}
+
+
+def array_to_map(queries, array_to_map, metadata, target_pool):
+    mapped_array = []
+    for i in range(len(queries)):
+        query_result = target_pool.query(queries[i])
+        if isinstance(query_result, dict):
+            mapped_array.append(query_result.get("rows"))
+        else:
+            mapped_array.append([])
+    return mapped_array

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

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

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

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

quillsql-2.2.5/tests/test_core.py

@@ -0,0 +1,196 @@
+import os
+import sys
+from unittest.mock import MagicMock, patch
+
+sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), "..")))
+
+from quillsql.core import Quill
+
+
+@patch("quillsql.core.CachedConnection")
+def test_query_handles_none_tenant_flag_responses(mock_cached_connection):
+    mock_connection = MagicMock()
+    mock_connection.database_type = "PostgreSQL"
+    mock_cached_connection.return_value = mock_connection
+
+    quill = Quill(
+        private_key=os.getenv("PRIVATE_KEY"),
+        database_type=os.getenv("DB_TYPE"),
+        database_connection_string=os.getenv("DB_URL")
+    )
+
+    quill.run_queries = MagicMock(
+        side_effect=[
+            {"queryResults": [None]},
+            {"queryResults": []},
+        ]
+    )
+
+    def post_quill_side_effect(path, payload):
+        if path == "tenant-mapped-flags":
+            return {
+                "queries": [
+                    'SELECT * FROM (SELECT "id" AS "customer_id", "name" AS "quill_label", "id" AS "quill_flag" FROM "public"."customers") AS "subq_owner_query" WHERE "customer_id" IN (2)'
+                ],
+                "metadata": {"queryOrder": ["customer_id"]},
+            }
+        return {"queries": [], "metadata": {}}
+
+    quill.post_quill = MagicMock(side_effect=post_quill_side_effect)
+
+    result = quill.query(
+        tenants=["tenant-1"],
+        metadata={
+            "task": "report",
+            "clientId": "client-123",
+            "reportId": "report-456",
+            "databaseType": "PostgreSQL",
+        },
+    )
+
+    assert result["status"] == "success"
+    assert result["data"] == {}
+
+
+@patch("quillsql.core.CachedConnection")
+def test_query_handles_tenant_flag_metadata_none(mock_cached_connection):
+    mock_connection = MagicMock()
+    mock_connection.database_type = "PostgreSQL"
+    mock_cached_connection.return_value = mock_connection
+
+    quill = Quill(
+       private_key=os.getenv("PRIVATE_KEY"),
+        database_type=os.getenv("DB_TYPE"),
+        database_connection_string=os.getenv("DB_URL")
+    )
+
+    quill.run_queries = MagicMock(
+        side_effect=[
+            {"queryResults": [{"rows": [{"quill_flag": "alpha"}]}]},
+            {"queryResults": []},
+        ]
+    )
+
+    def post_quill_side_effect(path, payload):
+        if path == "tenant-mapped-flags":
+            return {
+                "queries": [
+                    'SELECT * FROM (SELECT "id" AS "customer_id", "name" AS "quill_label", "id" AS "quill_flag" FROM "public"."customers") AS "subq_owner_query" WHERE "customer_id" IN (2)'
+                ],
+                "metadata": None,
+            }
+        return {"queries": [], "metadata": {}}
+
+    quill.post_quill = MagicMock(side_effect=post_quill_side_effect)
+
+    result = quill.query(
+        tenants=[{"tenantField": "customer_id", "tenantIds": [2]}],
+        metadata={
+            "task": "report",
+            "clientId": "client-123",
+            "reportId": "report-456",
+            "databaseType": "PostgreSQL",
+        },
+    )
+
+    assert result["status"] == "success"
+    assert result["data"] == {}
+
+
+@patch("quillsql.core.CachedConnection")
+def test_query_handles_array_to_map_with_null_mapped_rows(mock_cached_connection):
+    mock_connection = MagicMock()
+    mock_connection.database_type = "PostgreSQL"
+    mock_cached_connection.return_value = mock_connection
+
+    quill = Quill(
+        private_key=os.getenv("PRIVATE_KEY"),
+        database_type=os.getenv("DB_TYPE"),
+        database_connection_string=os.getenv("DB_URL")
+    )
+
+    quill.run_queries = MagicMock(
+        side_effect=[
+            {"queryResults": []},  # tenant-mapped-flags
+            {"queryResults": [], "mapped_array": [None]},  # main query
+        ]
+    )
+
+    def post_quill_side_effect(path, payload):
+        if path == "tenant-mapped-flags":
+            return {"queries": [], "metadata": {"queryOrder": []}}
+        if path == "filter-options":
+            return {
+                "queries": ["SELECT 1"],
+                "metadata": {
+                    "filters": [{"label": "Driver"}],
+                    "runQueryConfig": {
+                        "arrayToMap": {"arrayName": "filters", "field": "options"}
+                    },
+                },
+            }
+        return {"queries": [], "metadata": {}}
+
+    quill.post_quill = MagicMock(side_effect=post_quill_side_effect)
+
+    result = quill.query(
+        tenants=[{"tenantField": "customer_id", "tenantIds": [2]}],
+        metadata={
+            "task": "filter-options",
+            "clientId": "client-123",
+            "filter": {"field": "user_name"},
+        },
+        flags=[],
+    )
+
+    assert result["status"] == "success"
+    assert result["data"]["filters"][0]["options"] == []
+
+
+@patch("quillsql.core.CachedConnection")
+def test_query_handles_fields_to_remove_with_null_results(mock_cached_connection):
+    mock_connection = MagicMock()
+    mock_connection.database_type = "PostgreSQL"
+    mock_cached_connection.return_value = mock_connection
+
+    quill = Quill(
+        private_key=os.getenv("PRIVATE_KEY"),
+        database_type=os.getenv("DB_TYPE"),
+        database_connection_string=os.getenv("DB_URL")
+    )
+
+    quill.run_queries = MagicMock(
+        side_effect=[
+            {"queryResults": []},  # tenant-mapped-flags
+            {"queryResults": [None]},  # main run_queries
+        ]
+    )
+
+    def post_quill_side_effect(path, payload):
+        if path == "tenant-mapped-flags":
+            return {"queries": [], "metadata": {"queryOrder": []}}
+        if path == "report":
+            return {
+                "queries": ["SELECT 1"],
+                "metadata": {
+                    "runQueryConfig": {"fieldsToRemove": ["customer_id"]},
+                },
+            }
+        return {"queries": [], "metadata": {}}
+
+    quill.post_quill = MagicMock(side_effect=post_quill_side_effect)
+
+    result = quill.query(
+        tenants=[{"tenantField": "customer_id", "tenantIds": [2]}],
+        metadata={
+            "task": "report",
+            "clientId": "client-123",
+            "reportId": "report-456",
+            "databaseType": "PostgreSQL",
+        },
+        flags=[],
+    )
+
+    assert result["status"] == "success"
+    assert result["queries"]["queryResults"][0] is None
+

quillsql-2.2.3/quillsql/utils/run_query_processes.py

@@ -1,20 +0,0 @@
-def remove_fields(query_result, fields_to_remove):
-    fields = [
-        {"name": field["name"], "dataTypeID": field["dataTypeID"]}
-        for field in query_result["fields"]
-        if field["name"] not in fields_to_remove
-    ]
-    rows = [row for row in query_result["rows"]]
-    for row in rows:
-        for field in fields_to_remove:
-            if field in row:
-                del row[field]
-    return {"fields": fields, "rows": rows}
-
-
-def array_to_map(queries, array_to_map, metadata, target_pool):
-    mapped_array = []
-    for i in range(len(queries)):
-        query_result = target_pool.query(queries[i])
-        mapped_array.append(query_result.get("rows"))
-    return mapped_array

quillsql-2.2.3/tests/test_core.py

@@ -1,53 +0,0 @@
-import os
-import sys
-from unittest.mock import MagicMock, patch
-
-sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), "..")))
-
-from quillsql.core import Quill
-
-
-@patch("quillsql.core.CachedConnection")
-def test_query_handles_none_tenant_flag_responses(mock_cached_connection):
-    mock_connection = MagicMock()
-    mock_connection.database_type = "PostgreSQL"
-    mock_cached_connection.return_value = mock_connection
-
-    quill = Quill(
-        private_key="test-key",
-        database_type="PostgreSQL",
-        database_config={},
-    )
-
-    quill.run_queries = MagicMock(
-        side_effect=[
-            {"queryResults": [None]},
-            {"queryResults": []},
-        ]
-    )
-
-    def post_quill_side_effect(path, payload):
-        if path == "tenant-mapped-flags":
-            return {
-                "queries": [
-                    'SELECT * FROM (SELECT "id" AS "customer_id", "name" AS "quill_label", "id" AS "quill_flag" FROM "public"."customers") AS "subq_owner_query" WHERE "customer_id" IN (2)'
-                ],
-                "metadata": {"queryOrder": ["customer_id"]},
-            }
-        return {"queries": [], "metadata": {}}
-
-    quill.post_quill = MagicMock(side_effect=post_quill_side_effect)
-
-    result = quill.query(
-        tenants=["tenant-1"],
-        metadata={
-            "task": "report",
-            "clientId": "client-123",
-            "reportId": "report-456",
-            "databaseType": "PostgreSQL",
-        },
-    )
-
-    assert result["status"] == "success"
-    assert result["data"] == {}
-