Update app.py

app.py

@@ -8,10 +8,12 @@ import tempfile
 import os
 import logging
 import time
+import json
 from datetime import datetime
 from html.parser import HTMLParser
 from fastapi import FastAPI, Request, Query
 from fastapi.responses import JSONResponse
+from fastapi.middleware.cors import CORSMiddleware
 import uvicorn
 
 logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(message)s')
@@ -32,7 +34,7 @@ logger.info("Models loaded!")
 
 def search_parallel(query):
     """DuckDuckGo search"""
-    logger.info("[SEARCH] Starting...")
+    logger.info(f"[SEARCH] Query: {query}")
     try:
         response = requests.get(
             'https://html.duckduckgo.com/html/',
@@ -66,15 +68,15 @@ def search_parallel(query):
             parser = DDGParser()
             parser.feed(response.text)
             result = "\n".join([f"• {r}" for r in parser.results[:2]]) if parser.results else "No results"
-            logger.info("[SEARCH] ✓")
+            logger.info(f"[SEARCH] ✓ Found {len(parser.results)} results")
             return result, "DuckDuckGo"
-    except:
-        pass
+    except Exception as e:
+        logger.error(f"[SEARCH] Error: {str(e)}")
     return "No search results", "None"
 
 def generate_answer(text_input):
     """Generate answer"""
-    logger.info(f"[AI] Question: {text_input[:60]}...")
+    logger.info(f"[AI] Question: {text_input}")
     
     try:
         if not text_input or not text_input.strip():
@@ -84,10 +86,11 @@ def generate_answer(text_input):
         
         search_start = time.time()
         search_results, search_engine = search_parallel(text_input)
-        logger.info(f"[AI] Search: {time.time()-search_start:.2f}s")
+        search_time = time.time() - search_start
+        logger.info(f"[AI] Search: {search_time:.2f}s")
         
         messages = [
-            {"role": "system", "content": f"Today is {current_date}. Answer briefly using search results (60-80 words)."},
+            {"role": "system", "content": f"Today is {current_date}. Answer briefly (60-80 words)."},
             {"role": "user", "content": f"Search:\n{search_results}\n\nQ: {text_input}\nA:"}
         ]
         
@@ -109,7 +112,9 @@ def generate_answer(text_input):
             )
         
         answer = tokenizer.decode(outputs[0][inputs['input_ids'].shape[1]:], skip_special_tokens=True).strip()
-        logger.info(f"[AI] Gen: {time.time()-gen_start:.2f}s | ✓")
+        gen_time = time.time() - gen_start
+        logger.info(f"[AI] Gen: {gen_time:.2f}s")
+        logger.info(f"[AI] Answer: {answer[:100]}...")
         
         return f"{answer}\n\n**Source:** {search_engine}"
         
@@ -120,40 +125,69 @@ def generate_answer(text_input):
 # FastAPI app
 app = FastAPI()
 
+# Add CORS
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+@app.middleware("http")
+async def log_requests(request: Request, call_next):
+    """Log all requests"""
+    logger.info("="*80)
+    logger.info(f"[REQUEST] Method: {request.method}")
+    logger.info(f"[REQUEST] URL: {request.url}")
+    logger.info(f"[REQUEST] Headers: {dict(request.headers)}")
+    logger.info(f"[REQUEST] Query params: {dict(request.query_params)}")
+    
+    # Read body if POST
+    if request.method == "POST":
+        body = await request.body()
+        logger.info(f"[REQUEST] Raw body ({len(body)} bytes): {body}")
+        try:
+            body_str = body.decode('utf-8')
+            logger.info(f"[REQUEST] Body as string: {body_str}")
+            body_json = json.loads(body_str)
+            logger.info(f"[REQUEST] Body as JSON: {body_json}")
+        except Exception as e:
+            logger.error(f"[REQUEST] Body parse error: {str(e)}")
+    
+    response = await call_next(request)
+    logger.info(f"[RESPONSE] Status: {response.status_code}")
+    logger.info("="*80)
+    return response
+
 @app.post("/api/ai")
 async def api_ai_post(request: Request):
-    """AI endpoint - POST with JSON body"""
+    """AI endpoint - POST"""
     try:
         body = await request.body()
-        logger.info(f"[API AI POST] Raw body: {body}")
         
         if not body:
-            return JSONResponse({"error": "Empty request body"}, status_code=400)
+            return JSONResponse({"error": "Empty body"}, status_code=400)
         
-        try:
-            data = await request.json()
-        except Exception as e:
-            logger.error(f"[API AI POST] JSON parse error: {str(e)}")
-            return JSONResponse({"error": f"Invalid JSON: {str(e)}"}, status_code=400)
-        
-        logger.info(f"[API AI POST] Parsed data: {data}")
+        data = json.loads(body.decode('utf-8'))
+        logger.info(f"[API POST] Parsed: {data}")
         
         question = data.get("text", "")
         if not question:
-            return JSONResponse({"error": "No 'text' field in JSON"}, status_code=400)
+            return JSONResponse({"error": "No 'text' field"}, status_code=400)
         
         answer = generate_answer(question)
         return JSONResponse({"answer": answer})
         
     except Exception as e:
-        logger.error(f"[API AI POST] Error: {str(e)}")
+        logger.error(f"[API POST] Error: {str(e)}")
         return JSONResponse({"error": str(e)}, status_code=500)
 
 @app.get("/api/ai")
-async def api_ai_get(text: str = Query(..., description="Question text")):
-    """AI endpoint - GET with query param (Pluely fallback)"""
+async def api_ai_get(text: str = Query(default="", description="Question")):
+    """AI endpoint - GET"""
     try:
-        logger.info(f"[API AI GET] Question: {text}")
+        logger.info(f"[API GET] text param: '{text}'")
         
         if not text:
             return JSONResponse({"error": "No text parameter"}, status_code=400)
@@ -162,40 +196,84 @@ async def api_ai_get(text: str = Query(..., description="Question text")):
         return JSONResponse({"answer": answer})
         
     except Exception as e:
-        logger.error(f"[API AI GET] Error: {str(e)}")
+        logger.error(f"[API GET] Error: {str(e)}")
         return JSONResponse({"error": str(e)}, status_code=500)
 
 @app.get("/health")
 async def health():
-    return {"status": "ok", "model": "SmolLM2-360M"}
+    return {"status": "ok", "model": "SmolLM2-360M", "endpoints": ["/api/ai (GET/POST)"]}
 
 # Gradio UI
 with gr.Blocks(title="Fast Q&A") as demo:
     gr.Markdown("""
-    # ⚡ Ultra-Fast Q&A - SmolLM2-360M
+    # ⚡ Fast Q&A - SmolLM2-360M
     
     ## 🎯 Pluely Configuration
     
-    ### Option 1: GET with Query Param (EASIEST - Windows Compatible)
+    ### Method 1: GET Request (RECOMMENDED - Works with Pluely)
+    
+    **Curl Command for Pluely:**
     ```
     curl https://archcoder-basic-app.hf.space/api/ai?text={{TEXT}}
     ```
+    
     **Response Path:** `answer`
     
-    ### Option 2: POST with JSON (If Option 1 doesn't work)
+    **Streaming:** OFF
+    
+    ---
+    
+    ### Method 2: POST Request (Alternative)
+    
+    **Curl Command for Pluely:**
     ```
-    curl -X POST https://archcoder-basic-app.hf.space/api/ai -H "Content-Type: application/json" --data-binary @- << EOF
-    {"text":"{{TEXT}}"}
-    EOF
+    curl -X POST https://archcoder-basic-app.hf.space/api/ai -H "Content-Type: application/json" -d {\"text\":\"{{TEXT}}\"}
     ```
+    
     **Response Path:** `answer`
+    
+    **Streaming:** OFF
+    
+    ---
+    
+    ## 🧪 Test Manually
+    
+    **Windows CMD:**
+    ```
+    curl "https://archcoder-basic-app.hf.space/api/ai?text=Who+is+the+president"
+    ```
+    
+    **PowerShell:**
+    ```
+    Invoke-RestMethod -Uri "https://archcoder-basic-app.hf.space/api/ai?text=Who is the president"
+    ```
+    
+    **Browser:**
+    ```
+    https://archcoder-basic-app.hf.space/api/ai?text=Who is the president
+    ```
     """)
     
     with gr.Tab("Test"):
-        test_input = gr.Textbox(label="Question")
+        test_input = gr.Textbox(label="Question", placeholder="Ask anything...")
         test_btn = gr.Button("🚀 Test")
         test_output = gr.Textbox(label="Answer", lines=8)
         test_btn.click(fn=generate_answer, inputs=[test_input], outputs=[test_output])
+    
+    with gr.Tab("Logs"):
+        gr.Markdown("""
+        ## How to Check Logs
+        
+        1. Go to your Hugging Face Space
+        2. Click on **"Logs"** tab at the top
+        3. You'll see all requests with:
+           - Request method and URL
+           - Headers
+           - Body content
+           - Response
+        
+        This helps debug what Pluely is actually sending!
+        """)
 
 app = gr.mount_gradio_app(app, demo, path="/")