Update app.py

app.py

@@ -2,10 +2,19 @@ import os
 import re
 import io
 import json
+import time
 import sqlite3
 import tempfile
+import threading
 import pandas as pd
 import urllib.request
+import urllib.error
+
+try:
+    import requests as _requests
+    HAS_REQUESTS = True
+except ImportError:
+    HAS_REQUESTS = False
 
 from fastapi import FastAPI, File, UploadFile, HTTPException, Request
 from fastapi.staticfiles import StaticFiles
@@ -41,89 +50,85 @@ class QueryRequest(BaseModel):
     question:   str
 
 
-# ─────────────────────────────
-# HEURISTIC SQL — disabled, Gemini handles everything
-# ─────────────────────────────
-
-def _heuristic_sql(question: str, table: str, cols: list = None):
-    return None
-
-
 # ─────────────────────────────
 # GEMINI CALL
+# retries=1 → fail fast, tell user immediately
+# do NOT change retries back to 4
 # ─────────────────────────────
 
-def _call_gemini(question: str, schema: str, columns: list, table: str):
+def _call_gemini(question: str, schema: str, columns: list, table: str,
+                 retries: int = 1):
 
     if not GEMINI_API_KEY:
         return ""
 
     prompt = f"""
 You are an expert SQLite data analyst.
-
 Return ONLY a valid SQL query. No explanation, no markdown, no text before or after.
-
 STRICT RULES:
 - Use only the table "{table}"
 - Never use DROP or DELETE
 - For GROUP BY queries, always include the grouped column in SELECT
 - For filtering, use the exact case as in the data
 - Return only one SQL statement ending without semicolon
-
 COLUMNS AVAILABLE:
 {", ".join(columns)}
-
 SCHEMA:
 {schema}
-
 QUESTION:
 {question}
 """
 
     url = (
-        f"https://generativelanguage.googleapis.com"
-        f"/v1beta/models/gemini-2.5-flash"
+        "https://generativelanguage.googleapis.com"
+        "/v1beta/models/gemini-2.5-flash"
         f":generateContent?key={GEMINI_API_KEY}"
     )
 
     payload = json.dumps({
-        "contents": [
-            {
-                "role": "user",
-                "parts": [{"text": prompt}]
-            }
-        ]
+        "contents": [{"role": "user", "parts": [{"text": prompt}]}]
     }).encode("utf-8")
 
-    try:
-        req = urllib.request.Request(
-            url,
-            data=payload,
-            headers={"Content-Type": "application/json"}
-        )
-
-        with urllib.request.urlopen(req, timeout=30) as resp:
-            data = json.loads(resp.read().decode())
-
+    for attempt in range(1, retries + 1):
         try:
-            sql = data["candidates"][0]["content"]["parts"][0]["text"]
-        except Exception:
-            return ""
-
-        if not sql:
+            req = urllib.request.Request(
+                url,
+                data=payload,
+                headers={"Content-Type": "application/json"}
+            )
+            with urllib.request.urlopen(req, timeout=30) as resp:
+                data = json.loads(resp.read().decode())
+
+            try:
+                sql = data["candidates"][0]["content"]["parts"][0]["text"]
+            except Exception:
+                return ""
+
+            if not sql:
+                return ""
+
+            sql = sql.replace("```sql", "").replace("```", "").strip()
+            sql = sql.split(";")[0].strip()
+
+            if "drop" in sql.lower() or "delete" in sql.lower():
+                return f'SELECT * FROM "{table}" LIMIT 10'
+
+            return sql
+
+        except urllib.error.HTTPError as e:
+            if e.code == 429:
+                print(f"⚠️ Gemini 429 — rate limited (attempt {attempt}/{retries})")
+                # fail fast — do not retry, tell user immediately
+                return ""
+            else:
+                print(f"❌ GEMINI HTTP ERROR {e.code}: {e}")
+                return ""
+
+        except Exception as e:
+            print(f"❌ GEMINI ERROR: {e}")
             return ""
 
-        sql = sql.replace("```sql", "").replace("```", "").strip()
-        sql = sql.split(";")[0].strip()
-
-        if "drop" in sql.lower() or "delete" in sql.lower():
-            return f'SELECT * FROM "{table}" LIMIT 10'
-
-        return sql
-
-    except Exception as e:
-        print("❌ GEMINI ERROR:", e)
-        return ""
+    return ""
 
 
 # ─────────────────────────────
@@ -173,7 +178,6 @@ async def upload_csv(file: UploadFile = File(...)):
         table_name = re.sub(r"[^a-zA-Z0-9_]", "_", file.filename)
         if table_name and table_name[0].isdigit():
             table_name = "t_" + table_name
-
         table_name = table_name[:40]
 
         with tempfile.NamedTemporaryFile(delete=False) as tf:
@@ -185,7 +189,6 @@ async def upload_csv(file: UploadFile = File(...)):
             ).fetchone()[0]
 
             conn.close()
-
             db_bytes = open(tf.name, "rb").read()
 
         os.remove(tf.name)
@@ -195,7 +198,6 @@ async def upload_csv(file: UploadFile = File(...)):
             "table": table_name,
             "cols":  list(df.columns)
         }
-
         _schema_store[session_id] = schema
 
         return {
@@ -217,14 +219,12 @@ async def upload_csv(file: UploadFile = File(...)):
 async def query(req: QueryRequest):
 
     data = _db_store.get(req.session_id)
-
     if not data and _db_store:
         data = list(_db_store.values())[-1]
-
     if not data:
         raise HTTPException(status_code=404, detail="No dataset loaded")
 
-    table = data["table"]
+    table  = data["table"]
     schema = (
         _schema_store.get(req.session_id)
         or list(_schema_store.values())[-1]
@@ -232,15 +232,17 @@ async def query(req: QueryRequest):
 
     sql = _call_gemini(req.question, schema, data["cols"], table)
 
-    if not sql or "error" in sql.lower():
-        sql = f'SELECT * FROM "{table}" LIMIT 10'
+    # If Gemini failed (429 or error), return clear error to Render bot
+    if not sql:
+        return {
+            "sql": "",
+            "results": [],
+            "error": "⚠️ AI busy (rate limit). Wait 60s and retry."
+        }
 
     results = execute_sql(sql, data["bytes"])
 
-    return {
-        "sql":     sql,
-        "results": results
-    }
+    return {"sql": sql, "results": results}
 
 
 # ─────────────────────────────
@@ -257,32 +259,23 @@ def health():
 
 
 # ─────────────────────────────
-# TELEGRAM WEBHOOK
+# TELEGRAM WEBHOOK — DISABLED
+# Telegram is now handled by Render bot (polling)
+# Do not re-enable — causes conflict with Render polling
 # ─────────────────────────────
 
-@app.on_event("startup")
-async def on_startup():
-    try:
-        from bot import setup_webhook
-        setup_webhook()
-    except Exception as e:
-        print(f"⚠️ Webhook setup skipped: {e}")
+# @app.on_event("startup")
+# async def on_startup():
+#     thread = threading.Thread(target=_background_webhook_setup, daemon=True)
+#     thread.start()
 
+# @app.get("/set-webhook")
+# async def set_webhook_endpoint():
+#     ...
 
-@app.post("/webhook/{token}")
-async def telegram_webhook(token: str, request: Request):
-    expected = os.getenv("BOT_TOKEN", "")
-    if token != expected:
-        raise HTTPException(status_code=403, detail="Invalid token")
-    try:
-        import telebot
-        from bot import bot
-        json_data = await request.json()
-        update = telebot.types.Update.de_json(json_data)
-        bot.process_new_updates([update])
-    except Exception as e:
-        print(f"❌ Webhook error: {e}")
-    return {"ok": True}
+# @app.post("/webhook/{token}")
+# async def telegram_webhook(token: str, request: Request):
+#     ...
 
 
 # ─────────────────────────────