Update app.py

app.py

@@ -1,86 +1,132 @@
-from dotenv import load_dotenv
 import os
-import sys
+import json
 import time
 import requests
-import json
-
+import gradio as gr
+from dotenv import load_dotenv
 
-def main():
+CU_VERSION = "2025-05-01-preview"
 
-    # Clear the console
-    os.system('cls' if os.name=='nt' else 'clear')
 
+def safe_json(resp: requests.Response):
     try:
+        return resp.json()
+    except Exception:
+        return {"text": resp.text}
 
-        # Get the business card schema
-        with open("biz-card.json", "r") as file:
-            schema_json = json.load(file)
-        
-        card_schema = json.dumps(schema_json)
-
-        # Get config settings
-        load_dotenv()
-        ai_svc_endpoint = os.getenv('ENDPOINT')
-        ai_svc_key = os.getenv('KEY')
-        analyzer = os.getenv('ANALYZER_NAME')
-
-        # Create the analyzer
-        create_analyzer (card_schema, analyzer, ai_svc_endpoint, ai_svc_key)
 
-        print("\n")
+def load_schema(path="biz-card.json"):
+    with open(path, "r", encoding="utf-8") as f:
+        return json.dumps(json.load(f))
 
-    except Exception as ex:
-        print(ex)
 
+def load_config():
+    load_dotenv()
+    endpoint = os.getenv("ENDPOINT")
+    key = os.getenv("KEY")
+    analyzer = os.getenv("ANALYZER_NAME")
+    missing = [n for n, v in [("ENDPOINT", endpoint), ("KEY", key), ("ANALYZER_NAME", analyzer)] if not v]
+    return endpoint, key, analyzer, missing
 
 
-def create_analyzer (schema, analyzer, endpoint, key):
-    
-    # Create a Content Understanding analyzer
-    print (f"Creating {analyzer}")
-
-    # Set the API version
-    CU_VERSION = "2025-05-01-preview"
-
-    # initiate the analyzer creation operation
-    headers = { "Ocp-Apim-Subscription-Key": key, "Content-Type": "application/json"}
+def create_analyzer(schema: str, analyzer: str, endpoint: str, key: str):
+    headers = {"Ocp-Apim-Subscription-Key": key, "Content-Type": "application/json"}
     url = f"{endpoint}/contentunderstanding/analyzers/{analyzer}?api-version={CU_VERSION}"
 
-    # Delete the analyzer if it already exists
-    response = requests.delete(url, headers=headers)
-    print(response.status_code)
-    time.sleep(1)
+    # Delete if exists
+    del_resp = requests.delete(url, headers=headers, timeout=60)
 
-    # Now create it
-    response = requests.put(url, headers=headers, data=(schema))
-    print(response.status_code)
+    # Create
+    put_resp = requests.put(url, headers=headers, data=schema, timeout=60)
 
-    # Get the response and extract the callback URL
-    callback_url = response.headers["Operation-Location"]
+    op_loc = put_resp.headers.get("Operation-Location")
+    if not op_loc:
+        return (
+            False,
+            f"Missing Operation-Location header.\n"
+            f"delete status: {del_resp.status_code}\n"
+            f"create status: {put_resp.status_code}\n"
+            f"create body: {json.dumps(safe_json(put_resp), indent=2)}"
+        )
 
-    # Check the status of the operation
-    time.sleep(1)
-    result_response = requests.get(callback_url, headers=headers)
-
-    # Keep polling until the operation is no longer running
-    status = result_response.json().get("status")
-    while status == "Running":
+    # Poll
+    for _ in range(180):  # ~3 minutes max
         time.sleep(1)
-        result_response = requests.get(callback_url, headers=headers)
-        status = result_response.json().get("status")
-
-    result = result_response.json().get("status")
-    print(result)
-
-    if result == "Succeeded":
-        print(f"Analyzer '{analyzer}' created successfully.")
-    else:
-        print("Analyzer creation failed.")
-        print(result_response.json())
-
-
+        poll = requests.get(op_loc, headers=headers, timeout=60)
+        j = safe_json(poll)
+        status = (j or {}).get("status")
+        if status and status != "Running":
+            if status == "Succeeded":
+                return (
+                    True,
+                    f"Analyzer '{analyzer}' created successfully.\n"
+                    f"delete status: {del_resp.status_code}\n"
+                    f"create status: {put_resp.status_code}\n"
+                    f"final status: {status}"
+                )
+            return (
+                False,
+                f"Analyzer creation failed.\n"
+                f"delete status: {del_resp.status_code}\n"
+                f"create status: {put_resp.status_code}\n"
+                f"final status: {status}\n"
+                f"details:\n{json.dumps(j, indent=2)}"
+            )
+
+    return (
+        False,
+        f"Timed out waiting for analyzer creation.\n"
+        f"delete status: {del_resp.status_code}\n"
+        f"create status: {put_resp.status_code}"
+    )
+
+
+def handle_message(user_text, chat_history):
+    """
+    Gradio ChatInterface handler signature:
+      (message: str, history: list[tuple[str,str]]) -> str | tuple
+    We'll append to history outside via ChatInterface; just return assistant text.
+    """
+    text = (user_text or "").strip().lower()
+
+    if text in {"help", "/help", "commands"}:
+        return (
+            "Commands:\n"
+            "- **create analyzer** : delete (if exists) + create analyzer from `biz-card.json`\n"
+            "- **show config** : show whether ENDPOINT/KEY/ANALYZER_NAME are set\n"
+            "- **help** : show this message"
+        )
+
+    if text in {"show config", "config"}:
+        endpoint, key, analyzer, missing = load_config()
+        if missing:
+            return f"Missing env vars: {', '.join(missing)}"
+        return f"Config loaded ✅\n- ENDPOINT: {endpoint}\n- ANALYZER_NAME: {analyzer}\n- KEY: (set)"
+
+    if text in {"create analyzer", "create", "make analyzer", "build analyzer"}:
+        endpoint, key, analyzer, missing = load_config()
+        if missing:
+            return f"Cannot create analyzer. Missing env vars: {', '.join(missing)}"
+
+        try:
+            schema = load_schema("biz-card.json")
+        except Exception as ex:
+            return f"Could not load biz-card.json: {ex}"
+
+        ok, msg = create_analyzer(schema, analyzer, endpoint, key)
+        return msg
+
+    return "Type **help** to see commands. Try **create analyzer**."
+
+
+demo = gr.ChatInterface(
+    fn=handle_message,
+    title="Content Understanding Chat App",
+    description="Type **help** or **create analyzer** to create your Content Understanding analyzer from biz-card.json.",
+    examples=["help", "show config", "create analyzer"],
+    theme="soft",
+)
 
 
 if __name__ == "__main__":
-    main()
+    demo.launch()