Update app.py

app.py

@@ -1,132 +1,85 @@
-import os
-import json
-import time
-import requests
 import gradio as gr
-from dotenv import load_dotenv
+import requests
+import json
 
-CU_VERSION = "2025-05-01-preview"
 
+def _normalize_endpoint(endpoint: str) -> str:
+    endpoint = (endpoint or "").strip()
+    return endpoint[:-1] if endpoint.endswith("/") else endpoint
 
-def safe_json(resp: requests.Response):
-    try:
-        return resp.json()
-    except Exception:
-        return {"text": resp.text}
 
+def _azure_chat_completions(endpoint, api_key, model, messages, temperature=0.7, max_tokens=600, timeout=60):
+    endpoint = _normalize_endpoint(endpoint)
+    url = f"{endpoint}/openai/v1/chat/completions"
 
-def load_schema(path="biz-card.json"):
-    with open(path, "r", encoding="utf-8") as f:
-        return json.dumps(json.load(f))
+    headers = {
+        "Content-Type": "application/json",
+        "api-key": api_key.strip(),
+    }
 
+    payload = {
+        "model": model.strip(),
+        "messages": messages,
+        "temperature": float(temperature),
+        "max_tokens": int(max_tokens),
+    }
 
-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
+    r = requests.post(url, headers=headers, json=payload, timeout=timeout)
+    r.raise_for_status()
+    return r.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}"
+def handle_message(message, history, endpoint, api_key, model, system_prompt, temperature, max_tokens):
+    # history is list of [user, assistant] pairs
+    messages = []
+    if system_prompt and system_prompt.strip():
+        messages.append({"role": "system", "content": system_prompt.strip()})
 
-    # Delete if exists
-    del_resp = requests.delete(url, headers=headers, timeout=60)
+    for u, a in history:
+        if u:
+            messages.append({"role": "user", "content": u})
+        if a:
+            messages.append({"role": "assistant", "content": a})
 
-    # Create
-    put_resp = requests.put(url, headers=headers, data=schema, timeout=60)
+    messages.append({"role": "user", "content": message})
 
-    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)}"
-        )
+    if not endpoint or not api_key or not model:
+        return "Please provide Endpoint, API Key, and Model."
 
-    # Poll
-    for _ in range(180):  # ~3 minutes max
-        time.sleep(1)
-        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"
+    try:
+        data = _azure_chat_completions(
+            endpoint=endpoint,
+            api_key=api_key,
+            model=model,
+            messages=messages,
+            temperature=temperature,
+            max_tokens=max_tokens,
         )
+        return data["choices"][0]["message"]["content"]
 
-    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)}"
-
+    except requests.HTTPError as e:
         try:
-            schema = load_schema("biz-card.json")
-        except Exception as ex:
-            return f"Could not load biz-card.json: {ex}"
+            err_json = e.response.json()
+            return f"HTTP {e.response.status_code}: {json.dumps(err_json, indent=2)}"
+        except Exception:
+            return f"HTTP error: {str(e)}"
 
-        ok, msg = create_analyzer(schema, analyzer, endpoint, key)
-        return msg
-
-    return "Type **help** to see commands. Try **create analyzer**."
+    except Exception as e:
+        return f"Error: {str(e)}"
 
 
 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",
+    additional_inputs=[
+        gr.Textbox(label="Azure OpenAI Endpoint", placeholder="https://ai-hubXXXX.openai.azure.com"),
+        gr.Textbox(label="API Key", placeholder="paste your key here", type="password"),
+        gr.Textbox(label="Model (or deployment name)", placeholder="e.g., gpt-4o-mini"),
+        gr.Textbox(label="System prompt (optional)", value="You are a helpful assistant."),
+        gr.Slider(0.0, 1.5, value=0.7, step=0.1, label="Temperature"),
+        gr.Slider(50, 2000, value=600, step=50, label="Max tokens"),
+    ],
+    title="Azure OpenAI Chat Completion",
+    description="Enter your Azure OpenAI endpoint + key, then chat.",
 )
 
-
-if __name__ == "__main__":
-    demo.launch()
+demo.launch()