Upload 5 files

Dockerfile

@@ -1,25 +1,12 @@
-FROM python:3.11-slim
+FROM python:3.9
 
-# Set working directory
-WORKDIR /app
-
-# Copy requirements first for better caching
-COPY requirements.txt .
-
-# Install dependencies
-RUN pip install --no-cache-dir -r requirements.txt
+RUN useradd -m -u 1000 user
+USER user
+ENV PATH="/home/user/.local/bin:$PATH"
 
-# Copy application code
-COPY main.py .
-
-# Create a test image file (optional - for development)
-RUN echo "This is a test image file" > test.jpg
-
-# Expose port 8080 for Hugging Face Spaces
-EXPOSE 8080
+WORKDIR /app
+COPY --chown=user . .
 
-# Set environment variables for better logging
-ENV PYTHONUNBUFFERED=1
+RUN pip install --no-cache-dir --upgrade -r requirements.txt
 
-# Run the application with Uvicorn
-CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "8080"]
+CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "7860"] 

main.py

@@ -5,171 +5,97 @@ import os
 import httpx
 import base64
 
-app = FastAPI(title="WhatsApp ChatBot", version="1.0.0")
+app = FastAPI()
+VERIFY_TOKEN = os.getenv('VERIFY_TOKEN')
+PHONE_NUMBER_ID = os.getenv('PHONE_NUMBER_ID')
+WHATSAPP_API_TOKEN = os.getenv('WHATSAPP_API_TOKEN')
 
-# Load environment variables
-VERIFY_TOKEN = os.getenv("VERIFY_TOKEN", "")
-WHATSAPP_API_TOKEN = os.getenv("WHATSAPP_API_TOKEN", "")
-PHONE_NUMBER_ID = os.getenv("PHONE_NUMBER_ID", "")
+if not all([VERIFY_TOKEN, WHATSAPP_API_TOKEN, PHONE_NUMBER_ID]):
+    raise ValueError("Missing required environment variables")
 
 @app.get("/")
 def root():
-    return {"message": "WhatsApp ChatBot API", "status": "running"}
+    return {"message": "Hello from WhatsApp ChatBot"}
 
-@app.get("/health")
-def health_check():
-    return {"status": "healthy", "verify_token_loaded": bool(VERIFY_TOKEN), "api_token_loaded": bool(WHATSAPP_API_TOKEN)}
+@app.get("/ping")
+def ping():
+    return {"pong": True}
+
+@app.get("/test")
+async def test_get():
+    return {"detail": "GET method working"}
+
+@app.post("/test")
+async def test_post():
+    return {"detail": "POST method working"}
 
 @app.get("/webhook")
-async def verify_webhook(
-    hub_mode: str = Query(..., alias="hub.mode"),
-    hub_token: str = Query(..., alias="hub.verify_token"),
-    hub_challenge: str = Query(..., alias="hub.challenge")
+def verify(
+    hub_mode:        Optional[str] = Query(None, alias="hub.mode"),
+    hub_challenge:   Optional[str] = Query(None, alias="hub.challenge"),
+    hub_verify_token: Optional[str] = Query(None, alias="hub.verify_token"),
 ):
-    """
-    Verify webhook with Meta's WhatsApp Business API
-    """
-    if hub_mode == "subscribe" and hub_token == VERIFY_TOKEN:
-        return PlainTextResponse(hub_challenge)
-    raise HTTPException(status_code=403, detail="Verification failed")
+    # 1) Initial probe
+    if hub_mode is None and hub_challenge is None and hub_verify_token is None:
+        return PlainTextResponse(status_code=200, content="")
+
+    # 2) Real handshake: echo back challenge (temporarily ignore token)
+    if hub_mode == "subscribe":
+        return PlainTextResponse(content=hub_challenge or "", media_type="text/plain")
+
+    # 3) Everything else → forbidden
+    if hub_verify_token != VERIFY_TOKEN:
+        raise HTTPException(status_code=403, detail="Invalid verify token")
 
 @app.post("/webhook")
 async def receive_webhook(request: Request):
-    """
-    Receive incoming WhatsApp messages
-    """
+    data = await request.json()
     try:
-        data = await request.json()
-        
-        # Extract message from webhook payload
-        entry = data.get("entry", [])
-        if not entry:
-            return {"status": "no_entry"}
-            
-        changes = entry[0].get("changes", [])
-        if not changes:
-            return {"status": "no_changes"}
-            
-        value = changes[0].get("value", {})
-        messages = value.get("messages", [])
-        
-        if not messages:
-            return {"status": "no_messages"}
-            
-        msg = messages[0]
-        wa_id = msg.get("from")
-        msg_type = msg.get("type")
-        
-        if not wa_id:
-            return {"status": "no_sender_id"}
-        
+        msg = data["entry"][0]["changes"][0]["value"]["messages"][0]
+        wa_id = msg["from"]
+        msg_type = msg["type"]
+
         if msg_type == "image":
-            # Handle image message
             media_id = msg["image"]["id"]
             image_bytes = await download_whatsapp_media(media_id)
-            
-            if image_bytes:
-                # Convert to base64
-                b64_str = base64.b64encode(image_bytes).decode('utf-8')
-                reply = f"Image received! Base64 (first 50 chars): {b64_str[:50]}..."
-                
-                # Send reply
-                await send_whatsapp_message(wa_id, reply)
-                
-                return {
-                    "status": "success",
-                    "message_type": "image",
-                    "base64_length": len(b64_str),
-                    "base64_preview": b64_str[:50]
-                }
-            else:
-                await send_whatsapp_message(wa_id, "Sorry, I couldn't process your image.")
-                return {"status": "error", "message": "Failed to download image"}
+            if not image_bytes:
+                return {"status": "error", "message": "Failed to process image"}
+            b64_str = base64.b64encode(image_bytes).decode('utf-8')
+            reply = f"Base64: {b64_str[:10]}"
+            send_whatsapp_message(wa_id, reply)
+            return {"status": "success", "base64_first_10": b64_str[:10]}
         else:
-            # Handle non-image messages
-            await send_whatsapp_message(wa_id, "Please send an image and I'll process it for you!")
-            return {"status": "replied", "message": "Requested image"}
-            
+            send_whatsapp_message(wa_id, "Please send an image.")
+            return {"status": "replied", "message": "Please send an image"}
     except Exception as e:
-        print(f"Webhook error: {e}")
-        return JSONResponse(
-            content={"error": str(e), "status": "error"}, 
-            status_code=400
-        )
+        print("Webhook error:", e)
+        return JSONResponse(content={"error": str(e)}, status_code=400)
 
-async def download_whatsapp_media(media_id: str) -> Optional[bytes]:
-    """
-    Download media from WhatsApp Cloud API
-    Currently stubbed - replace with actual implementation
-    """
+async def download_whatsapp_media(media_id):
     try:
-        # Stub implementation - replace with actual WhatsApp media download
-        # For now, return a test image or None
         with open("test.jpg", "rb") as f:
             return f.read()
     except FileNotFoundError:
-        print(f"Media file not found for ID: {media_id}")
-        return None
-    except Exception as e:
-        print(f"Error downloading media {media_id}: {e}")
+        print("test.jpg not found")
         return None
 
-async def send_whatsapp_message(to: str, text: str) -> bool:
-    """
-    Send WhatsApp message via Cloud API
-    """
-    if not WHATSAPP_API_TOKEN or not PHONE_NUMBER_ID:
-        print("Missing WhatsApp API token or phone number ID")
-        return False
-        
+def send_whatsapp_message(wa_id, text):
     url = f"https://graph.facebook.com/v19.0/{PHONE_NUMBER_ID}/messages"
-    
     headers = {
         "Authorization": f"Bearer {WHATSAPP_API_TOKEN}",
         "Content-Type": "application/json"
     }
-    
     payload = {
         "messaging_product": "whatsapp",
-        "to": to,
+        "to": wa_id,
         "type": "text",
         "text": {"body": text}
     }
-    
-    try:
-        async with httpx.AsyncClient() as client:
-            response = await client.post(url, headers=headers, json=payload)
-            response.raise_for_status()
-            print(f"Message sent successfully to {to}")
-            return True
-    except Exception as e:
-        print(f"Error sending message to {to}: {e}")
-        return False
-
-@app.get("/test")
-async def test_endpoint():
-    """
-    Test endpoint to verify API is working
-    """
-    return {
-        "message": "API is working!",
-        "verify_token_configured": bool(VERIFY_TOKEN),
-        "api_token_configured": bool(WHATSAPP_API_TOKEN),
-        "phone_number_configured": bool(PHONE_NUMBER_ID)
-    }
+    httpx.post(url, headers=headers, json=payload)
 
 @app.post("/send")
 async def check_token():
-    """
-    Health check endpoint to verify WhatsApp API token configuration
-    """
-    if WHATSAPP_API_TOKEN:
-        return {"token_loaded": True, "message": "WhatsApp API token is configured"}
-    return JSONResponse(
-        content={"error": "Token not found in environment", "token_loaded": False}, 
-        status_code=400
-    )
-
-if __name__ == "__main__":
-    import uvicorn
-    uvicorn.run(app, host="0.0.0.0", port=8080) 
+    token = WHATSAPP_API_TOKEN
+    if token:
+        return {"token_loaded": True}
+    return JSONResponse(content={"error": "Token not found in environment"}, status_code=400) 

requirements.txt

@@ -1,4 +1,3 @@
-fastapi==0.104.1
-uvicorn[standard]==0.24.0
-httpx==0.25.2
-python-multipart==0.0.6 
+fastapi
+uvicorn
+httpx