Updated to gradio

Dockerfile

@@ -3,12 +3,6 @@
 
 FROM python:3.12
 
-# # Install system dependencies
-# RUN apt-get update && apt-get install -y \
-#     portaudio19-dev \
-#     python3-dev \
-#     && rm -rf /var/lib/apt/lists/*
-
 # Install ALSA dependencies and other packages
 RUN apt-get update && apt-get install -y \
     alsa-utils \
@@ -26,15 +20,9 @@ COPY requirements.txt .
 RUN pip install --no-cache-dir --upgrade -r requirements.txt
 
 COPY . .
-# CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "7860"]
-
-# Set the environment variable for Flask
-ENV FLASK_APP=app.py
-ENV FLASK_RUN_HOST=0.0.0.0
-ENV FLASK_RUN_PORT=7860
 
-# Expose the port Flask will run on
+# Expose the port Gradio will run on
 EXPOSE 7860
 
-# Command to run the Flask app
-CMD ["flask", "run"]
+# Command to run the Gradio app
+CMD ["python", "app.py"]

Dockerfile_backups

@@ -0,0 +1,40 @@
+# read the doc: https://huggingface.co/docs/hub/spaces-sdks-docker
+# you will also find guides on how best to write your Dockerfile
+
+FROM python:3.12
+
+# # Install system dependencies
+# RUN apt-get update && apt-get install -y \
+#     portaudio19-dev \
+#     python3-dev \
+#     && rm -rf /var/lib/apt/lists/*
+
+# Install ALSA dependencies and other packages
+RUN apt-get update && apt-get install -y \
+    alsa-utils \
+    libasound2 \
+    portaudio19-dev \
+    python3-dev \
+    && rm -rf /var/lib/apt/lists/*
+
+# The two following lines are requirements for the Dev Mode to be functional
+# Learn more about the Dev Mode at https://huggingface.co/dev-mode-explorers
+RUN useradd -m -u 1000 user
+WORKDIR /app
+
+COPY requirements.txt .
+RUN pip install --no-cache-dir --upgrade -r requirements.txt
+
+COPY . .
+# CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "7860"]
+
+# Set the environment variable for Flask
+ENV FLASK_APP=app.py
+ENV FLASK_RUN_HOST=0.0.0.0
+ENV FLASK_RUN_PORT=7860
+
+# Expose the port Flask will run on
+EXPOSE 7860
+
+# Command to run the Flask app
+CMD ["flask", "run"]

app.py

@@ -1,177 +1,65 @@
-from flask import Flask, render_template, request, jsonify
+import gradio as gr
 import speech_recognition as sr
 from googletrans import Translator
 import requests
 import os
- 
-app = Flask(__name__)
- 
+
 # Initialize recognizer and translator
 recognizer = sr.Recognizer()
 translator = Translator()
- 
+
 # Language settings mapping
 language_mapping = {
-    1: ('ta-IN', 'ta', 'en'),  # Tamil
-    2: ('en-US', 'en', 'en'),  # English
-    3: ('hi-IN', 'hi', 'en'),  # Hindi
-    4: ('ms-MY', 'ms', 'en')   # Malay
+    "Tamil": ('ta-IN', 'ta', 'en'),
+    "English": ('en-US', 'en', 'en'),
+    "Hindi": ('hi-IN', 'hi', 'en'),
+    "Malay": ('ms-MY', 'ms', 'en')
 }
- 
-# Check microphone availability at startup
-try:
-    mic_list = sr.Microphone.list_microphone_names()
-    print("Available microphones:", mic_list)
-    if not mic_list:
-        print("WARNING: No microphones detected - audio input disabled")
-except OSError as e:
-    print(f"Microphone check failed: {str(e)}")
- 
-@app.route('/')
-def index():
-    return render_template("index.html")
- 
-@app.route('/speech-to-text', methods=['POST'])
-def speech_to_text():
+
+def speech_to_text(language):
     """Convert speech to text, translate, and query the /ask endpoint"""
-    try:
-        language = int(request.form.get("language", 0))
-        if language not in language_mapping:
-            return jsonify({"error": "Invalid language selection"}), 400
- 
-        recognition_lang, src_lang, dest_lang = language_mapping[language]
- 
-        # Get available microphone devices
-        mic_devices = sr.Microphone.list_microphone_names()
-        if not mic_devices:
-            return jsonify({"error": "No audio input devices available"}), 400
- 
-        # Use first available microphone explicitly
-        with sr.Microphone(device_index=0) as source:
-            print(f"Listening for {recognition_lang}...")
-            recognizer.adjust_for_ambient_noise(source, duration=1)
-            audio = recognizer.listen(source, timeout=10)
- 
+    if language not in language_mapping:
+        return "Invalid language selection", "", ""
+    
+    recognition_lang, src_lang, dest_lang = language_mapping[language]
+    
+    with sr.Microphone() as source:
+        print(f"Listening for {recognition_lang}...")
+        recognizer.adjust_for_ambient_noise(source)
+        audio = recognizer.listen(source)
+        
+        try:
             text = recognizer.recognize_google(audio, language=recognition_lang)
             print(f"Recognized: {text}")
- 
+            
             # Translate text
             translated = translator.translate(text, src=src_lang, dest=dest_lang)
             print(f"Translated: {translated.text}")
- 
-            # API call with error handling
+            
+            # Send to /ask API
             API_KEY = os.getenv("RAG_API_KEY")
-            if not API_KEY:
-                return jsonify({"error": "API key not configured"}), 500
- 
-            response = requests.post(
-                url="https://aitestingworkspace-aiagentchatup.hf.space/ask",
-                headers={"Authorization": f"Bearer {API_KEY}"},
-                data={"question": translated.text},
-                timeout=15
-            )
- 
-            return jsonify({
-                "recognized_text": text,
-                "translated_text": translated.text,
-                "server_response": response.json().get('answer', 'No response')
-            })
- 
-    except sr.UnknownValueError:
-        return jsonify({"error": "Could not understand audio"}), 400
-    except sr.RequestError as e:
-        return jsonify({"error": f"Speech recognition error: {str(e)}"}), 500
-    except OSError as e:
-        return jsonify({"error": f"Audio device error: {str(e)}"}), 500
-    except Exception as e:
-        return jsonify({"error": f"Unexpected error: {str(e)}"}), 500
- 
-if __name__ == "__main__":
-    app.run(host="0.0.0.0", port=5000, debug=False)  # Disable debug for production
-
-
-###################This is the Existing CODE########################################
-# from flask import Flask, render_template, request, jsonify
-# import speech_recognition as sr
-# from googletrans import Translator
-# import requests
-# import os
-# # import pyttsx3
-
-# app = Flask(__name__)
-
-# # Initialize recognizer and translator
-# recognizer = sr.Recognizer()
-# translator = Translator()
-# # engine = pyttsx3.init()
-
-# # Language settings mapping
-# language_mapping = {
-#     1: ('ta-IN', 'ta', 'en'),  # Tamil
-#     2: ('en-US', 'en', 'en'),  # English
-#     3: ('hi-IN', 'hi', 'en'),  # Hindi
-#     4: ('ms-MY', 'ms', 'en')   # Malay
-# }
-
-# @app.route('/')
-# def index():
-#     return render_template("index.html")
-
-# # def speak(text):
-# #     engine.say(text)
-# #     engine.runAndWait()
-
-# @app.route('/speech-to-text', methods=['POST'])
-# def speech_to_text():
-#     """Convert speech to text, translate, and query the /ask endpoint"""
-#     language = int(request.form.get("language", 0))
-
-#     if language not in language_mapping:
-#         return jsonify({"error": "Invalid language selection"}), 400
-
-#     recognition_lang, src_lang, dest_lang = language_mapping[language]
-
-#     with sr.Microphone() as source:
-#         print(f"Listening for {recognition_lang}...")
-#         recognizer.adjust_for_ambient_noise(source)
-#         audio = recognizer.listen(source)
-
-#         try:
-#             text = recognizer.recognize_google(audio, language=recognition_lang)
-#             print(f"Recognized: {text}")
-
-#             # Translate text
-#             translated = translator.translate(text, src=src_lang, dest=dest_lang)
-#             print(f"Translated: {translated.text}")
-
-#             # Send to /ask API
-#             API_KEY = os.getenv("RAG_API_KEY")
-
-#             # Hugging Face API endpoint
-#             url = "https://aitestingworkspace-aiagentchatup.hf.space/ask"
-
-#             # Headers with authentication
-#             headers = {
-#                 "Authorization": f"Bearer {API_KEY}"
-#             }
-
-#             response = requests.post(url=url,data={"question": translated.text},headers=headers)
-
-#             # # Get response and speak it
-#             # server_response = response.json().get('answer', 'No response received.')
-#             # print(f"Server Response: {server_response}")
-#             # speak(server_response)
-
-#             return jsonify({
-#                 "recognized_text": text,
-#                 "translated_text": translated.text,
-#                 "server_response": response.json()['answer']
-#             })
-
-#         except sr.UnknownValueError:
-#             return jsonify({"error": "Could not understand audio"}), 400
-#         except Exception as e:
-#             return jsonify({"error": str(e)}), 500
-
-# if __name__ == "__main__":
-#     app.run(host="0.0.0.0", port=5000, debug=True)
+            url = "https://aitestingworkspace-aiagentchatup.hf.space/ask"
+            headers = {"Authorization": f"Bearer {API_KEY}"}
+            response = requests.post(url=url, data={"question": translated.text}, headers=headers)
+            
+            return text, translated.text, response.json().get("answer", "No response received.")
+        
+        except sr.UnknownValueError:
+            return "Could not understand audio", "", ""
+        except Exception as e:
+            return str(e), "", ""
+
+# Gradio Interface
+demo = gr.Interface(
+    fn=speech_to_text,
+    inputs=gr.Dropdown(choices=list(language_mapping.keys()), label="Select Language"),
+    outputs=[
+        gr.Textbox(label="Recognized Text"),
+        gr.Textbox(label="Translated Text"),
+        gr.Textbox(label="Server Response")
+    ],
+    title="Speech to Text & Translation",
+    description="Speak in the selected language, and the system will transcribe, translate, and fetch a response."
+)
+
+demo.launch()

app_flask.py

@@ -0,0 +1,85 @@
+###################This is the Existing CODE########################################
+from flask import Flask, render_template, request, jsonify
+import speech_recognition as sr
+from googletrans import Translator
+import requests
+import os
+# import pyttsx3
+
+app = Flask(__name__)
+
+# Initialize recognizer and translator
+recognizer = sr.Recognizer()
+translator = Translator()
+# engine = pyttsx3.init()
+
+# Language settings mapping
+language_mapping = {
+    1: ('ta-IN', 'ta', 'en'),  # Tamil
+    2: ('en-US', 'en', 'en'),  # English
+    3: ('hi-IN', 'hi', 'en'),  # Hindi
+    4: ('ms-MY', 'ms', 'en')   # Malay
+}
+
+@app.route('/')
+def index():
+    return render_template("index.html")
+
+# def speak(text):
+#     engine.say(text)
+#     engine.runAndWait()
+
+@app.route('/speech-to-text', methods=['POST'])
+def speech_to_text():
+    """Convert speech to text, translate, and query the /ask endpoint"""
+    language = int(request.form.get("language", 0))
+
+    if language not in language_mapping:
+        return jsonify({"error": "Invalid language selection"}), 400
+
+    recognition_lang, src_lang, dest_lang = language_mapping[language]
+
+    with sr.Microphone() as source:
+        print(f"Listening for {recognition_lang}...")
+        recognizer.adjust_for_ambient_noise(source)
+        audio = recognizer.listen(source)
+
+        try:
+            text = recognizer.recognize_google(audio, language=recognition_lang)
+            print(f"Recognized: {text}")
+
+            # Translate text
+            translated = translator.translate(text, src=src_lang, dest=dest_lang)
+            print(f"Translated: {translated.text}")
+
+            # Send to /ask API
+            API_KEY = os.getenv("RAG_API_KEY")
+
+            # Hugging Face API endpoint
+            url = "https://aitestingworkspace-aiagentchatup.hf.space/ask"
+
+            # Headers with authentication
+            headers = {
+                "Authorization": f"Bearer {API_KEY}"
+            }
+
+            response = requests.post(url=url,data={"question": translated.text},headers=headers)
+
+            # # Get response and speak it
+            # server_response = response.json().get('answer', 'No response received.')
+            # print(f"Server Response: {server_response}")
+            # speak(server_response)
+
+            return jsonify({
+                "recognized_text": text,
+                "translated_text": translated.text,
+                "server_response": response.json()['answer']
+            })
+
+        except sr.UnknownValueError:
+            return jsonify({"error": "Could not understand audio"}), 400
+        except Exception as e:
+            return jsonify({"error": str(e)}), 500
+
+if __name__ == "__main__":
+    app.run(host="0.0.0.0", port=5000, debug=True)

templates/index.html

@@ -3,12 +3,12 @@
 <head>
     <meta charset="UTF-8">
     <meta name="viewport" content="width=device-width, initial-scale=1.0">
-    <title>Speech to Text</title>
+    <title>UST CHATBOT</title>
     <link rel="stylesheet" href="{{ url_for('static', filename='styles.css') }}">
 </head>
 <body>
     <div class="container">
-        <h1>Speech to Text Converter</h1>
+        <h1>UST CHATBOT</h1>
         <form id="speechForm">
             <label for="language">Select Language:</label>
             <select id="language" name="language">