Upload main.py

main.py

@@ -1,166 +1,162 @@
-import os, json
-from fastapi import FastAPI, Request, HTTPException, Query
-from fastapi.responses import PlainTextResponse, JSONResponse
-import httpx
-import base64
-import asyncio
-
-app = FastAPI()
-
-VERIFY_TOKEN = os.getenv("VERIFY_TOKEN", "")  # set in HF Secrets
-PHONE_NUMBER_ID = os.getenv("PHONE_NUMBER_ID", "")
-WHATSAPP_API_TOKEN = os.getenv("WHATSAPP_API_TOKEN", "")
-RUMAS_API_URL = os.getenv("RUMAS_API_URL", "")
-
-async def forward_to_rumas(b64_str: str, wa_id: str):
-    """Fire-and-forget call to RUMAS /api/process_id."""
-    payload = {
-        "data": [b64_str],
-        "configurations": {
-            "iddetectionconfidence": "80",
-            "smartidconfidence": "50",
-            "greenidconfidence": "50",
-            "binaryString": "1111111011110011"
-        }
-    }
-    short = b64_str[:40]                       # first 40 chars for reference
-    try:
-        print(f"[RUMAS] ➜ sending image ({len(b64_str)} bytes) "
-              f"preview='{short}…'")
-
-        print("Payload to RUMAS:", json.dumps(payload)[:300], "…")
-
-        async with httpx.AsyncClient(timeout=60) as client:
-            resp = await client.post(RUMAS_API_URL, json=payload)
-            resp.raise_for_status()
-            # ── log the full JSON response (truncated to 300 chars for brevity) ──
-            data = resp.json()
-            print(f"[RUMAS] ✔ 200 {json.dumps(data)[:300]}…")
-            body = data
-            print(f"[RUMAS] ✔ {resp.status_code}")
-            pretty_print_dict(body)
-
-            # ── send parsed ID back to WhatsApp ──
-            if wa_id and data.get("status") == "success":
-                det = data["results"][0]["detections"][0]
-                # build a line-by-line summary of every field
-                fields = [
-                    "status", "message", "id_num", "name", "surname",
-                    "date_of_birth", "gender", "id_type", "cob",
-                    "citizen", "citizen_status", "date_issued", "age"
-                ]
-                lines = ["✅ *ID processed*"]
-                for field in fields:
-                    # Title-case the key and fetch its value (empty string if missing)
-                    pretty_key = field.replace("_", " ").title()
-                    lines.append(f"*{pretty_key}*: {det.get(field, '')}")
-                send_whatsapp_message(wa_id, "\n".join(lines))
-
-    except Exception as e:
-        print(f"[RUMAS] ✘ error while sending '{short}…' →", e)
-
-def pretty_print_dict(d, indent=0):
-    for k, v in d.items():
-        if isinstance(v, dict):
-            print(' ' * indent + f"{k}:")
-            pretty_print_dict(v, indent + 2)
-        elif isinstance(v, list):
-            print(' ' * indent + f"{k}: [")
-            for item in v:
-                if isinstance(item, dict):
-                    pretty_print_dict(item, indent + 2)
-                else:
-                    print(' ' * (indent + 2) + str(item))
-            print(' ' * indent + "]")
-        else:
-            print(' ' * indent + f"{k}: {v}")
-
-@app.get("/webhook")  # verification
-def verify(
-    hub_mode: str = Query(None, alias="hub.mode"),
-    hub_token: str = Query(None, alias="hub.verify_token"),
-    hub_challenge: str = Query(None, alias="hub.challenge")
-):
-    if hub_mode == "subscribe" and hub_token == VERIFY_TOKEN:
-        return PlainTextResponse(hub_challenge)
-    raise HTTPException(status_code=403, detail="Invalid token")
-
-def send_whatsapp_message(wa_id, reply):
-    url = f"https://graph.facebook.com/v23.0/{PHONE_NUMBER_ID}/messages"
-    headers = {
-        "Authorization": f"Bearer {WHATSAPP_API_TOKEN}",
-        "Content-Type": "application/json"
-    }
-    payload = {
-        "messaging_product": "whatsapp",
-        "to": wa_id,
-        "type": "text",
-        "text": {"body": reply}
-    }
-    httpx.post(url, headers=headers, json=payload)
-
-@app.post("/webhook")  # incoming WhatsApp updates
-async def receive_update(req: Request):
-    data = await req.json()
-    try:
-        change   = data["entry"][0]["changes"][0]["value"]
-        contacts = change.get("contacts")
-        messages = change.get("messages")
-        if not contacts or not messages:
-            # Missing expected payload—ignore
-            print("Ignoring update, no contacts or messages field")
-            return JSONResponse({"status": "ignored", "reason": "no contacts/messages"})
-
-        wa_id = contacts[0]["wa_id"]
-        msg   = messages[0]
-    except (KeyError, IndexError, TypeError) as e:
-        print("Malformed webhook payload:", e)
-        return JSONResponse({"status": "ignored", "reason": "malformed payload"})
-
-    # IMAGE: if user sent an image, convert to Base64 preview
-    if msg["type"] == "image":
-        media_id = msg["image"]["id"]
-        # 1) get media URL
-        media_resp = httpx.get(
-            f"https://graph.facebook.com/v23.0/{media_id}",
-            headers={"Authorization": f"Bearer {WHATSAPP_API_TOKEN}"}
-        )
-        media_resp.raise_for_status()
-        media_url = media_resp.json()["url"]
-        # 2) download bytes with auth
-        media_bytes = httpx.get(
-            media_url,
-            headers={"Authorization": f"Bearer {WHATSAPP_API_TOKEN}"}
-        ).content
-        # 3) encode full & preview
-        full_b64 = base64.b64encode(media_bytes).decode("utf-8")
-        preview  = full_b64[:10]
-
-        # 4) forward full string to RUMAS (non-blocking)
-        asyncio.create_task(forward_to_rumas(full_b64, wa_id))
-
-        # 5) echo preview to the user
-        send_whatsapp_message(wa_id, f"Base64: {preview}")
-        return JSONResponse({"status": "image_preview_sent", "preview": preview})
-
-    # TEXT: simple echo
-    if msg["type"] == "text":
-        incoming = msg["text"]["body"]
-        reply    = f"You said: {incoming}"
-        send_whatsapp_message(wa_id, reply)
-        return JSONResponse({"status": "replied"})
-
-    # OTHER: ignore
-    return JSONResponse({"status": "ignored", "type": msg["type"]})
-
-# health-check endpoint for token
-@app.post("/send")
-async def check_token():
-    token = os.getenv("WHATSAPP_API_TOKEN", "")
-    if token:
-        return {"token_loaded": True}
-    raise HTTPException(status_code=400, detail="Token not found")
-
-@app.get("/ping")      # health check
-def ping():
+import os, json
+from fastapi import FastAPI, Request, HTTPException, Query
+from fastapi.responses import PlainTextResponse, JSONResponse
+import httpx
+import base64
+import asyncio
+
+app = FastAPI()
+
+VERIFY_TOKEN = os.getenv("VERIFY_TOKEN", "")  # set in HF Secrets
+PHONE_NUMBER_ID = os.getenv("PHONE_NUMBER_ID", "")
+WHATSAPP_API_TOKEN = os.getenv("WHATSAPP_API_TOKEN", "")
+RUMAS_API_URL = os.getenv("RUMAS_API_URL", "")
+
+async def forward_to_rumas(b64_str: str, wa_id: str):
+    """Fire-and-forget call to RUMAS /api/process_id."""
+    payload = {
+        "data": [b64_str],
+        "configurations": {
+            "iddetectionconfidence": "80",
+            "smartidconfidence": "50",
+            "greenidconfidence": "50",
+            "binaryString": "1111111011110011"
+        }
+    }
+    short = b64_str[:40]                       # first 40 chars for reference
+    try:
+        print(f"[RUMAS] ➜ sending image ({len(b64_str)} bytes) "
+              f"preview='{short}…'")
+
+        print("Payload to RUMAS:", json.dumps(payload)[:300], "…")
+
+        async with httpx.AsyncClient(timeout=60) as client:
+            resp = await client.post(RUMAS_API_URL, json=payload)
+            resp.raise_for_status()
+            # ── log the full JSON response (truncated to 300 chars for brevity) ──
+            data = resp.json()
+            print(f"[RUMAS] ✔ 200 {json.dumps(data)[:300]}…")
+            body = data
+            print(f"[RUMAS] ✔ {resp.status_code}")
+            pretty_print_dict(body)
+
+            # ── send parsed ID back to WhatsApp ──
+            if wa_id and data.get("status") == "success":
+                det = data["results"][0]["detections"][0]
+                reply = (
+                    "✅ *ID processed*\n"
+                    f"*Name*: {det.get('name','?')} {det.get('surname','')}\n"
+                    f"*ID No.*: {det.get('id_num','?')}\n"
+                    f"*DOB*: {det.get('date_of_birth','?')}\n"
+                    f"*Gender*: {det.get('gender','?')}"
+                )
+                send_whatsapp_message(wa_id, reply)
+
+    except Exception as e:
+        print(f"[RUMAS] ✘ error while sending '{short}…' →", e)
+
+def pretty_print_dict(d, indent=0):
+    for k, v in d.items():
+        if isinstance(v, dict):
+            print(' ' * indent + f"{k}:")
+            pretty_print_dict(v, indent + 2)
+        elif isinstance(v, list):
+            print(' ' * indent + f"{k}: [")
+            for item in v:
+                if isinstance(item, dict):
+                    pretty_print_dict(item, indent + 2)
+                else:
+                    print(' ' * (indent + 2) + str(item))
+            print(' ' * indent + "]")
+        else:
+            print(' ' * indent + f"{k}: {v}")
+
+@app.get("/webhook")  # verification
+def verify(
+    hub_mode: str = Query(None, alias="hub.mode"),
+    hub_token: str = Query(None, alias="hub.verify_token"),
+    hub_challenge: str = Query(None, alias="hub.challenge")
+):
+    if hub_mode == "subscribe" and hub_token == VERIFY_TOKEN:
+        return PlainTextResponse(hub_challenge)
+    raise HTTPException(status_code=403, detail="Invalid token")
+
+def send_whatsapp_message(wa_id, reply):
+    url = f"https://graph.facebook.com/v23.0/{PHONE_NUMBER_ID}/messages"
+    headers = {
+        "Authorization": f"Bearer {WHATSAPP_API_TOKEN}",
+        "Content-Type": "application/json"
+    }
+    payload = {
+        "messaging_product": "whatsapp",
+        "to": wa_id,
+        "type": "text",
+        "text": {"body": reply}
+    }
+    httpx.post(url, headers=headers, json=payload)
+
+@app.post("/webhook")  # incoming WhatsApp updates
+async def receive_update(req: Request):
+    data = await req.json()
+    try:
+        change   = data["entry"][0]["changes"][0]["value"]
+        contacts = change.get("contacts")
+        messages = change.get("messages")
+        if not contacts or not messages:
+            # Missing expected payload—ignore
+            print("Ignoring update, no contacts or messages field")
+            return JSONResponse({"status": "ignored", "reason": "no contacts/messages"})
+
+        wa_id = contacts[0]["wa_id"]
+        msg   = messages[0]
+    except (KeyError, IndexError, TypeError) as e:
+        print("Malformed webhook payload:", e)
+        return JSONResponse({"status": "ignored", "reason": "malformed payload"})
+
+    # IMAGE: if user sent an image, convert to Base64 preview
+    if msg["type"] == "image":
+        media_id = msg["image"]["id"]
+        # 1) get media URL
+        media_resp = httpx.get(
+            f"https://graph.facebook.com/v23.0/{media_id}",
+            headers={"Authorization": f"Bearer {WHATSAPP_API_TOKEN}"}
+        )
+        media_resp.raise_for_status()
+        media_url = media_resp.json()["url"]
+        # 2) download bytes with auth
+        media_bytes = httpx.get(
+            media_url,
+            headers={"Authorization": f"Bearer {WHATSAPP_API_TOKEN}"}
+        ).content
+        # 3) encode full & preview
+        full_b64 = base64.b64encode(media_bytes).decode("utf-8")
+        preview  = full_b64[:10]
+
+        # 4) forward full string to RUMAS (non-blocking)
+        asyncio.create_task(forward_to_rumas(full_b64, wa_id))
+
+        # 5) echo preview to the user
+        send_whatsapp_message(wa_id, f"Base64: {preview}")
+        return JSONResponse({"status": "image_preview_sent", "preview": preview})
+
+    # TEXT: simple echo
+    if msg["type"] == "text":
+        incoming = msg["text"]["body"]
+        reply    = f"You said: {incoming}"
+        send_whatsapp_message(wa_id, reply)
+        return JSONResponse({"status": "replied"})
+
+    # OTHER: ignore
+    return JSONResponse({"status": "ignored", "type": msg["type"]})
+
+# health-check endpoint for token
+@app.post("/send")
+async def check_token():
+    token = os.getenv("WHATSAPP_API_TOKEN", "")
+    if token:
+        return {"token_loaded": True}
+    raise HTTPException(status_code=400, detail="Token not found")
+
+@app.get("/ping")      # health check
+def ping():
     return {"pong": True}