Update app.py

app.py

@@ -1,116 +1,114 @@
 """
 app.py – Advanced Chatbot with Automatic Long-Input Handling
+(OpenAI Python SDK ≥1.0.0)
 """
 
 import os
 import asyncio
 import gradio as gr
-
-import openai
 import tiktoken
+from openai import OpenAI
 
-# Alias the right exception class (your SDK uses BadRequestError for invalid‐request)
-try:
-    # if your install still has openai.error, this will work
-    from openai.error import InvalidRequestError
-except ImportError:
-    # otherwise, BadRequestError covers context-length errors
-    from openai import BadRequestError as InvalidRequestError
+# Instantiate the new client
+client = OpenAI(api_key=os.getenv("OPENAI_API_KEY", "").strip())
 
 # Configuration
-MODEL_NAME           = "gpt-4-32k"
-MAX_CONTEXT_TOKENS   = 32768
-SUMMARY_MAX_TOKENS   = 1024
-REPLY_MAX_TOKENS     = 2048
-TEMPERATURE          = 0.3
-BUFFER_TOKENS        = 500   # reserved for the model’s reply
-
-# Load your key
-openai.api_key = os.getenv("OPENAI_API_KEY", "").strip()
+MODEL_NAME         = "gpt-4-32k"
+MAX_CONTEXT        = 32768
+SUMMARY_MAX        = 1024
+REPLY_MAX          = 2048
+TEMPERATURE        = 0.3
+BUFFER_TOKENS      = 500  # leave room for the model's answer
 
 def count_tokens(text: str, model: str = MODEL_NAME) -> int:
     enc = tiktoken.encoding_for_model(model)
     return len(enc.encode(text))
 
-def chunk_text(text: str, max_tokens: int, model: str = MODEL_NAME) -> list[str]:
-    words, chunks, current = text.split(), [], []
+def chunk_text(text: str, max_toks: int, model: str = MODEL_NAME) -> list[str]:
+    words, chunks, cur = text.split(), [], []
     for w in words:
-        current.append(w)
-        if count_tokens(" ".join(current), model) >= max_tokens:
-            last = current.pop()
-            chunks.append(" ".join(current))
-            current = [last]
-    if current:
-        chunks.append(" ".join(current))
+        cur.append(w)
+        if count_tokens(" ".join(cur), model) >= max_toks:
+            last = cur.pop()
+            chunks.append(" ".join(cur))
+            cur = [last]
+    if cur:
+        chunks.append(" ".join(cur))
     return chunks
 
 async def summarize_chunk(chunk: str) -> str:
-    resp = await openai.ChatCompletion.acreate(
+    resp = await client.chat.completions.create(
         model=MODEL_NAME,
         messages=[
-            {"role":"system","content":"You are a concise summarizer."},
-            {"role":"user","content":f"Summarize this text briefly, preserving key details:\n\n{chunk}"}
+            {"role":"system", "content":"You are a concise summarizer."},
+            {"role":"user",   "content":f"Summarize this text briefly, preserving key details:\n\n{chunk}"}
         ],
-        max_tokens=SUMMARY_MAX_TOKENS,
+        max_tokens=SUMMARY_MAX,
         temperature=0.0,
     )
     return resp.choices[0].message.content.strip()
 
-def safe_chat_completion(convo: list[dict], max_tokens: int):
-    """Try once, catch context-length, summarize last user message, retry."""
+def safe_chat(convo: list[dict], max_reply: int):
+    """
+    1) Try a normal chat
+    2) On context-length error, summarize only the last user message
+    3) Retry once with the summaries in place
+    """
     try:
-        return openai.ChatCompletion.create(
+        return client.chat.completions.create(
             model=MODEL_NAME,
             messages=convo,
-            max_tokens=max_tokens,
+            max_tokens=max_reply,
             temperature=TEMPERATURE
         )
-    except InvalidRequestError as e:
-        err = str(e)
-        if "maximum context length" not in err:
-            raise  # some other bad request error
+    except Exception as e:
+        text = str(e).lower()
+        if "context length" not in text and "maximum context length" not in text:
+            # Not a token-limit issue
+            raise
 
-        # calculate tokens used by everything except the last user message
+        # How many tokens have we used so far?
         used = count_tokens("".join(m["content"] for m in convo[:-1]), MODEL_NAME)
-        allowed_for_user = MAX_CONTEXT_TOKENS - used - BUFFER_TOKENS
-        if allowed_for_user < 100:
-            raise RuntimeError("Input too large, even after trimming.")
+        allowed = MAX_CONTEXT - used - BUFFER_TOKENS
+        if allowed < 100:
+            raise RuntimeError("Even after trimming, input is too large.")
 
-        # chunk & summarize
-        last = convo[-1]["content"]
-        chunks = chunk_text(last, allowed_for_user // 2, MODEL_NAME)
+        # Chunk & summarize the last message
+        last_msg = convo[-1]["content"]
+        bits = chunk_text(last_msg, max_toks=allowed // 2, model=MODEL_NAME)
         summaries = asyncio.get_event_loop().run_until_complete(
-            asyncio.gather(*(summarize_chunk(c) for c in chunks))
+            asyncio.gather(*(summarize_chunk(b) for b in bits))
         )
+
         convo[-1]["content"] = " ".join(summaries)
 
-        # retry once
-        return openai.ChatCompletion.create(
+        # Retry once
+        return client.chat.completions.create(
             model=MODEL_NAME,
             messages=convo,
-            max_tokens=max_tokens,
+            max_tokens=max_reply,
             temperature=TEMPERATURE
         )
 
 def chat_handler(
     user_message: str,
-    history: list[tuple[str, str]],
+    history: list[tuple[str,str]],
     system_prompt: str
-) -> tuple[list[tuple[str, str]], str]:
+) -> tuple[list[tuple[str,str]], str]:
     if not user_message.strip():
         return history, ""
-    if not openai.api_key:
+    if not client.api_key:
         return history, "❌ OPENAI_API_KEY not set."
 
-    # build convo
+    # Build the full conversation
     convo = [{"role":"system","content":system_prompt}]
     for u, b in history or []:
         convo.append({"role":"user",      "content":u})
         convo.append({"role":"assistant", "content":b})
-    convo.append({"role":"user","content":user_message})
+    convo.append({"role":"user", "content":user_message})
 
     try:
-        resp = safe_chat_completion(convo, max_tokens=REPLY_MAX_TOKENS)
+        resp = safe_chat(convo, max_reply=REPLY_MAX)
         reply = resp.choices[0].message.content
     except Exception as e:
         reply = f"❌ OpenAI error: {e}"
@@ -119,7 +117,7 @@ def chat_handler(
     history.append((user_message, reply))
     return history, ""
 
-# --- Gradio UI ---
+# ——— Gradio UI ———
 with gr.Blocks(title="🤖 Advanced Chatbot (Long-Input Safe)") as demo:
     gr.Markdown(
         """
@@ -138,9 +136,9 @@ with gr.Blocks(title="🤖 Advanced Chatbot (Long-Input Safe)") as demo:
         label="System Prompt"
     )
 
-    chatbot   = gr.Chatbot(label="Conversation")
-    user_input = gr.Textbox(placeholder="Type your message here...", label="You")
-    send_btn  = gr.Button("Send")
+    chatbot    = gr.Chatbot(label="Conversation")
+    user_input = gr.Textbox(placeholder="Type your message here…", label="You")
+    send_btn   = gr.Button("Send")
 
     send_btn.click(
         fn=chat_handler,