Update app.py

app.py

@@ -1,133 +1,140 @@
 import gradio as gr
-import torch
-from transformers import AutoTokenizer, AutoModelForCausalLM, pipeline
-import warnings
-warnings.filterwarnings("ignore")
+import os
+import requests
+import json
+from typing import List, Tuple
+import time
 
-# Initialize models with better error handling
-def load_models():
-    """Load models with proper error handling"""
+# Simple chatbot using Hugging Face Inference API (free tier)
+HF_TOKEN = os.getenv("HUGGINGFACE_HUB_TOKEN", "")  # Optional: set in Space secrets
+
+def is_nepali_text(text: str) -> bool:
+    """Simple check to see if text contains Devanagari script (Nepali)"""
+    return any('\u0900' <= char <= '\u097F' for char in text)
+
+def translate_text(text: str, source_lang: str = "ne", target_lang: str = "en") -> str:
+    """Translate text using Hugging Face Inference API"""
     try:
-        # Load conversational model
-        model_name = "microsoft/DialoGPT-medium"
-        tokenizer = AutoTokenizer.from_pretrained(model_name)
-        model = AutoModelForCausalLM.from_pretrained(model_name)
+        # Use Helsinki translation models via API
+        if source_lang == "ne" and target_lang == "en":
+            model = "Helsinki-NLP/opus-mt-ne-en"
+        elif source_lang == "en" and target_lang == "ne":
+            model = "Helsinki-NLP/opus-mt-en-ne"
+        else:
+            return text
         
-        # Add padding token if not present
-        if tokenizer.pad_token is None:
-            tokenizer.pad_token = tokenizer.eos_token
-            
-        print("✅ Conversational model loaded successfully")
+        api_url = f"https://api-inference.huggingface.co/models/{model}"
+        headers = {"Authorization": f"Bearer {HF_TOKEN}"} if HF_TOKEN else {}
+        
+        payload = {"inputs": text}
+        response = requests.post(api_url, headers=headers, json=payload, timeout=30)
+        
+        if response.status_code == 200:
+            result = response.json()
+            if isinstance(result, list) and len(result) > 0:
+                return result[0].get("translation_text", text)
         
-        # Load translation models
-        try:
-            en_to_ne = pipeline("translation", model="Helsinki-NLP/opus-mt-en-ne", device=-1)
-            ne_to_en = pipeline("translation", model="Helsinki-NLP/opus-mt-ne-en", device=-1)
-            print("✅ Translation models loaded successfully")
-            return tokenizer, model, en_to_ne, ne_to_en, True
-        except Exception as e:
-            print(f"⚠️ Translation models failed to load: {e}")
-            print("📝 Continuing with English-only mode")
-            return tokenizer, model, None, None, False
-            
-    except Exception as e:
-        print(f"❌ Failed to load models: {e}")
-        return None, None, None, None, False
-
-# Load models
-tokenizer, model, en_to_ne, ne_to_en, translation_available = load_models()
-
-def translate_to_english(text):
-    """Translate Nepali text to English"""
-    if not translation_available or ne_to_en is None:
         return text
-    try:
-        result = ne_to_en(text, max_length=512)
-        return result[0]['translation_text']
     except Exception as e:
-        print(f"Translation error (NE->EN): {e}")
+        print(f"Translation error: {e}")
         return text
 
-def translate_to_nepali(text):
-    """Translate English text to Nepali"""
-    if not translation_available or en_to_ne is None:
-        return text
+def generate_response_api(message: str) -> str:
+    """Generate response using Hugging Face Inference API"""
     try:
-        result = en_to_ne(text, max_length=512)
-        return result[0]['translation_text']
+        # Use a lightweight conversational model
+        model = "microsoft/DialoGPT-medium"
+        api_url = f"https://api-inference.huggingface.co/models/{model}"
+        headers = {"Authorization": f"Bearer {HF_TOKEN}"} if HF_TOKEN else {}
+        
+        payload = {
+            "inputs": message,
+            "parameters": {
+                "max_length": 100,
+                "temperature": 0.7,
+                "do_sample": True,
+                "top_p": 0.9,
+                "repetition_penalty": 1.1
+            }
+        }
+        
+        response = requests.post(api_url, headers=headers, json=payload, timeout=30)
+        
+        if response.status_code == 200:
+            result = response.json()
+            if isinstance(result, list) and len(result) > 0:
+                generated_text = result[0].get("generated_text", "")
+                # Extract only the new part of the response
+                if generated_text.startswith(message):
+                    response_text = generated_text[len(message):].strip()
+                else:
+                    response_text = generated_text.strip()
+                
+                return response_text if response_text else "I understand. Could you tell me more?"
+        
+        # Fallback responses
+        return "I'm here to help! Could you tell me more about what you'd like to discuss?"
+        
     except Exception as e:
-        print(f"Translation error (EN->NE): {e}")
-        return text
+        print(f"API error: {e}")
+        return "I'm having trouble connecting right now. Please try again in a moment."
 
-def is_nepali_text(text):
-    """Simple check to see if text contains Devanagari script (Nepali)"""
-    nepali_chars = any('\u0900' <= char <= '\u097F' for char in text)
-    return nepali_chars
+def simple_fallback_response(message: str) -> str:
+    """Simple rule-based fallback responses"""
+    message_lower = message.lower()
+    
+    # English responses
+    if any(word in message_lower for word in ["hello", "hi", "hey"]):
+        return "Hello! How can I help you today?"
+    elif any(word in message_lower for word in ["how", "are", "you"]):
+        return "I'm doing well, thank you! How about you?"
+    elif any(word in message_lower for word in ["name", "who"]):
+        return "I'm a Nepali chatbot here to help you!"
+    elif any(word in message_lower for word in ["bye", "goodbye"]):
+        return "Goodbye! Have a great day!"
+    
+    # Check if it's Nepali text
+    if is_nepali_text(message):
+        return "धन्यवाद! म तपाईंलाई कसरी मद्दत गर्न सक्छु?"
+    
+    return "That's interesting! Tell me more about it."
 
-def generate_response(message, history):
-    """Generate chatbot response"""
-    if tokenizer is None or model is None:
-        return "Sorry, the chatbot models failed to load. Please try refreshing the page."
+def chat_function(message: str, history: List[List[str]]) -> Tuple[List[List[str]], str]:
+    """Main chat function"""
+    if not message.strip():
+        return history, ""
+    
+    # Detect language
+    is_nepali = is_nepali_text(message)
     
     try:
-        # Check if input is in Nepali and translate to English if needed
-        if is_nepali_text(message):
-            english_message = translate_to_english(message)
-            print(f"Translated input: {message} -> {english_message}")
+        if is_nepali:
+            # Translate Nepali to English for processing
+            english_message = translate_text(message, "ne", "en")
+            print(f"Translated NE->EN: {message} -> {english_message}")
+            
+            # Generate response in English
+            english_response = generate_response_api(english_message)
+            
+            # Translate back to Nepali
+            nepali_response = translate_text(english_response, "en", "ne")
+            print(f"Translated EN->NE: {english_response} -> {nepali_response}")
+            
+            bot_response = nepali_response
         else:
-            english_message = message
-
-        # Prepare conversation history
-        bot_input_ids = tokenizer.encode(english_message + tokenizer.eos_token, return_tensors='pt')
+            # Process in English directly
+            bot_response = generate_response_api(message)
         
-        # Generate response with more conservative settings for stability
-        with torch.no_grad():
-            chat_history_ids = model.generate(
-                bot_input_ids,
-                max_length=min(1000, bot_input_ids.shape[-1] + 100),
-                num_beams=3,
-                no_repeat_ngram_size=2,
-                temperature=0.8,
-                do_sample=True,
-                pad_token_id=tokenizer.eos_token_id,
-                early_stopping=True,
-                max_new_tokens=100
-            )
-
-        # Decode the response
-        response = tokenizer.decode(chat_history_ids[:, bot_input_ids.shape[-1]:][0], skip_special_tokens=True)
-        
-        # Clean up response
-        response = response.strip()
-        if not response:
-            response = "I understand. Could you tell me more?"
+        # Fallback if API response is empty or unhelpful
+        if not bot_response or len(bot_response.strip()) < 3:
+            bot_response = simple_fallback_response(message)
         
-        # If original input was in Nepali, translate response back to Nepali
-        if is_nepali_text(message) and translation_available:
-            nepali_response = translate_to_nepali(response)
-            print(f"Translated output: {response} -> {nepali_response}")
-            return nepali_response
-        else:
-            return response
-            
     except Exception as e:
-        print(f"Error generating response: {e}")
-        error_msg = "Sorry, I encountered an error. Please try again."
-        if is_nepali_text(message):
-            return "माफ गर्नुहोस्, मलाई समस्या भयो। कृपया फेरि प्रयास गर्नुहोस्।"
-        return error_msg
-
-def chat_interface(message, history):
-    """Gradio chat interface function"""
-    if not message.strip():
-        return history, ""
-    
-    # Generate bot response
-    bot_response = generate_response(message, history)
+        print(f"Chat error: {e}")
+        bot_response = simple_fallback_response(message)
     
     # Add to history
     history.append([message, bot_response])
-    
     return history, ""
 
 # Custom CSS for better appearance
@@ -142,18 +149,22 @@ css = """
 .message.bot {
     background-color: #f5f5f5 !important;
 }
+.chat-message {
+    padding: 10px !important;
+    border-radius: 8px !important;
+}
 """
 
 # Create Gradio interface
-with gr.Blocks(css=css, title="Nepali Chatbot") as demo:
+with gr.Blocks(css=css, title="Nepali Chatbot", theme=gr.themes.Soft()) as demo:
     gr.Markdown("""
-    # नेपाली च्याटबोट (Nepali Chatbot) 🇳🇵
+    # 🇳🇵 नेपाली च्याटबोट (Nepali Chatbot)
     
-    A simple chatbot that can understand and respond in Nepali language.
+    **तपाईंलाई स्वागत छ! Welcome!** 
     
-    **नेपालीमा कुराकानी गर्नुहोस् वा अंग्रेजीमा!**
+    This chatbot can understand and respond in both Nepali and English.
     
-    *You can chat in Nepali or English - the bot will respond in the same language you use.*
+    **नेपालीमा वा अंग्रेजीमा कुराकानी सुरु गर्नुहोस्!**
     """)
     
     chatbot = gr.Chatbot(
@@ -161,54 +172,58 @@ with gr.Blocks(css=css, title="Nepali Chatbot") as demo:
         height=400,
         show_label=False,
         container=True,
-        bubble_full_width=False
+        bubble_full_width=False,
+        show_copy_button=True
     )
     
     with gr.Row():
         msg = gr.Textbox(
-            placeholder="तपाईंको सन्देश यहाँ लेख्नुहोस्... (Type your message here...)",
+            placeholder="यहाँ आफ्नो सन्देश लेख्नुहोस्... / Type your message here...",
             show_label=False,
             scale=4,
-            container=False
+            container=False,
+            lines=1
         )
-        submit_btn = gr.Button("Send", scale=1, variant="primary")
-        clear_btn = gr.Button("Clear", scale=1)
+        submit_btn = gr.Button("📤 Send", scale=1, variant="primary")
+        clear_btn = gr.Button("🗑️ Clear", scale=1)
     
-    # Event handlers
-    msg.submit(
-        chat_interface, 
-        inputs=[msg, chatbot], 
-        outputs=[chatbot, msg],
-        queue=True
+    # Examples for users to try
+    gr.Examples(
+        examples=[
+            ["नमस्ते! तपाईं कस्तो हुनुहुन्छ?"],
+            ["Hello! How are you?"],
+            ["तपाईंको नाम के हो?"],
+            ["What's your name?"],
+            ["मलाई नेपालको बारेमा भन्नुहोस्"],
+            ["Tell me about Nepal"]
+        ],
+        inputs=msg,
+        label="Try these examples / यी उदाहरणहरू प्रयास गर्नुहोस्:"
     )
     
-    submit_btn.click(
-        chat_interface,
-        inputs=[msg, chatbot],
-        outputs=[chatbot, msg],
-        queue=True
-    )
-    
-    clear_btn.click(
-        lambda: ([], ""),
-        outputs=[chatbot, msg],
-        queue=False
-    )
+    # Event handlers
+    msg.submit(chat_function, inputs=[msg, chatbot], outputs=[chatbot, msg], queue=True)
+    submit_btn.click(chat_function, inputs=[msg, chatbot], outputs=[chatbot, msg], queue=True)
+    clear_btn.click(lambda: ([], ""), outputs=[chatbot, msg], queue=False)
     
     gr.Markdown("""
     ---
-    **Note:** This chatbot uses translation models to handle Nepali language. 
-    The responses might not be perfect but should be understandable.
+    **📝 Note:** This chatbot uses Hugging Face's free inference API for translation and conversation.
     
-    **टिप्पणी:** यो च्याटबोटले नेपाली भाषा ह्यान्डल गर्न अनुवाद मोडेलहरू प्रयोग गर्छ।
+    **टिप्पणी:** यो च्याटबोटले अनुवाद र कुराकानीका लागि Hugging Face को नि:शुल्क API प्रयोग गर्छ।
+    
+    *Response time may vary depending on API availability.*
     """)
 
-# Launch the app
+# Launch configuration
 if __name__ == "__main__":
-    demo.queue(concurrency_count=3)
+    demo.queue(
+        concurrency_count=1,  # Lower concurrency for free tier
+        max_size=10
+    )
     demo.launch(
-        share=False,
         server_name="0.0.0.0",
         server_port=7860,
-        show_error=True
+        show_error=True,
+        share=False
     )