Upload app (16).py

app (16).py

@@ -0,0 +1,203 @@
+import os
+from fastapi import FastAPI, Request, HTTPException, Form
+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
+
+# 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
+try:
+    client = Client("Futuresony/Mr.Events")
+    print("Gradio Client for 'Futuresony/Mr.Events' initialized.")
+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
+
+
+# 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.")
+
+
+app = FastAPI()
+
+# --- Chat Endpoint (Existing Functionality) ---
+@app.post("/chat")
+async def chat(request: Request):
+    """
+    Handles chat requests via a JSON payload, validates API key,
+    and calls the hosted Gradio chatbot with history.
+    """
+    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
+    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
+            query=user_message,
+            chat_history=chat_history, # Pass the history directly
+            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
+        )
+        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
+):
+    """
+    Handles incoming Twilio webhook requests for new messages,
+    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 ---")
+
+    # Access the incoming message and sender number directly from Form parameters
+    incoming_message = Body
+    sender_number = 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}")
+
+
+    # --- Call Chatbot Logic ---
+    if client is None:
+        print("Error: Gradio Client not initialized. Cannot call chatbot from 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"  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
+                query=incoming_message,
+                chat_history=chat_history, # Pass the retrieved history
+                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
+             )
+             print(f"Received raw result from hosted Space for webhook: {result}")
+
+             bot_response = result
+             if not isinstance(bot_response, str):
+                 print(f"Warning: Hosted Space returned unexpected result type for webhook: {type(bot_response)}. Raw result: {result}")
+                 bot_response = str(bot_response)
+             print(f"Formatted chatbot response for webhook: {bot_response}")
+
+        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
+
+
+    # --- 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