Update app.py

app.py

@@ -1,33 +1,44 @@
-# At top of your file:
-import tiktoken
-import openai
-from openai.error import InvalidRequestError
+"""
+app.py – Advanced OpenAI Chatbot with Automatic Long‐Input Handling
+"""
+
+import os
 import openai
+import asyncio
+import gradio as gr
+import tiktoken
 
-# some versions expose exceptions under openai.error, others at the root
+# Handle exception import across SDK versions
 try:
     from openai.error import InvalidRequestError
 except ImportError:
     InvalidRequestError = openai.InvalidRequestError
 
-# Choose your model and its max context size
-MODEL_NAME    = "gpt-4-32k"
-MAX_CONTEXT   = 32768  # GPT-4-32k model limit
-SUMMARY_MAX_TOKENS = 1024  # how long each summary can be
+# Configuration
+MODEL_NAME           = "gpt-4-32k"    # high‐capacity model
+MAX_CONTEXT_TOKENS   = 32768          # model’s max context
+SUMMARY_MAX_TOKENS   = 1024           # summary length per chunk
+REPLY_MAX_TOKENS     = 2048           # max tokens for reply
+TEMPERATURE          = 0.3
+
+# Load API key
+openai.api_key = os.getenv("OPENAI_API_KEY", "").strip()
 
-# Helper to count tokens
-def count_tokens(text: str, model: str=MODEL_NAME) -> int:
+def count_tokens(text: str, model: str = MODEL_NAME) -> int:
+    """Return token count for given text and model."""
     enc = tiktoken.encoding_for_model(model)
     return len(enc.encode(text))
 
-# Simple chunker by word so each chunk’s token count ≤ limit
-def chunk_text(text: str, max_tokens: int, model: str=MODEL_NAME):
+def chunk_text(text: str, max_tokens: int, model: str = MODEL_NAME) -> list[str]:
+    """
+    Split text into chunks so each chunk’s token count ≤ max_tokens.
+    Splits on word boundaries.
+    """
     words = text.split()
     chunks, current = [], []
     for w in words:
         current.append(w)
         if count_tokens(" ".join(current), model) >= max_tokens:
-            # pop last word into next chunk
             last = current.pop()
             chunks.append(" ".join(current))
             current = [last]
@@ -35,77 +46,81 @@ def chunk_text(text: str, max_tokens: int, model: str=MODEL_NAME):
         chunks.append(" ".join(current))
     return chunks
 
-# Summarize a single chunk
 async def summarize_chunk(chunk: str) -> str:
+    """Async call to summarize one text chunk."""
     resp = await openai.ChatCompletion.acreate(
         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,
-        temperature=0.0,
+        temperature=0.0
     )
     return resp.choices[0].message.content.strip()
 
-# Entry-point wrapper that transparently handles over-limit inputs
-def safe_chat_completion(convo: list, max_tokens: int):
+def safe_chat_completion(convo: list[dict], max_tokens: int) -> openai.openai_object.OpenAIObject:
     """
-    convo: full messages list (system, history, user)
+    Perform ChatCompletion.create, catch context‐length errors,
+    summarize the last user message, and retry once.
     """
     try:
         return openai.ChatCompletion.create(
             model=MODEL_NAME,
             messages=convo,
             max_tokens=max_tokens,
-            temperature=0.3,
+            temperature=TEMPERATURE
         )
     except InvalidRequestError as e:
         err = str(e)
         if "maximum context length" not in err:
-            raise  # re-raise any other error
-        # Token limit hit → shrink only the last user message
-        last_msg = convo[-1]["content"]
-        # leave 500 tokens buffer for reply
-        allowed = MAX_CONTEXT - count_tokens("".join(m["content"] for m in convo[:-1]), MODEL_NAME) - 500
-        # chunk & summarize
-        raw_chunks = chunk_text(last_msg, allowed // 2, MODEL_NAME)
-        # run summarizations
-        import asyncio
+            raise
+
+        # Determine how many tokens remain for the latest user message
+        used = count_tokens("".join(m["content"] for m in convo[:-1]), MODEL_NAME)
+        buffer = 500  # reserve tokens for the reply
+        allowed_for_user = MAX_CONTEXT_TOKENS - used - buffer
+        if allowed_for_user < 100:
+            raise RuntimeError("Context too large even after trimming.")
+
+        # Chunk & summarize the last user message
+        last = convo[-1]["content"]
+        raw_chunks = chunk_text(last, allowed_for_user // 2, MODEL_NAME)
         summaries = asyncio.get_event_loop().run_until_complete(
             asyncio.gather(*(summarize_chunk(c) for c in raw_chunks))
         )
-        new_msg = " ".join(summaries)
-        convo[-1]["content"] = new_msg
-        # retry once
+        convo[-1]["content"] = " ".join(summaries)
+
+        # Retry once
         return openai.ChatCompletion.create(
             model=MODEL_NAME,
             messages=convo,
             max_tokens=max_tokens,
-            temperature=0.3,
+            temperature=TEMPERATURE
         )
 
-# Then in your chat handler:
 def chat_handler(
     user_message: str,
-    history: list,
-    system_prompt: str,
-):
+    history: list[tuple[str, str]],
+    system_prompt: str
+) -> tuple[list[tuple[str, str]], str]:
+    """Gradio handler: builds convo, calls safe_chat_completion, updates history."""
     if not user_message.strip():
         return history, ""
 
-    # build messages list
-    convo = [{"role":"system","content":system_prompt}]
-    for u, b in history:
-        convo += [
-            {"role":"user","content":u},
-            {"role":"assistant","content":b},
-        ]
-    convo.append({"role":"user","content":user_message})
+    if not openai.api_key:
+        return history, "❌ OPENAI_API_KEY not set."
 
-    # call via safe wrapper
+    # Build conversation
+    convo = [{"role": "system", "content": system_prompt}]
+    for user, bot in history:
+        convo.append({"role": "user",      "content": user})
+        convo.append({"role": "assistant", "content": bot})
+    convo.append({"role": "user", "content": user_message})
+
+    # Call OpenAI safely
     try:
-        resp = safe_chat_completion(convo, max_tokens=2048)
+        resp = safe_chat_completion(convo, max_tokens=REPLY_MAX_TOKENS)
         reply = resp.choices[0].message.content
     except Exception as e:
         reply = f"❌ OpenAI error: {e}"
@@ -113,3 +128,35 @@ def chat_handler(
     history = history or []
     history.append((user_message, reply))
     return history, ""
+
+# Gradio UI
+with gr.Blocks(title="🤖 Advanced Chatbot (Long‐Input Safe)") as demo:
+    gr.Markdown(
+        """
+        # Advanced Chatbot  
+        Paste arbitrarily long code or text; the bot will auto‐summarize overflow.  
+        Expert in Python & C# with production‐grade answers.
+        """
+    )
+
+    system_txt = gr.Textbox(
+        lines=3,
+        value=(
+            "You are an expert software engineer specializing in Python and C#. "
+            "Provide detailed, production‐grade answers and include code snippets when appropriate."
+        ),
+        label="System Prompt"
+    )
+
+    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,
+        inputs=[user_input, chatbot, system_txt],
+        outputs=[chatbot, user_input]
+    )
+
+if __name__ == "__main__":
+    demo.launch()