updatation

app.py

@@ -1,23 +1,19 @@
-# app.py — Project 2 updated
+# app.py — from local backup
 
 import gradio as gr
 import os
 import tempfile
 import textwrap
 from datetime import datetime
+from pathlib import Path
 from typing import List, Dict, Any, Optional
-from reportlab.lib.pagesizes import A4
-from reportlab.pdfgen import canvas
-from reportlab.pdfbase import pdfmetrics
-from reportlab.pdfbase.ttfonts import TTFont
 
 from src.model_loader import load_local_model
 from src.conversation import ConversationMemory
 from src.chatbot import LocalChatbot
 
-# -------------------------------
-# Load LLM and memory
-# -------------------------------
+
+
 llm = load_local_model()
 memory = ConversationMemory()
 bot = LocalChatbot(llm, memory)
@@ -32,75 +28,105 @@ INTENT_TEMPLATES = {
 def now_ts():
     return datetime.now().strftime("%Y-%m-%d %H:%M:%S")
 
-# -------------------------------
-# PDF / TXT Export Function
-# -------------------------------
+
+# ----------------------
+# EXPORT TXT/PDF
+# ----------------------
+import os
+import tempfile
+import textwrap
+from datetime import datetime
+from typing import List, Dict, Optional
+from reportlab.lib.pagesizes import A4
+from reportlab.pdfgen import canvas
+
 def export_chat_files(history: List[Dict[str, any]]) -> Dict[str, Optional[str]]:
     tmpdir = tempfile.gettempdir()
     timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
     txt_path = os.path.join(tmpdir, f"chat_history_{timestamp}.txt")
     pdf_path = os.path.join(tmpdir, f"chat_history_{timestamp}.pdf")
 
-    # ---------------- TXT ----------------
+
+    def remove_last_closing_line(lines):
+        closing_keywords = [
+            "let me know", "is there anything else",
+            "anything else i can help", "feel free to ask",
+            "hope this helps", "need further assistance",
+            "feel free", "happy to help",
+            "hello! how can i assist you today?",
+            "are there any specific industries or areas you'd like to explore in more detail?",
+            "how can i help you better?", "what did you like about our interaction?",
+            "do you have any feedback on your experience?", "would you like to explore",
+            "need clarification"
+        ]
+        if not lines:
+            return lines
+        last = lines[-1].lower().strip()
+        if any(k in last for k in closing_keywords):
+            return lines[:-1]
+        return lines
+
+    # ---------------- TXT FILE ----------------
     with open(txt_path, "w", encoding="utf-8") as f:
         for msg in history:
-            content = str(msg.get("content", ""))
+            content_data = msg.get("content", "")
+            if isinstance(content_data, dict):
+                content = content_data.get("text", "")
+            else:
+                content = str(content_data)
+
             lines = content.splitlines()
-            lines = [l.strip() for l in lines if l.strip() and not l.strip().startswith("🕒")]
-            for line in lines:
-                f.write(line + "\n")
+            clean = [l.strip() for l in lines if l.strip() and not l.strip().startswith("🕒")]
+            clean = remove_last_closing_line(clean)
+            f.write("\n".join(clean) + "\n\n")
             f.write("-" * 60 + "\n\n")
 
-    # ---------------- PDF ----------------
+    # ---------------- PDF FILE ----------------
     try:
-        # Register bold font for role labels
-        pdfmetrics.registerFont(TTFont("Helvetica-Bold", "Helvetica-Bold.ttf"))
-
         c = canvas.Canvas(pdf_path, pagesize=A4)
         page_width, page_height = A4
         margin = 40
+        y = page_height - margin
         line_height = 14
         font_size = 10
 
-        textobject = c.beginText(margin, page_height - margin)
-        textobject.setFont("Helvetica", font_size)
+        c.setFont("Helvetica", font_size)
 
         for msg in history:
             role = msg.get("role", "user").capitalize()
-            content = str(msg.get("content", ""))
+            content_data = msg.get("content", "")
+            if isinstance(content_data, dict):
+                content = content_data.get("text", "")
+            else:
+                content = str(content_data) 
+
             lines = content.splitlines()
             clean_lines = [l.strip() for l in lines if l.strip()]
+            clean_lines = remove_last_closing_line(clean_lines)
 
             for line in clean_lines:
-                wrapped = textwrap.wrap(line, width=100)
+                wrapped = textwrap.wrap(line, width=95)
                 for wline in wrapped:
-                    if textobject.getY() < margin:
-                        c.drawText(textobject)
+                    if y < margin + line_height:
                         c.showPage()
-                        textobject = c.beginText(margin, page_height - margin)
-                        textobject.setFont("Helvetica", font_size)
+                        c.setFont("Helvetica", font_size)
+                        y = page_height - margin
+                    c.drawString(margin, y, f"{role}: {wline}" if role=="User" else wline)
+                    y -= line_height
 
-                    if role == "User":
-                        textobject.setFont("Helvetica-Bold", font_size)
-                        textobject.textLine(f"{role}: {wline}")
-                        textobject.setFont("Helvetica", font_size)
-                    else:
-                        textobject.textLine(wline)
+            y -= line_height  # spacing between messages
 
-            textobject.textLine("")  # spacing between messages
-
-        c.drawText(textobject)
         c.showPage()
         c.save()
     except Exception as e:
         print("PDF export failed:", e)
         pdf_path = None
-
+    
     return {"txt": txt_path, "pdf": pdf_path}
 
-# -------------------------------
-# Chat reply function
-# -------------------------------
+# ----------------------
+# Core chat function
+# ----------------------
 def generate_reply(user_msg: str, history: Optional[List[Dict[str, Any]]]):
     if history is None:
         history = []
@@ -108,7 +134,6 @@ def generate_reply(user_msg: str, history: Optional[List[Dict[str, Any]]]):
     if not user_msg.strip():
         return history
 
-    # Detect intent from message start
     intent = None
     low = user_msg.lower()
     for key in INTENT_TEMPLATES:
@@ -117,19 +142,19 @@ def generate_reply(user_msg: str, history: Optional[List[Dict[str, Any]]]):
             user_msg = user_msg[len(key):].strip()
             break
 
+
     system_prefix = INTENT_TEMPLATES.get(intent, None)
     if system_prefix:
         prompt = f"{system_prefix}\nUser: {user_msg}"
     else:
         prompt = f"User: {user_msg}"
 
-    bot_reply = bot.ask(user_msg)  # intent auto-detected
-
+    bot_reply = bot.ask(prompt)
     ts = now_ts()
     bot_reply_ts = f"{bot_reply}\n\n🕒 {ts}"
 
-    history.append({"role": "user", "content": str(user_msg)})
-    history.append({"role": "assistant", "content": str(bot_reply_ts)})
+    history.append({"role": "user", "content": user_msg})
+    history.append({"role": "assistant", "content": bot_reply_ts})
 
     try:
         memory.add(user_msg, bot_reply)
@@ -138,9 +163,10 @@ def generate_reply(user_msg: str, history: Optional[List[Dict[str, Any]]]):
 
     return history
 
-# -------------------------------
-# Custom CSS
-# -------------------------------
+
+# ----------------------
+# CUSTOM CSS
+# ----------------------
 CUSTOM_CSS = """
 /* GLOBAL */
 .gradio-container { 
@@ -179,6 +205,7 @@ CUSTOM_CSS = """
     padding: 12px;
 }
 
+
 /* Input box */
 #message-box textarea {
     background: #e0e7ff !important;
@@ -192,8 +219,9 @@ CUSTOM_CSS = """
     color: white !important;
     transition: background 0.2s ease, transform 0.2s ease;
 }
+
 .send-btn:hover {
-    background: #4338ca !important;
+    background: #4338ca !important; /* darker indigo */
     transform: scale(1.05);
 }
 
@@ -202,15 +230,18 @@ CUSTOM_CSS = """
     background: #f1f5f9 !important;
     transition: background 0.2s ease, transform 0.2s ease;
 }
+
 .icon-btn:hover {
-    background: #e2e8f0 !important;
+    background: #e2e8f0 !important; /* slightly darker */
     transform: scale(1.05);
 }
+
 """
 
-# -------------------------------
-# JS (Voice)
-# -------------------------------
+#----------------------
+#JS (Voice only)
+#----------------------
+
 PAGE_JS = """
 <script>
 (function(){
@@ -229,6 +260,8 @@ PAGE_JS = """
 
     recog.onresult = function(e){
       textarea.value = e.results[0][0].transcript;
+
+      // Visual flash to confirm input
       textarea.style.background = "#e7f5ff";
       setTimeout(() => { textarea.style.background = ""; }, 400);
     };
@@ -239,15 +272,19 @@ PAGE_JS = """
 </script>
 """
 
-# -------------------------------
-# Gradio UI
-# -------------------------------
+# ----------------------
+# UI
+# ----------------------
 with gr.Blocks(title="Tayyab — Chatbot") as demo:
-    gr.HTML(f"<style>{CUSTOM_CSS}</style><script>{PAGE_JS}</script>")
+    gr.HTML(f"""
+    <style>{CUSTOM_CSS}</style>
+    <script>{PAGE_JS}</script>
+    """)
 
     with gr.Row():
         with gr.Column(scale=1, min_width=220):
             gr.Markdown("### ⚡ Tools & Export")
+
             new_chat_btn = gr.Button("➕ New Chat")
             export_btn = gr.Button("📥 Export TXT/PDF")
 
@@ -278,14 +315,19 @@ with gr.Blocks(title="Tayyab — Chatbot") as demo:
 
     new_chat_btn.click(new_chat, outputs=[chatbot])
 
+
     def export_handler(history):
+        # history is already list of dicts: [{"role": "...", "content": "..."}]
         files = export_chat_files(history or [])
+
         return (
             gr.update(value=files.get("txt"), visible=True),
             gr.update(value=files.get("pdf"), visible=bool(files.get("pdf")))
         )
 
-    export_btn.click(export_handler, inputs=[chatbot], outputs=[file_txt, file_pdf])
 
+    export_btn.click(export_handler, inputs=[chatbot], outputs=[file_txt, file_pdf])
+    
+    
 if __name__ == "__main__":
     demo.launch()

src/chatbot.py

@@ -7,36 +7,29 @@ from src.templates import TEMPLATES
 # -------------------------------
 # DEFAULT GENERATION ARGUMENTS
 # -------------------------------
+
 DEFAULT_GEN_ARGS = {
-    "max_tokens": 350,
-    "temperature": 0.6,
-    "top_p": 0.9
+    "max_tokens": 350,     
+    "temperature": 0.6,    
+    "top_p": 0.9           
 }
 
+
 MSG_SEPARATOR = "\n"
 
-# -------------------------------
-# Local Chatbot Class
-# -------------------------------
+
 class LocalChatbot:
     def __init__(self, llm, memory, default_template: Optional[str] = "general"):
         self.llm = llm
         self.memory = memory
         self.default_template = default_template
 
-    # ------------------------------------------------
-    # System Prompt Builder (intent → template)
-    # ------------------------------------------------
-    def _build_system_prompt(self, intent: Optional[str]) -> str:
-        return TEMPLATES.get(
-            intent,
-            TEMPLATES.get(self.default_template, TEMPLATES["general"])
-        )
-
-    # ------------------------------------------------
-    # Chat Prompt Builder
-    # ------------------------------------------------
-    def _build_prompt(self, user_message: str, intent: Optional[str], max_pairs: int = 12) -> str:
+    def _build_system_prompt(self, intent: str) -> str:
+        # get template for intent
+        return TEMPLATES.get(intent, TEMPLATES.get(self.default_template, TEMPLATES["general"]))
+
+    def _build_prompt(self, user_message: str, intent: str, max_pairs: int = 12) -> str:
+        # Trim memory to recent pairs before building prompt
         try:
             self.memory.trim_to_recent_pairs(max_pairs)
         except Exception:
@@ -44,59 +37,44 @@ class LocalChatbot:
 
         system_prompt = self._build_system_prompt(intent)
         history_text = self.memory.get_formatted(separator=MSG_SEPARATOR)
-
+     
         parts = [
-            f"System: {system_prompt}",
-            history_text,
-            f"User: {user_message}",
-            "Assistant:"
-        ]
-        return MSG_SEPARATOR.join([p for p in parts if p])
-
-    # ------------------------------------------------
-    # Main Ask Function
-    # ------------------------------------------------
-    def ask(self, user_message: Any, gen_args: Optional[Dict[str, Any]] = None, intent: Optional[str] = None) -> str:
-
-        # --- FIX #1: Extract text from Gradio compatibility formats ---
-        if isinstance(user_message, list):
-            extracted = []
-            for item in user_message:
-                if isinstance(item, dict) and "text" in item:
-                    extracted.append(item["text"])
-            user_message = "\n".join(extracted)
-
-        elif isinstance(user_message, dict) and "text" in user_message:
-            user_message = user_message["text"]
-
-        user_message = str(user_message).strip()
-
-        if not user_message:
+                    f"System: {system_prompt}",
+                    history_text,
+                    f"User: {user_message}",
+                    "Assistant:"
+                ]
+                # join non-empty parts
+        return MSG_SEPARATOR.join([p for p in parts if p is not None and p != ""])
+
+
+    def ask(self, user_message: str, gen_args: Optional[Dict[str, Any]] = None) -> str:
+        if not user_message or not user_message.strip():
             return "Please enter a message."
 
-        # --- FIX #2: Use passed intent, or detect if None ---
-        if intent is None:
-            intent = detect_intent(user_message)
+        # Detect intent
+        intent = detect_intent(user_message)
 
         # Build prompt
         prompt = self._build_prompt(user_message, intent, max_pairs=12)
 
-        # Merge generation args
+
+   # Merge generation args
         gen = DEFAULT_GEN_ARGS.copy()
         if gen_args:
             gen.update(gen_args)
 
-        # Call LLM
+        # Attempt to call the LLM (defensive: handle different API variants)
         try:
             output = self.llm(prompt, **gen)
         except TypeError:
-            # fallback: rename max_tokens → max_new_tokens
+            # fallback mapping: map max_tokens -> max_new_tokens
             alt_gen = gen.copy()
             if "max_tokens" in alt_gen:
                 alt_gen["max_new_tokens"] = alt_gen.pop("max_tokens")
             output = self.llm(prompt, **alt_gen)
 
-        # Parse output
+        # Parse the output robustly
         bot_reply = ""
         try:
             if isinstance(output, dict) and "choices" in output:
@@ -111,7 +89,7 @@ class LocalChatbot:
         if not bot_reply:
             bot_reply = "Sorry — I couldn't generate a response. Please try again."
 
-        # Store memory
+        # Add to memory
         try:
             self.memory.add(user_message, bot_reply)
         except Exception:
@@ -122,3 +100,27 @@ class LocalChatbot:
                 pass
 
         return bot_reply
+
+
+    
+    
+    # # Create the generation args HERE
+    #     gen = DEFAULT_GEN_ARGS.copy()
+    #     if gen_args:
+    #         gen.update(gen_args)
+            
+    #     response = self.llm(
+    #         prompt,
+    #         max_tokens=gen["max_tokens"],
+    #         temperature=gen["temperature"],
+    #         top_p=gen["top_p"],
+
+    #         stop=["</system>", "\nUser:", "\nUser says:", "\nSystem:", "\nAssistant:", "\nYou:"]
+
+
+    #     )
+
+    #     reply = response["choices"][0]["text"].strip()
+
+    #     self.memory.add(user_message, reply)
+    #     return reply