Update app.py

app.py

@@ -7,6 +7,7 @@ import json
 import os
 import sys
 import uuid
+import asyncio
 from datetime import datetime
 
 # Third party imports
@@ -37,7 +38,9 @@ CATEGORIES = {
 }
 
 # --- OpenAI Setup ---
+# Create both sync and async clients
 client = openai.OpenAI(api_key=os.getenv("OPENAI_API_KEY"))
+async_client = openai.AsyncOpenAI(api_key=os.getenv("OPENAI_API_KEY"))
 
 # --- Model Loading ---
 def load_lionguard2():
@@ -204,10 +207,12 @@ def vote_thumbs_down(text_id):
         return '<div style="color: #fca5a5; font-weight:700;">📝 Thanks for the feedback!</div>'
     return '<div>Voting not available or analysis not yet run.</div>'
 
-# --- Guardrail Comparison logic ---
-def get_openai_response(message, system_prompt="You are a helpful assistant."):
+# --- Guardrail Comparison logic (ASYNC VERSION) ---
+
+async def get_openai_response_async(message, system_prompt="You are a helpful assistant."):
+    """Async version of OpenAI API call"""
     try:
-        response = client.chat.completions.create(
+        response = await async_client.chat.completions.create(
             model="gpt-4.1-nano",
             messages=[
                 {"role": "system", "content": system_prompt},
@@ -221,15 +226,17 @@ def get_openai_response(message, system_prompt="You are a helpful assistant."):
     except Exception as e:
         return f"Error: {str(e)}. Please check your OpenAI API key."
 
-def openai_moderation(message):
+async def openai_moderation_async(message):
+    """Async version of OpenAI moderation"""
     try:
-        response = client.moderations.create(input=message)
+        response = await async_client.moderations.create(input=message)
         return response.results[0].flagged
     except Exception as e:
         print(f"Error in OpenAI moderation: {e}")
         return False
 
-def lionguard_2(message, threshold=0.5):
+def lionguard_2_sync(message, threshold=0.5):
+    """LionGuard remains sync as it's using a local model"""
     try:
         embeddings = get_embeddings([message])
         results = model.predict(embeddings)
@@ -239,68 +246,109 @@ def lionguard_2(message, threshold=0.5):
         print(f"Error in LionGuard 2: {e}")
         return False, 0.0
 
-def process_message(message, history_no_mod, history_openai, history_lg):
-    if not message.strip():
-        return history_no_mod, history_openai, history_lg, ""
-    no_mod_response = get_openai_response(message)
+async def process_no_moderation(message, history_no_mod):
+    """Process message without moderation"""
+    no_mod_response = await get_openai_response_async(message)
     history_no_mod.append({"role": "user", "content": message})
     history_no_mod.append({"role": "assistant", "content": no_mod_response})
+    return history_no_mod
 
-    openai_flagged = openai_moderation(message)
+async def process_openai_moderation(message, history_openai):
+    """Process message with OpenAI moderation"""
+    openai_flagged = await openai_moderation_async(message)
     history_openai.append({"role": "user", "content": message})
     if openai_flagged:
         openai_response = "🚫 This message has been flagged by OpenAI moderation"
         history_openai.append({"role": "assistant", "content": openai_response})
     else:
-        openai_response = get_openai_response(message)
+        openai_response = await get_openai_response_async(message)
         history_openai.append({"role": "assistant", "content": openai_response})
-
-    lg_flagged, lg_score = lionguard_2(message)
+    return history_openai
+
+async def process_lionguard(message, history_lg):
+    """Process message with LionGuard 2"""
+    # Run LionGuard sync check in thread pool to not block
+    loop = asyncio.get_event_loop()
+    lg_flagged, lg_score = await loop.run_in_executor(None, lionguard_2_sync, message, 0.5)
+    
     history_lg.append({"role": "user", "content": message})
     if lg_flagged:
         lg_response = "🚫 This message has been flagged by LionGuard 2"
         history_lg.append({"role": "assistant", "content": lg_response})
     else:
-        lg_response = get_openai_response(message)
+        lg_response = await get_openai_response_async(message)
         history_lg.append({"role": "assistant", "content": lg_response})
+    return history_lg, lg_score
 
-    # --- Logging for chatbot worksheet ---
+async def process_message_async(message, history_no_mod, history_openai, history_lg):
+    """Process message concurrently across all three guardrails"""
+    if not message.strip():
+        return history_no_mod, history_openai, history_lg, ""
+    
+    # Run all three processes concurrently using asyncio.gather
+    results = await asyncio.gather(
+        process_no_moderation(message, history_no_mod),
+        process_openai_moderation(message, history_openai),
+        process_lionguard(message, history_lg),
+        return_exceptions=True  # Continue even if one fails
+    )
+    
+    # Unpack results
+    history_no_mod = results[0] if not isinstance(results[0], Exception) else history_no_mod
+    history_openai = results[1] if not isinstance(results[1], Exception) else history_openai
+    history_lg_result = results[2] if not isinstance(results[2], Exception) else (history_lg, 0.0)
+    history_lg = history_lg_result[0]
+    lg_score = history_lg_result[1] if isinstance(history_lg_result, tuple) else 0.0
+
+    # --- Logging for chatbot worksheet (runs in background) ---
     if GOOGLE_SHEET_URL and GOOGLE_CREDENTIALS:
         try:
-            embeddings = get_embeddings([message])
-            results = model.predict(embeddings)
-            now = datetime.now().isoformat()
-            text_id = str(uuid.uuid4())
-            row = {
-                "datetime": now,
-                "text_id": text_id,
-                "text": message,
-                "binary_score": results.get("binary", [None])[0],
-                "hateful_l1_score": results.get(CATEGORIES['hateful'][0], [None])[0],
-                "hateful_l2_score": results.get(CATEGORIES['hateful'][1], [None])[0],
-                "insults_score": results.get(CATEGORIES['insults'][0], [None])[0],
-                "sexual_l1_score": results.get(CATEGORIES['sexual'][0], [None])[0],
-                "sexual_l2_score": results.get(CATEGORIES['sexual'][1], [None])[0],
-                "physical_violence_score": results.get(CATEGORIES['physical_violence'][0], [None])[0],
-                "self_harm_l1_score": results.get(CATEGORIES['self_harm'][0], [None])[0],
-                "self_harm_l2_score": results.get(CATEGORIES['self_harm'][1], [None])[0],
-                "aom_l1_score": results.get(CATEGORIES['all_other_misconduct'][0], [None])[0],
-                "aom_l2_score": results.get(CATEGORIES['all_other_misconduct'][1], [None])[0],
-                "openai_score": None
-            }
-            try:
-                openai_result = client.moderations.create(input=message)
-                # Using the "hate" category score as a demonstration. You may customize as needed.
-                row["openai_score"] = float(openai_result.results[0].category_scores.get("hate", 0.0))
-            except Exception:
-                row["openai_score"] = None
-
-            log_chatbot_data(row)
+            loop = asyncio.get_event_loop()
+            # Run logging in thread pool so it doesn't block
+            loop.run_in_executor(None, _log_chatbot_sync, message, lg_score)
         except Exception as e:
             print(f"Chatbot logging failed: {e}")
 
     return history_no_mod, history_openai, history_lg, ""
 
+def _log_chatbot_sync(message, lg_score):
+    """Sync helper for logging - runs in thread pool"""
+    try:
+        embeddings = get_embeddings([message])
+        results = model.predict(embeddings)
+        now = datetime.now().isoformat()
+        text_id = str(uuid.uuid4())
+        row = {
+            "datetime": now,
+            "text_id": text_id,
+            "text": message,
+            "binary_score": results.get("binary", [None])[0],
+            "hateful_l1_score": results.get(CATEGORIES['hateful'][0], [None])[0],
+            "hateful_l2_score": results.get(CATEGORIES['hateful'][1], [None])[0],
+            "insults_score": results.get(CATEGORIES['insults'][0], [None])[0],
+            "sexual_l1_score": results.get(CATEGORIES['sexual'][0], [None])[0],
+            "sexual_l2_score": results.get(CATEGORIES['sexual'][1], [None])[0],
+            "physical_violence_score": results.get(CATEGORIES['physical_violence'][0], [None])[0],
+            "self_harm_l1_score": results.get(CATEGORIES['self_harm'][0], [None])[0],
+            "self_harm_l2_score": results.get(CATEGORIES['self_harm'][1], [None])[0],
+            "aom_l1_score": results.get(CATEGORIES['all_other_misconduct'][0], [None])[0],
+            "aom_l2_score": results.get(CATEGORIES['all_other_misconduct'][1], [None])[0],
+            "openai_score": None
+        }
+        try:
+            openai_result = client.moderations.create(input=message)
+            row["openai_score"] = float(openai_result.results[0].category_scores.get("hate", 0.0))
+        except Exception:
+            row["openai_score"] = None
+
+        log_chatbot_data(row)
+    except Exception as e:
+        print(f"Error in sync logging: {e}")
+
+def process_message(message, history_no_mod, history_openai, history_lg):
+    """Wrapper function for Gradio (converts async to sync)"""
+    return asyncio.run(process_message_async(message, history_no_mod, history_openai, history_lg))
+
 def clear_all_chats():
     return [], [], []
 
@@ -362,6 +410,7 @@ with gr.Blocks(title="LionGuard 2 Demo", theme=gr.themes.Soft()) as demo:
 
         with gr.Tab("Guardrail Comparison"):
             gr.HTML(DISCLAIMER)
+            gr.HTML('<div style="background: #34d399; color: #1e293b; border-radius: 8px; padding: 12px; margin-bottom: 12px; font-size: 14px; font-weight:600;">⚡ Concurrent Processing: All 3 guardrails run in parallel for faster responses!</div>')
             with gr.Row():
                 with gr.Column(scale=1):
                     gr.Markdown("#### 🔵 No Moderation")