Update app.py

app.py

@@ -2,90 +2,61 @@ import gradio as gr
 from huggingface_hub import InferenceClient
 
 import nltk
-import json
-import io
-import base64
-from fpdf import FPDF
-from textblob import TextBlob
 import PyPDF2
-import tempfile
 
-# Download the NLTK punkt tokenizer if not already present
 nltk.download("punkt", quiet=True)
 
 ###############################################################################
 #                           Hugging Face Chat Code                            #
 ###############################################################################
-"""
-For more information on Hugging Face Inference API support, please check:
-https://huggingface.co/docs/huggingface_hub/v0.22.2/en/guides/inference
-"""
 
-# Initialize your Hugging Face model client
+# Initialize the Hugging Face model client
 client = InferenceClient("HuggingFaceH4/zephyr-7b-beta")
 
-def respond(
-    message,
-    history: list[tuple[str, str]],
-    system_message,
-    max_tokens,
-    temperature,
-    top_p,
-    file_content
-):
+def respond(message, history, system_message, max_tokens, temperature, top_p, file_content):
     """
-    Streams the chat response from the Hugging Face model.
-    The uploaded file's content is appended to the system message for context.
-    Yields tokens as they arrive.
+    Calls the Hugging Face model for a response.
+    Includes file content in the system message for context.
     """
-    # Append file content to the system prompt if available.
+    # Append file content to system message if available
     if file_content and file_content.strip():
-        system_message = system_message + "\n\nFile content:\n" + file_content
-
-    # Build the messages list to send
+        system_message += f"\n\nFile content:\n{file_content}"
+    
+    # Prepare the message payload
     messages = [{"role": "system", "content": system_message}]
-    for user_msg, assistant_msg in history:
-        if user_msg:
-            messages.append({"role": "user", "content": user_msg})
-        if assistant_msg:
-            messages.append({"role": "assistant", "content": assistant_msg})
+    for user, assistant in history:
+        if user:
+            messages.append({"role": "user", "content": user})
+        if assistant:
+            messages.append({"role": "assistant", "content": assistant})
     messages.append({"role": "user", "content": message})
-
-    response = ""
+    
+    # Get the model response
     try:
-        for partial in client.chat_completion(
+        completion = client.chat_completion(
             messages,
             max_tokens=max_tokens,
-            stream=True,
             temperature=temperature,
             top_p=top_p,
-        ):
-            token = partial.choices[0].delta.get("content", "")
-            response += token
-            yield response
+        )
+        return completion.choices[0].message["content"]
     except Exception as e:
-        yield f"Error during model response: {e}"
+        return f"Error: {e}"
 
 ###############################################################################
-#                    File Upload & Parsing Functionality                      #
+#                        File Upload & Parsing Functions                      #
 ###############################################################################
 
 def parse_file(file_obj):
     """
-    Parses the provided file object.
-    For PDFs, it extracts text using PyPDF2.
-    For other file types, it attempts to decode as UTF-8 text.
+    Parses uploaded files and extracts content.
+    Supports PDFs and plain text.
     """
-    # Expect file_obj to be a file-like object with a 'name' attribute.
     file_extension = file_obj.name.split('.')[-1].lower()
     if file_extension == "pdf":
         try:
             reader = PyPDF2.PdfReader(file_obj)
-            text = ""
-            for page in reader.pages:
-                extracted = page.extract_text() or ""
-                text += extracted + "\n"
-            return text
+            return "\n".join(page.extract_text() or "" for page in reader.pages)
         except Exception as e:
             return f"Error reading PDF: {e}"
     else:
@@ -96,83 +67,66 @@ def parse_file(file_obj):
 
 def load_files(files):
     """
-    Processes a list of file paths (uploaded with type="filepath").
-    Opens each file, extracts its text, and concatenates the results.
+    Loads multiple files, parses their content, and concatenates the text.
     """
-    all_text = ""
-    for file_path in files:
+    combined_text = ""
+    for file in files:
         try:
-            with open(file_path, "rb") as f:
+            with open(file, "rb") as f:
                 content = parse_file(f)
-            all_text += content + "\n"
+            combined_text += content + "\n"
         except Exception as e:
-            all_text += f"Error processing file {file_path}: {e}\n"
-    return all_text
+            combined_text += f"Error processing file {file}: {e}\n"
+    return combined_text
 
 ###############################################################################
-#                              Gradio UI Layout                               #
+#                             Gradio UI Layout                                #
 ###############################################################################
 
 with gr.Blocks() as demo:
-    gr.Markdown("# **Combined Chat & File Upload App**")
+    gr.Markdown("# **Chat with File Context**")
     gr.Markdown(
         """
-This app allows you to upload file(s) and chat with an AI assistant that uses 
-the uploaded file(s) as context throughout the conversation.
-
-- **Upload File(s):** (PDF or TXT files) The content is automatically parsed.
-- **Chat:** Your messages are sent to the AI along with the uploaded file's context.
-"""
+This app lets you upload file(s) and chat with an AI assistant.
+Uploaded file content will provide context for the conversation.
+        """
     )
     
-    # State to hold the concatenated file content and conversation history.
+    # States to store file content and chat history
     file_content_state = gr.State("")
-    chat_history_state = gr.State([])  # List of tuples: (user_message, assistant_response)
-    
-    # File uploader (using type="filepath" so we get the file paths)
+    chat_history_state = gr.State([])
+
+    # File Upload Section
     file_input = gr.File(label="Upload File(s)", file_count="multiple", type="filepath")
-    # When the file(s) are uploaded, automatically load them and store the combined text.
     file_input.change(fn=load_files, inputs=file_input, outputs=file_content_state)
-    
-    gr.Markdown("## Chat with AI (File context is automatically used)")
-    chatbot = gr.Chatbot(label="Chat History")
-    user_input = gr.Textbox(label="Your Message", placeholder="Type your message here...", lines=2)
-    
-    def handle_user_message(user_message, chat_history, file_content):
+
+    # Chat Section
+    gr.Markdown("## Chat")
+    chatbot = gr.Chatbot(label="Conversation")
+    user_input = gr.Textbox(label="Your Message", placeholder="Ask something...", lines=2)
+
+    # Model Configuration Sliders
+    system_prompt = gr.Textbox(label="System Prompt", value="You are a helpful AI assistant.", interactive=True)
+    max_tokens = gr.Slider(minimum=1, maximum=2048, value=512, step=1, label="Max Tokens")
+    temperature = gr.Slider(minimum=0.1, maximum=4.0, value=0.7, step=0.1, label="Temperature")
+    top_p = gr.Slider(minimum=0.1, maximum=1.0, value=0.95, step=0.05, label="Top-p")
+
+    # Chat Function
+    def chat_function(user_message, history, file_content, system_prompt, max_tokens, temperature, top_p):
         if not user_message.strip():
-            return "", chat_history
-        # Append the user's message to chat history.
-        chat_history.append((user_message, None))
-        # Generate the AI response using the uploaded file content as context.
-        response_gen = respond(
-            message=user_message,
-            history=chat_history,
-            system_message="You are a helpful AI assistant.",
-            max_tokens=512,
-            temperature=0.7,
-            top_p=0.95,
-            file_content=file_content
-        )
-        response = ""
-        try:
-            for partial in response_gen:
-                response = partial
-                # Update the last chat history entry with the current response.
-                chat_history[-1] = (user_message, response)
-                yield "", chat_history
-        except Exception as e:
-            chat_history[-1] = (user_message, f"Error: {e}")
-            yield "", chat_history
+            return "", history
+        # Append user's message to the chat history
+        history.append((user_message, ""))
+        # Get response from the model
+        assistant_response = respond(user_message, history, system_prompt, max_tokens, temperature, top_p, file_content)
+        history[-1] = (user_message, assistant_response)
+        return "", history
 
-    # When a message is submitted (by pressing Enter), handle the message.
+    # Submit Chat Input
     user_input.submit(
-        handle_user_message,
-        inputs=[user_input, chat_history_state, file_content_state],
-        outputs=[user_input, chatbot],
-        queue=True
+        fn=chat_function,
+        inputs=[user_input, chat_history_state, file_content_state, system_prompt, max_tokens, temperature, top_p],
+        outputs=[user_input, chatbot]
     )
-    
+
     demo.launch(server_name="0.0.0.0", server_port=7860)
-    
-if __name__ == "__main__":
-    demo.launch()