quillsql 2.2.7__tar.gz → 2.2.8__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: quillsql
-Version: 2.2.7
+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.7 → 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"
@@ -386,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

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

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

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

quillsql-2.2.7/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!