Update main.py

main.py

@@ -1,126 +1,31 @@
-from fastapi import FastAPI, HTTPException
-from fastapi.responses import StreamingResponse
-from fastapi.middleware.cors import CORSMiddleware
-from pydantic import BaseModel
 from hugchat import hugchat
 from hugchat.login import Login
-import os
-import logging
-
-# Set up logging
-logging.basicConfig(level=logging.INFO)
-logger = logging.getLogger(__name__)
-
+import fastapi
+from fastapi import FastAPI, Query
 app = FastAPI()
+# Your HuggingFace credentials
+EMAIL = "[email protected]"
+PASSWORD = "Allahisgreatest17"
+@app.post("/ask")
+def main(prompt: str = Query(..., description="The prompt for the AI")):
+    # Login and save cookies (optional cookie path omitted for simplicity)
+    sign = Login(EMAIL, PASSWORD)
+    cookies = sign.login(save_cookies=True)
+
+    # Initialize chatbot with cookies
+    chatbot = hugchat.ChatBot(cookies=cookies.get_dict())
 
-# Enable CORS for client compatibility
-app.add_middleware(
-    CORSMiddleware,
-    allow_origins=["*"],
-    allow_methods=["*"],
-    allow_headers=["*"],
-)
+    # Start a new conversation with your assistant ID
+    ASSISTANT_ID = "682e0c1f5f0c3d952a27498e"  # Replace with your assistant ID
+    chatbot.new_conversation(assistant=ASSISTANT_ID, switch_to=True)
 
-# Pydantic model for request body
-class QuestionRequest(BaseModel):
-    question: str
+    # Send message and get the full response (no streaming)
+    response = chatbot.chat(f"{prompt}", stream=False)
 
-# Global variable to store the chatbot instance
-chatbot = None
+    # Print full response
+    print("Assistant:", response)
+    return response
 
-def setup_chatbot(email, password, cookie_path, assistant_id):
-    """
-    Sets up the Hugging Face chatbot with login and conversation.
-    
-    Args:
-        email (str): User email for login
-        password (str): User password for login
-        cookie_path (str): Directory to store cookies
-        assistant_id (str): ID of the assistant to use
-    
-    Returns:
-        hugchat.ChatBot: Configured chatbot instance
-    """
-    try:
-        logger.info("Setting up chatbot...")
-        # Create cookie directory if it doesn't exist
-        os.makedirs(cookie_path, exist_ok=True)
-        
-        logger.info("Logging in with Hugging Face credentials...")
-        sign = Login(email, password)
-        cookies = sign.login(cookie_dir_path=cookie_path, save_cookies=True)
-        
-        logger.info("Initializing ChatBot...")
-        chatbot = hugchat.ChatBot(cookies=cookies.get_dict())
-        
-        logger.info(f"Creating new conversation with assistant ID: {assistant_id}")
-        chatbot.new_conversation(assistant=assistant_id, switch_to=True)
-        logger.info("Chatbot setup complete.")
-        return chatbot
-    except Exception as e:
-        logger.error(f"Failed to set up chatbot: {str(e)}")
-        raise Exception(f"Failed to set up chatbot: {e}")
 
-# Initialize chatbot at startup
-@app.on_event("startup")
-async def startup_event():
-    global chatbot
-    # Credentials and configuration
-    EMAIL = os.getenv("EMAIL")
-    PASSWD = os.getenv("PASSWD")
-    COOKIE_PATH_DIR = "./cookies/"
-    ASSISTANT_ID = "682e0c1f5f0c3d952a27498e"  # Replace with your actual assistant ID
-    
-    try:
-        chatbot = setup_chatbot(EMAIL, PASSWD, COOKIE_PATH_DIR, ASSISTANT_ID)
-    except Exception as e:
-        logger.error(f"Startup error: {str(e)}")
 
-@app.post("/generate")
-async def generate_response(request: QuestionRequest):
-    """
-    Generates a streaming response from the AI based on the provided question.
-    
-    Args:
-        request (QuestionRequest): JSON body containing the question.
-    
-    Returns:
-        StreamingResponse: A streaming response with the AI's reply.
-    """
-    global chatbot
-    if chatbot is None:
-        logger.error("Chatbot not initialized.")
-        async def generate_error():
-            error_message = "Error: Chatbot not initialized. Please try again later."
-            yield error_message.encode('utf-8')
-        return StreamingResponse(generate_error(), media_type="text/plain")
-    
-    async def generate():
-        try:
-            logger.info(f"Processing question: {request.question}")
-            # Use streaming to match client expectations
-            for token in chatbot.chat(request.question, stream=True):
-                # Handle hugchat response (token may be dict or string)
-                if isinstance(token, dict):
-                    token_text = token.get("token", "")
-                else:
-                    token_text = str(token)
-                
-                if token_text:
-                    logger.debug(f"Streaming token: {token_text}")
-                    yield token_text.encode('utf-8')
-                else:
-                    logger.warning("Empty token received.")
-            
-            # Fallback response if no tokens were yielded
-            if not any(True for _ in chatbot.chat(request.question, stream=True)):
-                fallback = "Welcome, valued client! How can Abdullah Ali and our premium team bring your vision to life with a custom website ($200–$600) or AI chatbot ($119)?"
-                logger.info("Using fallback response.")
-                yield fallback.encode('utf-8')
-        except Exception as e:
-            logger.error(f"Failed to generate response: {str(e)}")
-            error_message = f"Error: Failed to generate response: {str(e)}"
-            yield error_message.encode('utf-8')
-    
-    return StreamingResponse(generate(), media_type="text/plain")