quillsql 2.2.6__tar.gz → 2.2.8__tar.gz

{quillsql-2.2.6 → quillsql-2.2.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: quillsql
-Version: 2.2.6
+Version: 2.2.8
 Summary: Quill SDK for Python.
 Home-page: https://github.com/quill-sql/quill-python
 Author: Quill
@@ -67,3 +67,44 @@ async def quill_post(data: Request, user: dict = Depends(authenticate_jwt)):
 
 Then you can run your app like normally. Pass in this route to our react library
 on the frontend and you all set!
+
+## Streaming
+
+```python
+from quillsql import Quill
+from fastapi.responses import StreamingResponse
+import asyncio
+
+quill = Quill(
+    private_key=os.getenv("QULL_PRIVATE_KEY"),
+    database_connection_string=os.getenv("POSTGRES_READ"),
+    database_type="postgresql"
+)
+
+@app.post("/quill-stream")
+async def quill_post(data: Request, user: dict = Depends(authenticate_jwt)):
+    # assuming user fetched via auth middleware has an userId
+    user_id = user["user_id"]
+    body = await data.json()
+    metadata = body.get("metadata")
+
+    quill_stream = quill.stream(
+        tenants=[{"tenantField": "user_id", "tenantIds": [user_id]}],
+        metadata=metadata,
+    )
+
+    async def event_generator():
+        # Full event types list: https://ai-sdk.dev/docs/ai-sdk-ui/stream-protocol#data-stream-protocol
+        async for event in quill_stream:
+            if event["type"] == "start":
+                pass
+            elif event["type"] == "text-delta":
+                yield event['delta']
+            elif event["type"] == "finish":
+                return
+            elif event["type"] == "error":
+                yield event['errorText']
+            await asyncio.sleep(0)
+
+    return StreamingResponse(event_generator(), media_type="text/event-stream")
+```

quillsql-2.2.8/README.md

@@ -0,0 +1,87 @@
+# Quill Python SDK
+
+## Quickstart
+
+First, install the quillsql package by running:
+
+```bash
+$ pip install quillsql
+```
+
+Then, add a `/quill` endpoint to your existing python server. For example, if
+you were running a FASTAPI app, you would just add the endpoint like this:
+
+```python
+from quillsql import Quill
+
+quill = Quill(
+    private_key=os.getenv("QULL_PRIVATE_KEY"),
+    database_connection_string=os.getenv("POSTGRES_READ"),
+    database_type="postgresql"
+)
+
+security = HTTPBearer()
+
+async def authenticate_jwt(token: str = Depends(security)):
+    # Your JWT validation logic here
+    # Return user object or raise HTTPException
+    user = validate_jwt_token(token.credentials)
+    return user
+
+@app.post("/quill")
+async def quill_post(data: Request, user: dict = Depends(authenticate_jwt)):
+    # assuming user fetched via auth middleware has an userId
+    user_id = user["user_id"]
+    body = await data.json()
+    metadata = body.get("metadata")
+
+    result = quill.query(
+        tenants=[{"tenantField": "user_id", "tenantIds": [user_id]}],
+        metadata=metadata
+    )
+    return result
+```
+
+Then you can run your app like normally. Pass in this route to our react library
+on the frontend and you all set!
+
+## Streaming
+
+```python
+from quillsql import Quill
+from fastapi.responses import StreamingResponse
+import asyncio
+
+quill = Quill(
+    private_key=os.getenv("QULL_PRIVATE_KEY"),
+    database_connection_string=os.getenv("POSTGRES_READ"),
+    database_type="postgresql"
+)
+
+@app.post("/quill-stream")
+async def quill_post(data: Request, user: dict = Depends(authenticate_jwt)):
+    # assuming user fetched via auth middleware has an userId
+    user_id = user["user_id"]
+    body = await data.json()
+    metadata = body.get("metadata")
+
+    quill_stream = quill.stream(
+        tenants=[{"tenantField": "user_id", "tenantIds": [user_id]}],
+        metadata=metadata,
+    )
+
+    async def event_generator():
+        # Full event types list: https://ai-sdk.dev/docs/ai-sdk-ui/stream-protocol#data-stream-protocol
+        async for event in quill_stream:
+            if event["type"] == "start":
+                pass
+            elif event["type"] == "text-delta":
+                yield event['delta']
+            elif event["type"] == "finish":
+                return
+            elif event["type"] == "error":
+                yield event['errorText']
+            await asyncio.sleep(0)
+
+    return StreamingResponse(event_generator(), media_type="text/event-stream")
+```

quillsql-2.2.8/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.8}/quillsql/core.py

@@ -1,4 +1,5 @@
 import os
+import codecs
 from dotenv import load_dotenv
 
 import requests
@@ -29,7 +30,7 @@ load_dotenv()
 
 ENV = os.getenv("PYTHON_ENV")
 DEV_HOST = "http://localhost:8080"
-PROD_HOST = "https://quill-344421.uc.r.appspot.com"
+PROD_HOST = "https://api.quill.co"
 HOST = DEV_HOST if ENV == "development" else PROD_HOST
 
 SINGLE_TENANT = "QUILL_SINGLE_TENANT"
@@ -144,10 +145,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 +266,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"
@@ -383,6 +387,80 @@ class Quill:
                 "status": "error",
                 "data": responseMetadata,
             }
+        
+    async def stream(
+        self,
+        tenants,
+        metadata,
+        flags=None,
+    ):
+        if not tenants:
+            raise ValueError("You may not pass an empty tenants array.")
+
+        if not metadata:
+            yield {"type": "error", "errorText": "Missing metadata."}
+            return
+
+        task = metadata.get("task")
+        if not task:
+            yield {"type": "error", "errorText": "Missing task."}
+            return
+
+        try:
+            # Set tenant IDs in the connection
+            self.target_connection.tenant_ids = extract_tenant_ids(tenants)
+
+            # Handle tenant flags synthesis
+            tenant_flags = None
+            if tenants[0] == SINGLE_TENANT and flags:
+                if flags and isinstance(flags[0], dict):
+                    tenant_flags = [{'tenantField': SINGLE_TENANT, 'flags': flags}]
+                else:
+                    tenant_flags = flags
+
+            payload = { 
+                **metadata,
+                "tenants": tenants,
+                "flags": tenant_flags,
+            }
+            # Custom JSON Encoder to handle Enums
+            class EnumEncoder(json.JSONEncoder):
+                def default(self, obj):
+                    if isinstance(obj, Enum):
+                        return obj.value  # Convert enum to its value (string in this case)
+                    return super().default(obj)
+            url = f"{self.baseUrl}/sdk/{task}"
+            headers = {"Authorization": f"Bearer {self.private_key}", "Content-Type": "application/json","Accept": "text/event-stream"}
+            encoded = json.dumps(payload, cls=EnumEncoder)
+
+            resp = requests.post(url, data=encoded, headers=headers, stream=True)
+            decoder = codecs.getincrementaldecoder('utf-8')()
+            buf = ""
+            for chunk in resp.iter_content(chunk_size=4096):
+                buf += decoder.decode(chunk)
+                while "\n\n" in buf:
+                    raw_event, buf = buf.split("\n\n", 1)
+                    data_lines = []
+                    for line in raw_event.splitlines():
+                        if line.startswith("data:"):
+                            data_lines.append(line[len("data:"):].strip())
+                    if not data_lines:
+                        continue
+                    payload = "\n".join(data_lines)
+                    if payload == "[DONE]":
+                        break
+                    yield json.loads(payload)
+
+            # flush any partial code points at the end
+            buf += decoder.decode(b"", final=True)
+            yield buf
+            return
+        except Exception as err:
+            yield {
+                "type": "error",
+                "errorText": str(err).splitlines()[0],
+            }
+            return
 
     def apply_limit(self, query, limit):
         # Simple logic: if query already has a limit, don't add another
@@ -396,24 +474,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.8}/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.8}/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.8}/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.8/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.8}/quillsql.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: quillsql
-Version: 2.2.6
+Version: 2.2.8
 Summary: Quill SDK for Python.
 Home-page: https://github.com/quill-sql/quill-python
 Author: Quill
@@ -67,3 +67,44 @@ async def quill_post(data: Request, user: dict = Depends(authenticate_jwt)):
 
 Then you can run your app like normally. Pass in this route to our react library
 on the frontend and you all set!
+
+## Streaming
+
+```python
+from quillsql import Quill
+from fastapi.responses import StreamingResponse
+import asyncio
+
+quill = Quill(
+    private_key=os.getenv("QULL_PRIVATE_KEY"),
+    database_connection_string=os.getenv("POSTGRES_READ"),
+    database_type="postgresql"
+)
+
+@app.post("/quill-stream")
+async def quill_post(data: Request, user: dict = Depends(authenticate_jwt)):
+    # assuming user fetched via auth middleware has an userId
+    user_id = user["user_id"]
+    body = await data.json()
+    metadata = body.get("metadata")
+
+    quill_stream = quill.stream(
+        tenants=[{"tenantField": "user_id", "tenantIds": [user_id]}],
+        metadata=metadata,
+    )
+
+    async def event_generator():
+        # Full event types list: https://ai-sdk.dev/docs/ai-sdk-ui/stream-protocol#data-stream-protocol
+        async for event in quill_stream:
+            if event["type"] == "start":
+                pass
+            elif event["type"] == "text-delta":
+                yield event['delta']
+            elif event["type"] == "finish":
+                return
+            elif event["type"] == "error":
+                yield event['errorText']
+            await asyncio.sleep(0)
+
+    return StreamingResponse(event_generator(), media_type="text/event-stream")
+```

{quillsql-2.2.6 → quillsql-2.2.8}/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.8}/setup.py

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

quillsql-2.2.6/README.md

@@ -1,46 +0,0 @@
-# Quill Python SDK
-
-## Quickstart
-
-First, install the quillsql package by running:
-
-```bash
-$ pip install quillsql
-```
-
-Then, add a `/quill` endpoint to your existing python server. For example, if
-you were running a FASTAPI app, you would just add the endpoint like this:
-
-```python
-from quillsql import Quill
-
-quill = Quill(
-    private_key=os.getenv("QULL_PRIVATE_KEY"),
-    database_connection_string=os.getenv("POSTGRES_READ"),
-    database_type="postgresql"
-)
-
-security = HTTPBearer()
-
-async def authenticate_jwt(token: str = Depends(security)):
-    # Your JWT validation logic here
-    # Return user object or raise HTTPException
-    user = validate_jwt_token(token.credentials)
-    return user
-
-@app.post("/quill")
-async def quill_post(data: Request, user: dict = Depends(authenticate_jwt)):
-    # assuming user fetched via auth middleware has an userId
-    user_id = user["user_id"]
-    body = await data.json()
-    metadata = body.get("metadata")
-
-    result = quill.query(
-        tenants=[{"tenantField": "user_id", "tenantIds": [user_id]}],
-        metadata=metadata
-    )
-    return result
-```
-
-Then you can run your app like normally. Pass in this route to our react library
-on the frontend and you all set!

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