Update app.py

app.py

@@ -1,11 +1,26 @@
 import os
-from fastapi import FastAPI, Request, HTTPException, Form
+from fastapi import FastAPI, Request, HTTPException, Form # Keep Form for now, though not used in webhook
 import uvicorn
 from gradio_client import Client
 from fastapi.responses import Response
 import json
-import re # Import re for potential future use (e.g., parsing messages)
-import asyncio # Import asyncio for async operations
+import re
+import asyncio
+from pydantic import BaseModel # Import BaseModel
+
+# Define Pydantic model for incoming Twilio webhook data
+# Twilio typically sends 'From', 'Body', 'MessageSid', etc. as form data,
+# but the previous log showed application/json. We'll adapt to expect JSON for now.
+# If Twilio is configured to send JSON, the keys should match exactly.
+# Assuming the keys are 'From' and 'Body' based on the previous error.
+class TwilioWebhookData(BaseModel):
+    From: str
+    Body: str
+    # Add other fields you expect in the JSON payload if needed, e.g.:
+    # MessageSid: str = None
+    # AccountSid: str = None
+    # To: str = None
+
 
 # Connect to your hosted Gradio Space (Futuresony/Mr.Events)
 # This client is used by BOTH the /chat and /webhook endpoints to interact with the core chatbot
@@ -15,13 +30,11 @@ try:
 except Exception as e:
     print(f"Error initializing Gradio Client for 'Futuresony/Mr.Events': {e}")
     print("Ensure the Space name is correct and it is accessible.")
-    client = None # Set client to None if initialization fails
+    client = None
 
 
 # Get your secure API key for THIS FastAPI application and the hosted Space from environment
-# Assuming the same API key (APP_API_KEY) is used for both.
 VALID_API_KEY = os.getenv("APP_API_KEY")
-# Add a print statement to confirm if the API key is loaded
 print(f"APP_API_KEY loaded: {'Yes' if VALID_API_KEY else 'No'}")
 if not VALID_API_KEY:
     print("Warning: APP_API_KEY secret not set. API key validation and calls to hosted space may fail.")
@@ -34,102 +47,75 @@ app = FastAPI()
 async def chat(request: Request):
     """
     Handles chat requests via a JSON payload, validates API key,
-    and calls the hosted Gradio chatbot with history.
+    and calls the hosted Gradio chatbot.
     """
     print("\n--- Received POST request at /chat ---")
     data = await request.json()
 
     # API Key Check for THIS FastAPI application
-    api_key = request.headers.get("X-API-Key") # Get API key from headers
+    api_key = request.headers.get("X-API-Key")
     print(f"API Key from header: {api_key[:4]}...") if api_key else "No API Key in header"
     if not VALID_API_KEY or api_key != VALID_API_KEY:
         print("API Key validation failed.")
         raise HTTPException(status_code=403, detail="Invalid API Key")
     print("API Key validation successful.")
 
-    # Get user message
     user_message = data.get("message")
     if not user_message:
         print("Error: 'message' is required in the request body.")
         raise HTTPException(status_code=400, detail="Message is required")
     print(f"User message: {user_message}")
 
-
-    # Get chat history (assuming it's sent in the request body for stateless API)
-    # The chat_history is expected to be a list of lists: [[user_msg, bot_msg], ...]
-    # If not provided, initialize as empty list.
-    chat_history = data.get("chat_history", [])
-    # print(f"Received chat history: {chat_history}") # Be cautious logging history
-
-
-    # --- Call the hosted Gradio chatbot ---
     if client is None:
         print("Error: Gradio Client not initialized. Cannot call chatbot.")
         raise HTTPException(status_code=500, detail="Chatbot service not available.")
 
     try:
-        print(f"Calling hosted Gradio Space 'Futuresony/Mr.Events' /chat endpoint from /chat...")
-        # Note: The Gradio ChatInterface API typically expects query (current message)
-        # and chat_history (history *before* the current turn).
-        # Use the same VALID_API_KEY for the hosted space call
-        result = await client.predict( # Use await because client.predict can be async
+        print(f"Calling hosted Gradio Space 'Futuresony/ABSA_Test_Space' /chat endpoint from /chat...")
+        result = await client.predict(
             query=user_message,
-            # chat_history=chat_history, # Remove chat_history parameter
-            api_key=VALID_API_KEY, # Pass the APP_API_KEY to the hosted space
-            api_name="/chat" # Ensure this matches the API endpoint exposed by the hosted Gradio app
+            api_key=VALID_API_KEY,
+            api_name="/chat"
         )
         print(f"Received raw result from hosted Space: {result}")
 
-        # The result from client.predict on a ChatInterface is typically the assistant's response string
         assistant_response = result
         if not isinstance(assistant_response, str):
             print(f"Warning: Hosted Space returned unexpected result type: {type(assistant_response)}. Raw result: {result}")
-            # Attempt to convert to string or handle appropriately
             assistant_response = str(assistant_response)
         print(f"Formatted assistant response: {assistant_response}")
 
-
     except Exception as e:
         print(f"Error calling hosted Gradio Space from /chat: {e}")
         raise HTTPException(status_code=500, detail=f"Error communicating with chatbot model: {e}")
 
-
     return {"response": assistant_response}
 
 
 # --- Twilio Webhook Endpoint ---
 # In-memory dictionary to store history per sender (NOT for production!)
-# Replace this with a persistent storage solution (database, file storage) for production.
 conversation_histories = {}
-# For production-level history management, you would initialize and interact with
-# a database or other persistent storage here.
 
 @app.post("/webhook")
 async def webhook(
-    # Explicitly receive form data parameters expected from Twilio
-    From: str = Form(...), # Sender's phone number
-    Body: str = Form(...), # Message content
-    # Twilio sends other parameters like MessageSid, To, AccountSid, etc.
-    # You can receive them here if needed:
-    # MessageSid: str = Form(None),
-    # To: str = Form(None),
-    request: Request = None # Keep request for raw access if needed
+    # Receive JSON data using the Pydantic model
+    data: TwilioWebhookData,
+    request: Request = None
 ):
     """
-    Handles incoming Twilio webhook requests for new messages,
+    Handles incoming Twilio webhook requests (expecting JSON),
     processes them with the chatbot, and returns TwiML.
     Note: This implementation uses in-memory history (NOT for production).
     """
-    print("\n--- Received POST request at /webhook from Twilio ---")
+    print("\n--- Received POST request at /webhook from Twilio (expecting JSON) ---")
 
-    # Access the incoming message and sender number directly from Form parameters
-    incoming_message = Body
-    sender_number = From
+    # Access incoming message and sender number from the Pydantic model instance
+    incoming_message = data.Body
+    sender_number = data.From
 
     print(f"Parsed Incoming Message: '{incoming_message}' from {sender_number}")
 
     # --- Conversation History Management (In-Memory - NOT Persistent!) ---
-    # In a real application, you would load/save history from a database/file.
     chat_history = conversation_histories.get(sender_number, [])
     print(f"Retrieved in-memory history for {sender_number}: {chat_history}")
 
@@ -140,18 +126,13 @@ async def webhook(
         bot_response = "Error: Chatbot service is not available."
     else:
         try:
-             # Use the same VALID_API_KEY for the hosted space call from webhook
-             print(f"Calling hosted Gradio Space 'Futuresony/Mr.Events' /chat endpoint from /webhook...")
+             print(f"Calling hosted Gradio Space 'Futuresony/ABSA_Test_Space' /chat endpoint from /webhook...")
              print(f"  Query: {incoming_message}")
-             # print(f"  History: {chat_history}") # Be cautious logging history
 
-             # Call the hosted chatbot with the retrieved history
-             # Gradio client expects query (current message) and chat_history (history *before* current turn)
-             result = await client.predict( # Use await
+             result = await client.predict(
                 query=incoming_message,
-                # chat_history=chat_history, # Remove chat_history parameter
-                api_key=VALID_API_KEY, # Pass the APP_API_KEY to the hosted space
-                api_name="/chat" # Ensure this matches the API endpoint exposed by the hosted Gradio app
+                api_key=VALID_API_KEY,
+                api_name="/chat"
              )
              print(f"Received raw result from hosted Space for webhook: {result}")
 
@@ -163,41 +144,22 @@ async def webhook(
 
         except Exception as e:
              print(f"Error calling hosted Gradio Space from /webhook: {e}")
-             bot_response = f"An error occurred while processing your request: {e}" # Provide a user-friendly error message
+             bot_response = f"An error occurred while processing your request: {e}"
 
 
     # --- Update and Store History (In-Memory - NOT Persistent!) ---
-    # Append the current turn (user message + bot response)
     chat_history.append([incoming_message, bot_response])
     conversation_histories[sender_number] = chat_history
     print(f"Updated in-memory history for {sender_number}: {conversation_histories[sender_number]}")
 
 
     # --- Generate TwiML Response ---
-    # Twilio expects TwiML XML to know what to do with the message
-    # Use f-string with triple single quotes for multi-line string to avoid conflicts with HTML-like tags
     twiml_response = f'''<Response><Message>{bot_response}</Message></Response>'''
     print(f"Generated TwiML response: {twiml_response}")
 
-    # Return TwiML with the correct media type
     return Response(content=twiml_response, media_type="application/xml")
 
 
 if __name__ == "__main__":
-    # When running this app.py directly (e.g., with `uvicorn app:app --reload`),
-    # this block is executed. On Hugging Face Spaces, the environment typically
-    # runs the FastAPI application directly without executing this block.
-    # If you need specific initializations (like loading RAG data, initializing cache)
-    # when running on Spaces via FastAPI directly, you might need to move them
-    # outside this __main__ block or ensure they are called on app startup.
-
-    # Example (commented out, adjust based on your needs):
-    # from app_components import authenticate_google_sheets, load_business_info, initialize_cache
-    # authenticate_google_sheets()
-    # load_business_info()
-    # initialize_cache()
-    # cleanup_expired_cache_entries() # Optional
-
-
     print("Starting FastAPI application with Uvicorn...")
-    uvicorn.run(app, host="0.0.0.0", port=7860) # HF default port
+    uvicorn.run(app, host="0.0.0.0", port=7860)