Create app.py

app.py

@@ -0,0 +1,184 @@
+import gradio as gr
+import requests
+import json
+import pandas as pd
+from difflib import get_close_matches
+
+KYS_SAMPLE = "https://kys.udiseplus.gov.in/webapp/api/search-schools?searchType=3&searchParam={udise}"
+
+
+def call_kys_by_udise(udise_code):
+    url = KYS_SAMPLE.format(udise=udise_code)
+    try:
+        resp = requests.get(url, timeout=10)
+        resp.raise_for_status()
+        data = resp.json()
+        return {"ok": True, "url": url, "data": data}
+    except Exception as e:
+        return {"ok": False, "error": str(e), "url": url}
+
+
+def call_tavily(tavily_url, api_key, payload_text):
+    headers = {"Accept": "application/json"}
+    if api_key:
+        headers["Authorization"] = api_key
+    body = {"query": payload_text}
+    try:
+        resp = requests.post(tavily_url, json=body, headers=headers, timeout=12)
+        resp.raise_for_status()
+        return {"ok": True, "url": tavily_url, "status_code": resp.status_code, "data": resp.json()}
+    except Exception as e:
+        # fallback to GET
+        try:
+            params = {"q": payload_text}
+            resp = requests.get(tavily_url, params=params, headers=headers, timeout=12)
+            resp.raise_for_status()
+            return {"ok": True, "url": resp.url, "status_code": resp.status_code, "data": resp.json()}
+        except Exception as e2:
+            return {"ok": False, "error": f"POST failed: {e}; GET failed: {e2}"}
+
+
+def extract_udise_candidates_from_tavily(tavily_json):
+    # Heuristic: walk the JSON and collect strings that look like UDISE (digits, length 6-14)
+    found = set()
+
+    def walk(obj):
+        if isinstance(obj, dict):
+            for v in obj.values():
+                walk(v)
+        elif isinstance(obj, list):
+            for item in obj:
+                walk(item)
+        elif isinstance(obj, str):
+            s = obj.strip()
+            tokens = s.replace('-', ' ').split()
+            for t in tokens:
+                if t.isdigit() and 6 <= len(t) <= 14:
+                    found.add(t)
+
+    walk(tavily_json)
+    return sorted(list(found))
+
+
+def json_to_table(obj):
+    # Try to convert a JSON object/array to pandas DataFrame for display
+    try:
+        if isinstance(obj, list):
+            df = pd.json_normalize(obj)
+            return df
+        if isinstance(obj, dict):
+            # Often tavily returns {"results": [...]}
+            if "results" in obj and isinstance(obj["results"], list):
+                return pd.json_normalize(obj["results"])
+            # common patterns: top-level list wrapped in data or hits
+            for k in ("data", "hits", "items", "results"):
+                if k in obj and isinstance(obj[k], list):
+                    return pd.json_normalize(obj[k])
+            # fallback: flatten dict to single-row table
+            return pd.json_normalize([obj])
+    except Exception:
+        pass
+    return pd.DataFrame()
+
+
+def to_table_from_kys(kys_json):
+    try:
+        items = kys_json.get("data") if isinstance(kys_json, dict) else kys_json
+        if isinstance(items, dict) and "data" in items:
+            items = items["data"]
+        if not items:
+            return pd.DataFrame()
+        df = pd.json_normalize(items)
+        return df
+    except Exception:
+        return pd.DataFrame()
+
+
+def search_workflow(school_name_or_udise, tavily_url, tavily_key, use_tavily, use_kys):
+    out = {"kys": None, "tavily": None, "suggestions": []}
+
+    if use_tavily and tavily_url:
+        tavily_res = call_tavily(tavily_url, tavily_key, school_name_or_udise or "")
+        out["tavily"] = tavily_res
+        if tavily_res.get("ok"):
+            candidates = extract_udise_candidates_from_tavily(tavily_res["data"])
+            out["suggestions"] = candidates
+    else:
+        out["tavily"] = {"ok": False, "error": "Tavily disabled or no URL provided"}
+
+    # If user provided a numeric UDISE directly and KYS requested, do KYS
+    if use_kys and school_name_or_udise and school_name_or_udise.strip().isdigit() and 6 <= len(school_name_or_udise.strip()) <= 14:
+        kys_res = call_kys_by_udise(school_name_or_udise.strip())
+        out["kys"] = kys_res
+
+    return out
+
+
+with gr.Blocks() as demo:
+    gr.Markdown("# Tavily + KYS Search (Hugging Face Space)
+
+Enter a school name or a UDISE code and call KYS (UDISE) or your Tavily search endpoint.
+")
+
+    with gr.Row():
+        inp = gr.Textbox(label="School name or UDISE code", placeholder="e.g. 123456789012 or 'Govt High School...'", lines=1)
+        tavily_url = gr.Textbox(label="Tavily endpoint URL (POST/GET)", placeholder="https://your-tavily.example/api/search")
+        tavily_key = gr.Textbox(label="Tavily API Key / Authorization (optional)", placeholder="Bearer ... or APIKEY ...")
+
+    with gr.Row():
+        use_tavily = gr.Checkbox(value=True, label="Call Tavily")
+        use_kys = gr.Checkbox(value=True, label="Call KYS by UDISE")
+
+    run = gr.Button("Search Tavily")
+
+    output_json = gr.JSON(label="Raw Tavily Output (JSON)")
+    tavily_table = gr.DataFrame(headers=None, label="Tavily results (table)")
+
+    gr.Markdown("### UDISE candidates found in Tavily results
+The dropdown will list all numeric tokens resembling UDISE codes found in Tavily's response. Choose any candidate (or edit the UDISE field) and click 'Lookup UDISE' to call KYS.")
+    suggestions_dropdown = gr.Dropdown(choices=[], label="UDISE candidates (from Tavily)")
+    udise_input = gr.Textbox(label="UDISE to lookup (editable)", placeholder="Pick a candidate or type a UDISE code...", lines=1)
+    lookup_btn = gr.Button("Lookup UDISE (Call KYS)")
+
+    kys_output_json = gr.JSON(label="KYS Raw Output")
+    kys_table = gr.DataFrame(headers=None, label="KYS results (table)")
+
+    def on_run(school, turl, tkey, utav, ukys):
+        res = search_workflow(school, turl, tkey, utav, ukys)
+        # Prepare tavily table
+        tav_df = pd.DataFrame()
+        if res.get("tavily") and res["tavily"].get("ok"):
+            tav_df = json_to_table(res["tavily"]["data"])
+        # suggestions for dropdown
+        suggestions = res.get("suggestions", [])
+        return res.get("tavily"), tav_df, suggestions
+
+    run.click(on_run, inputs=[inp, tavily_url, tavily_key, use_tavily, use_kys], outputs=[output_json, tavily_table, suggestions_dropdown])
+
+    # When user selects a suggestion, populate the editable UDISE textbox
+    def on_select_suggestion(choice):
+        return choice or ""
+
+    suggestions_dropdown.change(on_select_suggestion, inputs=[suggestions_dropdown], outputs=[udise_input])
+
+    # Lookup button handler: call KYS for whatever is in udise_input
+    def on_lookup_udise(udise_code):
+        if not udise_code or not udise_code.strip().isdigit():
+            return {"ok": False, "error": "Provide a numeric UDISE code (6-14 digits)."}, pd.DataFrame()
+        kys_res = call_kys_by_udise(udise_code.strip())
+        df = pd.DataFrame()
+        if kys_res.get("ok"):
+            df = to_table_from_kys(kys_res["data"]) if kys_res.get("data") else pd.DataFrame()
+        return kys_res, df
+
+    lookup_btn.click(on_lookup_udise, inputs=[udise_input], outputs=[kys_output_json, kys_table])
+
+    gr.Markdown("---
+**Notes:**
+- Tavily results are attempted to be flattened into a table for easy scanning; complex nested structures will be shown as JSON above.
+- The UDISE candidates dropdown contains numeric tokens heuristically detected in the Tavily response; you can select one to fill the UDISE field, edit it, or type a different code.
+- The 'Search Tavily' button only queries Tavily and fills the table + suggestions; use 'Lookup UDISE' to call KYS for the chosen code.
+")
+
+if __name__ == "__main__":
+    demo.launch()