hearing.py

import streamlit as st

import base64
import cv2
import sqlite3


# ================ Background image ===

st.markdown(f'<h1 style="color:#000000;text-align: center;font-size:32px;">{"E-Learning System"}</h1>', unsafe_allow_html=True)


def add_bg_from_local(image_file):
    with open(image_file, "rb") as image_file:
        encoded_string = base64.b64encode(image_file.read())
    st.markdown(
    f"""
    <style>
    .stApp {{
        background-image: url(data:image/{"png"};base64,{encoded_string.decode()});
        background-size: cover
    }}
    </style>
    """,
    unsafe_allow_html=True
    )
add_bg_from_local('1.webp')


st.markdown(f'<h1 style="color:#000000;text-align: center;font-size:24px;font-family:Caveat, sans-serif;">{"Choose Subjects !!!"}</h1>', unsafe_allow_html=True)


ch=st.selectbox("Subjects",("Choose Here","Artificial Intelligence","Python"))


if ch=="Artificial Intelligence":
    
    
    ch1=st.selectbox("Subjects",("Choose Video Type","Video1","Video2"))
    
    if ch1=="Video1":
    
    
        st.video("A1.mp4")
        
        a=st.checkbox("💬 Chat")
        
        if a:
        
        
            import os
            import streamlit as st
            import google.generativeai as genai
            
            # Configure the API with your API key
            # genai.configure(api_key="YOUR_API_KEY_HERE")
            genai.configure(api_key="")
            
            # Create the model and set up the generation configuration
            generation_config = {
              "temperature": 1,
              "top_p": 0.95,
              "top_k": 40,
              "max_output_tokens": 8192,
              "response_mime_type": "text/plain",
            }
            
            # Initialize the model
            model = genai.GenerativeModel(
              model_name="gemini-1.5-flash",
              generation_config=generation_config,
              system_instruction="You are an AI assistant answering questions about artificial intelligence. Respond concisely and clearly.",
            )
            
            # Start the chat session with predefined AI-related context
            chat_session = model.start_chat(
              history=[
                {
                  "role": "user",
                  "parts": [
                    "What is artificial intelligence?",
                  ],
                },
                {
                  "role": "model",
                  "parts": [
                    "Artificial intelligence (AI) refers to the simulation of human intelligence in machines designed to think and act like humans. It involves learning, reasoning, problem-solving, perception, and language understanding.",
                  ],
                },
                {
                  "role": "user",
                  "parts": [
                    "What are the types of machine learning?",
                  ],
                },
                {
                  "role": "model",
                  "parts": [
                    "Machine learning can be classified into three main types: supervised learning, unsupervised learning, and reinforcement learning. Each has its own approach and application in AI tasks.",
                  ],
                },
              ]
            )
                
            # Display a prompt for user input
            user_input = st.text_input("You:", "")
            
            # If user provides input
            if user_input:
                # Send the user input to the chat model and get the response
                response = chat_session.send_message(user_input)
                bot_response = response.text
                
                st.markdown(f"""
        <div style="display: flex; flex-direction: column; margin-bottom: 10px;">
            <!-- User's input on the right -->
            <div style="display: flex; justify-content: flex-end; margin-bottom: 10px;">
                <div style="background-color: #f1f1f1; padding: 10px; border-radius: 5px; max-width: 80%; word-wrap: break-word;">
                    <strong>You 🧑 :</strong> {user_input}
                </div>
            </div>
            <!-- Bot's response on the left -->
            <div style="display: flex; justify-content: flex-start; margin-bottom: 10px;">
                <div style="background-color: #e0e0e0; padding: 10px; border-radius: 5px; max-width: 80%; word-wrap: break-word;">
                    <strong>Bot 🤖:</strong> {bot_response}
        
        </div>
        """, unsafe_allow_html=True)
            
                # # Display user input (right side) and bot response (left side)
                # st.markdown(f"""
                # <div style="display: flex; justify-content: flex-end; margin-bottom: 10px;">
                #     <div style="background-color: #f1f1f1; padding: 10px; border-radius: 5px; max-width: 80%; word-wrap: break-word;">
                #         <strong>You 🧑 :</strong> {user_input}
                   
                # </div>
                # <div style="display: flex; justify-content: flex-start; margin-bottom: 10px;">
                #     <div style="background-color: #e0e0e0; padding: 10px; border-radius: 5px; max-width: 80%; word-wrap: break-word;">
                #         <strong>Bot 🤖:</strong> {bot_response}
                   
                # </div>
                # """, unsafe_allow_html=True)
            
            # Display exit option
            if st.button('Exit'):
                st.stop()
    
            
        a1=st.checkbox("🎤 Speak")
        
        if a1:    
    
            import os
            import streamlit as st
            import google.generativeai as genai
            import speech_recognition as sr
            from gtts import gTTS
            import tempfile
            
            # Configure the API with your API key
            genai.configure(api_key="")
            
            # Create the model and set up the generation configuration
            generation_config = {
                "temperature": 1,
                "top_p": 0.95,
                "top_k": 40,
                "max_output_tokens": 8192,
                "response_mime_type": "text/plain",
            }
            
            # Initialize the model
            model = genai.GenerativeModel(
                model_name="gemini-1.5-flash",
                generation_config=generation_config,
                system_instruction="You are an AI assistant answering questions about artificial intelligence. Respond concisely and clearly.",
            )
            
            # Start the chat session with predefined AI-related context
            chat_session = model.start_chat(
                history=[
                    {
                        "role": "user",
                        "parts": [
                            "What is artificial intelligence?",
                        ],
                    },
                    {
                        "role": "model",
                        "parts": [
                            "Artificial intelligence (AI) refers to the simulation of human intelligence in machines designed to think and act like humans. It involves learning, reasoning, problem-solving, perception, and language understanding.",
                        ],
                    },
                    {
                        "role": "user",
                        "parts": [
                            "What are the types of machine learning?",
                        ],
                    },
                    {
                        "role": "model",
                        "parts": [
                            "Machine learning can be classified into three main types: supervised learning, unsupervised learning, and reinforcement learning. Each has its own approach and application in AI tasks.",
                        ],
                    },
                ]
            )
            
            # Initialize speech recognition
            recognizer = sr.Recognizer()
            
            # Set up speech-to-text function
            def listen_to_audio():
                with sr.Microphone() as source:
                    print("Listening for your input...")
                    recognizer.adjust_for_ambient_noise(source)
                    audio = recognizer.listen(source)
                    
                try:
                    print("Recognizing your speech...")
                    user_input = recognizer.recognize_google(audio)
                    print(f"You said: {user_input}")
                    # user_input = generate_speech(user_input)
            
                    # Create audio tag to play the bot's response on the webpage
                    # st.audio(user_input, format="audio/mp3")
                    return user_input
                except sr.UnknownValueError:
                    print("Sorry, I couldn't understand your speech.")
                    return ""
                except sr.RequestError:
                    print("Sorry, there was an issue with the speech recognition service.")
                    return ""
            
            # Set up text-to-speech function for the bot's response
            def generate_speech(text):
                tts = gTTS(text)
                # Use a temporary file to store the generated speech
                with tempfile.NamedTemporaryFile(delete=False) as tmpfile:
                    tmpfile.close()
                    tts.save(tmpfile.name)
                    return tmpfile.name
            
            # Streamlit UI
            # st.title("Voice Assistant with AI")
            
            # Option to start listening to user's voice input
            if st.button("Start Listening"):
                user_input = listen_to_audio()
            
                if user_input:
                    # Send the user input to the chat model and get the response
                    response = chat_session.send_message(user_input)
                    bot_response = response.text
            
                    # Display user input and bot response as text
                    st.markdown(f"""
                    <div style="display: flex; flex-direction: column; margin-bottom: 10px;">
                        <!-- User's input on the right -->
                        <div style="display: flex; justify-content: flex-end; margin-bottom: 10px;">
                            <div style="background-color: #f1f1f1; padding: 10px; border-radius: 5px; max-width: 80%; word-wrap: break-word;">
                                <strong>You 🧑 :</strong> {user_input}
                            </div>
                        </div>
                    #     <!-- Bot's response on the left -->
                    #     <div style="display: flex; justify-content: flex-start; margin-bottom: 10px;">
                    #         <div style="background-color: #e0e0e0; padding: 10px; border-radius: 5px; max-width: 80%; word-wrap: break-word;">
                    #             <strong>Bot 🤖:</strong> {bot_response}
                    #         </div>
                    #     </div>
                    # </div>
                    # """, unsafe_allow_html=True)
            
                    # Generate speech for the bot's response
                    bot_audio_path = generate_speech(bot_response)
            
                    # Create audio tag to play the bot's response on the webpage
                    st.audio(bot_audio_path, format="audio/mp3")
            
            # # Display exit option
            # if st.button('Exit1'):
            #     st.stop()
                
    if ch1=="Video2":
    
    
        st.video("A2.mp4")
        
        a=st.checkbox("💬 Chat")
        
        if a:
        
        
            import os
            import streamlit as st
            import google.generativeai as genai
            
            # Configure the API with your API key
            # genai.configure(api_key="YOUR_API_KEY_HERE")
            genai.configure(api_key="")
            
            # Create the model and set up the generation configuration
            generation_config = {
              "temperature": 1,
              "top_p": 0.95,
              "top_k": 40,
              "max_output_tokens": 8192,
              "response_mime_type": "text/plain",
            }
            
            # Initialize the model
            model = genai.GenerativeModel(
              model_name="gemini-1.5-flash",
              generation_config=generation_config,
              system_instruction="You are an AI assistant answering questions about artificial intelligence. Respond concisely and clearly.",
            )
            
            # Start the chat session with predefined AI-related context
            chat_session = model.start_chat(
              history=[
                {
                  "role": "user",
                  "parts": [
                    "What is artificial intelligence?",
                  ],
                },
                {
                  "role": "model",
                  "parts": [
                    "Artificial intelligence (AI) refers to the simulation of human intelligence in machines designed to think and act like humans. It involves learning, reasoning, problem-solving, perception, and language understanding.",
                  ],
                },
                {
                  "role": "user",
                  "parts": [
                    "What are the types of machine learning?",
                  ],
                },
                {
                  "role": "model",
                  "parts": [
                    "Machine learning can be classified into three main types: supervised learning, unsupervised learning, and reinforcement learning. Each has its own approach and application in AI tasks.",
                  ],
                },
              ]
            )
                
            # Display a prompt for user input
            user_input = st.text_input("You:", "")
            
            # If user provides input
            if user_input:
                # Send the user input to the chat model and get the response
                response = chat_session.send_message(user_input)
                bot_response = response.text
                
                st.markdown(f"""
        <div style="display: flex; flex-direction: column; margin-bottom: 10px;">
            <!-- User's input on the right -->
            <div style="display: flex; justify-content: flex-end; margin-bottom: 10px;">
                <div style="background-color: #f1f1f1; padding: 10px; border-radius: 5px; max-width: 80%; word-wrap: break-word;">
                    <strong>You 🧑 :</strong> {user_input}
                </div>
            </div>
            <!-- Bot's response on the left -->
            <div style="display: flex; justify-content: flex-start; margin-bottom: 10px;">
                <div style="background-color: #e0e0e0; padding: 10px; border-radius: 5px; max-width: 80%; word-wrap: break-word;">
                    <strong>Bot 🤖:</strong> {bot_response}
        
        </div>
        """, unsafe_allow_html=True)
            
                # # Display user input (right side) and bot response (left side)
                # st.markdown(f"""
                # <div style="display: flex; justify-content: flex-end; margin-bottom: 10px;">
                #     <div style="background-color: #f1f1f1; padding: 10px; border-radius: 5px; max-width: 80%; word-wrap: break-word;">
                #         <strong>You 🧑 :</strong> {user_input}
                   
                # </div>
                # <div style="display: flex; justify-content: flex-start; margin-bottom: 10px;">
                #     <div style="background-color: #e0e0e0; padding: 10px; border-radius: 5px; max-width: 80%; word-wrap: break-word;">
                #         <strong>Bot 🤖:</strong> {bot_response}
                   
                # </div>
                # """, unsafe_allow_html=True)
            
            # Display exit option
            if st.button('Exit'):
                st.stop()
    
            
        a1=st.checkbox("🎤 Speak")
        
        if a1:    
    
            import os
            import streamlit as st
            import google.generativeai as genai
            import speech_recognition as sr
            from gtts import gTTS
            import tempfile
            
            # Configure the API with your API key
            genai.configure(api_key="")
            
            # Create the model and set up the generation configuration
            generation_config = {
                "temperature": 1,
                "top_p": 0.95,
                "top_k": 40,
                "max_output_tokens": 8192,
                "response_mime_type": "text/plain",
            }
            
            # Initialize the model
            model = genai.GenerativeModel(
                model_name="gemini-1.5-flash",
                generation_config=generation_config,
                system_instruction="You are an AI assistant answering questions about artificial intelligence. Respond concisely and clearly.",
            )
            
            # Start the chat session with predefined AI-related context
            chat_session = model.start_chat(
                history=[
                    {
                        "role": "user",
                        "parts": [
                            "What is artificial intelligence?",
                        ],
                    },
                    {
                        "role": "model",
                        "parts": [
                            "Artificial intelligence (AI) refers to the simulation of human intelligence in machines designed to think and act like humans. It involves learning, reasoning, problem-solving, perception, and language understanding.",
                        ],
                    },
                    {
                        "role": "user",
                        "parts": [
                            "What are the types of machine learning?",
                        ],
                    },
                    {
                        "role": "model",
                        "parts": [
                            "Machine learning can be classified into three main types: supervised learning, unsupervised learning, and reinforcement learning. Each has its own approach and application in AI tasks.",
                        ],
                    },
                ]
            )
            
            # Initialize speech recognition
            recognizer = sr.Recognizer()
            
            # Set up speech-to-text function
            def listen_to_audio():
                with sr.Microphone() as source:
                    print("Listening for your input...")
                    recognizer.adjust_for_ambient_noise(source)
                    audio = recognizer.listen(source)
                    
                try:
                    print("Recognizing your speech...")
                    user_input = recognizer.recognize_google(audio)
                    print(f"You said: {user_input}")
                    # user_input = generate_speech(user_input)
            
                    # Create audio tag to play the bot's response on the webpage
                    # st.audio(user_input, format="audio/mp3")
                    return user_input
                except sr.UnknownValueError:
                    print("Sorry, I couldn't understand your speech.")
                    return ""
                except sr.RequestError:
                    print("Sorry, there was an issue with the speech recognition service.")
                    return ""
            
            # Set up text-to-speech function for the bot's response
            def generate_speech(text):
                tts = gTTS(text)
                # Use a temporary file to store the generated speech
                with tempfile.NamedTemporaryFile(delete=False) as tmpfile:
                    tmpfile.close()
                    tts.save(tmpfile.name)
                    return tmpfile.name
            
            # Streamlit UI
            # st.title("Voice Assistant with AI")
            
            # Option to start listening to user's voice input
            if st.button("Start Listening"):
                user_input = listen_to_audio()
            
                if user_input:
                    # Send the user input to the chat model and get the response
                    response = chat_session.send_message(user_input)
                    bot_response = response.text
            
                    # Display user input and bot response as text
                    st.markdown(f"""
                    <div style="display: flex; flex-direction: column; margin-bottom: 10px;">
                        <!-- User's input on the right -->
                        <div style="display: flex; justify-content: flex-end; margin-bottom: 10px;">
                            <div style="background-color: #f1f1f1; padding: 10px; border-radius: 5px; max-width: 80%; word-wrap: break-word;">
                                <strong>You 🧑 :</strong> {user_input}
                            </div>
                        </div>
                    #     <!-- Bot's response on the left -->
                    #     <div style="display: flex; justify-content: flex-start; margin-bottom: 10px;">
                    #         <div style="background-color: #e0e0e0; padding: 10px; border-radius: 5px; max-width: 80%; word-wrap: break-word;">
                    #             <strong>Bot 🤖:</strong> {bot_response}
                    #         </div>
                    #     </div>
                    # </div>
                    # """, unsafe_allow_html=True)
            
                    # Generate speech for the bot's response
                    bot_audio_path = generate_speech(bot_response)
            
                    # Create audio tag to play the bot's response on the webpage
                    st.audio(bot_audio_path, format="audio/mp3")
            
##################################################


if ch=="Python":
    
    
    ch2=st.selectbox("Subjects",("Choose Video Type","Video1","Video2"))
    
    if ch2=="Video1":
    
    
        st.video("P1.mp4")
        
        a=st.checkbox("💬 Chat")
        
        if a:
        
            import os
            import streamlit as st
            import google.generativeai as genai
            
            # --- Configuration ---
            genai.configure(api_key="") # Replace with your key or use environment variable
            
            # --- Generation settings ---
            generation_config = {
                "temperature": 0.7,
                "top_p": 0.95,
                "top_k": 40,
                "max_output_tokens": 2048,
                "response_mime_type": "text/plain",
            }
            
            # --- Model setup with system instruction focused on Python Q&A ---
            model = genai.GenerativeModel(
                model_name="gemini-1.5-flash",
                generation_config=generation_config,
                system_instruction="You are a Python programming expert. Answer user questions about Python clearly and accurately.",
            )
            
            # --- Initialize Chat Session ---
            if "chat_session" not in st.session_state:
                st.session_state.chat_session = model.start_chat(
                    history=[
                        {
                            "role": "user",
                            "parts": ["What is Python?"],
                        },
                        {
                            "role": "model",
                            "parts": ["Python is a high-level, general-purpose programming language known for its simplicity and readability. It's widely used in web development, data science, scripting, and more."],
                        },
                    ]
                )
            
            # --- Streamlit UI ---
            st.title("🐍 Python Assistant")
            st.markdown("Ask me anything about **Python programming**!")
            
            # Input box for user
            user_input = st.text_input("You 🧑:", "")
            
            # When user submits input
            if user_input:
                # Send input to the Gemini chat model
                response = st.session_state.chat_session.send_message(user_input)
                bot_reply = response.text
            
                # Display user message on the right
                st.markdown(f"""
                <div style="display: flex; justify-content: flex-end; margin-bottom: 10px;">
                    <div style="background-color: #fce4ec; padding: 10px; border-radius: 5px; max-width: 80%; word-wrap: break-word;">
                        <strong>You 🧑:</strong> {user_input}
                    </div>
                </div>
                """, unsafe_allow_html=True)
            
                # Display bot response on the left
                st.markdown(f"""
                <div style="display: flex; justify-content: flex-start; margin-bottom: 10px;">
                    <div style="background-color: #e0f2f1; padding: 10px; border-radius: 5px; max-width: 80%; word-wrap: break-word;">
                        <strong>Bot 🤖:</strong> {bot_reply}
                    </div>
                </div>
                """, unsafe_allow_html=True)
            
            # Optional: Exit button
            if st.button("❌ Exit"):
                st.session_state.chat_session = None
                st.experimental_rerun()
                    
         
            
        a1=st.checkbox("🎤 Speak")
        
        if a1:    
    
            import os
            import tempfile
            import streamlit as st
            import google.generativeai as genai
            import speech_recognition as sr
            from gtts import gTTS
            
            # ------------------ Configurations ------------------ #
            genai.configure(api_key="") # Replace with your Gemini API key
            
            generation_config = {
                "temperature": 1,
                "top_p": 0.95,
                "top_k": 40,
                "max_output_tokens": 8192,
                "response_mime_type": "text/plain",
            }
            
            model = genai.GenerativeModel(
                model_name="gemini-1.5-flash",
                generation_config=generation_config,
                system_instruction="You are an AI assistant answering questions about artificial intelligence. Respond concisely and clearly.",
            )
            
            # Initialize chat session (preserved across reruns)
            if "chat_session" not in st.session_state:
                st.session_state.chat_session = model.start_chat(
                    history=[
                        {
                            "role": "user",
                            "parts": ["What is artificial intelligence?"],
                        },
                        {
                            "role": "model",
                            "parts": ["Artificial intelligence (AI) refers to the simulation of human intelligence in machines. It includes learning, reasoning, perception, and language understanding."],
                        },
                    ]
                )
            
            chat_session = st.session_state.chat_session
            recognizer = sr.Recognizer()
            
            # ------------------ Voice Input Handler ------------------ #
            def listen_to_audio():
                with sr.Microphone() as source:
                    st.info("🎙️ Listening... please speak clearly")
                    recognizer.adjust_for_ambient_noise(source)
                    audio = recognizer.listen(source)
            
                try:
                    st.success("🧠 Recognizing speech...")
                    return recognizer.recognize_google(audio)
                except sr.UnknownValueError:
                    st.error("🤷 Sorry, I couldn't understand that.")
                    return ""
                except sr.RequestError:
                    st.error("❌ Could not request results from Google Speech Recognition.")
                    return ""
            
            # ------------------ Text-to-Speech Generator ------------------ #
            def generate_speech(text):
                tts = gTTS(text)
                with tempfile.NamedTemporaryFile(delete=False, suffix=".mp3") as tmpfile:
                    tts.save(tmpfile.name)
                    return tmpfile.name
            
            # ------------------ Streamlit App UI ------------------ #
            st.set_page_config(page_title="AI Voice Assistant", page_icon="🧠")
            st.title("🧠 AI Voice Assistant")
            st.markdown("Ask anything about **Artificial Intelligence** via voice!")
            
            # --- Button to listen ---
            if st.button("🎤 Start Listening"):
                user_input = listen_to_audio()
            
                if user_input:
                    # Get bot response from Gemini
                    response = chat_session.send_message(user_input)
                    bot_response = response.text
            
                    # Display user message (right)
                    st.markdown(f"""
                    <div style="display: flex; justify-content: flex-end; margin-bottom: 10px;">
                        <div style="background-color: #fce4ec; padding: 10px; border-radius: 5px; max-width: 75%; word-wrap: break-word;">
                            <strong>You 🧑:</strong> {user_input}
                        </div>
                    </div>
                    """, unsafe_allow_html=True)
            
                    # Display bot message (left)
                    st.markdown(f"""
                    <div style="display: flex; justify-content: flex-start; margin-bottom: 10px;">
                        <div style="background-color: #e0f2f1; padding: 10px; border-radius: 5px; max-width: 75%; word-wrap: break-word;">
                            <strong>Bot 🤖:</strong> {bot_response}
                        </div>
                    </div>
                    """, unsafe_allow_html=True)
            
                    # Play bot's response using TTS
                    bot_audio_path = generate_speech(bot_response)
                    st.audio(bot_audio_path, format="audio/mp3")    
                
                
    if ch2=="Video2":
    
    
        st.video("P1.mp4")
        
        a=st.checkbox("💬 Chat")
        
        if a:
        
            import os
            import streamlit as st
            import google.generativeai as genai
            
            # --- Configuration ---
            genai.configure(api_key="") # Replace with your key or use environment variable
            
            # --- Generation settings ---
            generation_config = {
                "temperature": 0.7,
                "top_p": 0.95,
                "top_k": 40,
                "max_output_tokens": 2048,
                "response_mime_type": "text/plain",
            }
            
            # --- Model setup with system instruction focused on Python Q&A ---
            model = genai.GenerativeModel(
                model_name="gemini-1.5-flash",
                generation_config=generation_config,
                system_instruction="You are a Python programming expert. Answer user questions about Python clearly and accurately.",
            )
            
            # --- Initialize Chat Session ---
            if "chat_session" not in st.session_state:
                st.session_state.chat_session = model.start_chat(
                    history=[
                        {
                            "role": "user",
                            "parts": ["What is Python?"],
                        },
                        {
                            "role": "model",
                            "parts": ["Python is a high-level, general-purpose programming language known for its simplicity and readability. It's widely used in web development, data science, scripting, and more."],
                        },
                    ]
                )
            
            # --- Streamlit UI ---
            st.title("🐍 Python Assistant")
            st.markdown("Ask me anything about **Python programming**!")
            
            # Input box for user
            user_input = st.text_input("You 🧑:", "")
            
            # When user submits input
            if user_input:
                # Send input to the Gemini chat model
                response = st.session_state.chat_session.send_message(user_input)
                bot_reply = response.text
            
                # Display user message on the right
                st.markdown(f"""
                <div style="display: flex; justify-content: flex-end; margin-bottom: 10px;">
                    <div style="background-color: #fce4ec; padding: 10px; border-radius: 5px; max-width: 80%; word-wrap: break-word;">
                        <strong>You 🧑:</strong> {user_input}
                    </div>
                </div>
                """, unsafe_allow_html=True)
            
                # Display bot response on the left
                st.markdown(f"""
                <div style="display: flex; justify-content: flex-start; margin-bottom: 10px;">
                    <div style="background-color: #e0f2f1; padding: 10px; border-radius: 5px; max-width: 80%; word-wrap: break-word;">
                        <strong>Bot 🤖:</strong> {bot_reply}
                    </div>
                </div>
                """, unsafe_allow_html=True)
            
            # Optional: Exit button
            if st.button("❌ Exit"):
                st.session_state.chat_session = None
                st.experimental_rerun()
                    
         
            
        a1=st.checkbox("🎤 Speak")
        
        if a1:    
    
            import os
            import tempfile
            import streamlit as st
            import google.generativeai as genai
            import speech_recognition as sr
            from gtts import gTTS
            
            # ------------------ Configurations ------------------ #
            genai.configure(api_key="") # Replace with your Gemini API key
            
            generation_config = {
                "temperature": 1,
                "top_p": 0.95,
                "top_k": 40,
                "max_output_tokens": 8192,
                "response_mime_type": "text/plain",
            }
            
            model = genai.GenerativeModel(
                model_name="gemini-1.5-flash",
                generation_config=generation_config,
                system_instruction="You are an AI assistant answering questions about artificial intelligence. Respond concisely and clearly.",
            )
            
            # Initialize chat session (preserved across reruns)
            if "chat_session" not in st.session_state:
                st.session_state.chat_session = model.start_chat(
                    history=[
                        {
                            "role": "user",
                            "parts": ["What is artificial intelligence?"],
                        },
                        {
                            "role": "model",
                            "parts": ["Artificial intelligence (AI) refers to the simulation of human intelligence in machines. It includes learning, reasoning, perception, and language understanding."],
                        },
                    ]
                )
            
            chat_session = st.session_state.chat_session
            recognizer = sr.Recognizer()
            
            # ------------------ Voice Input Handler ------------------ #
            def listen_to_audio():
                with sr.Microphone() as source:
                    st.info("🎙️ Listening... please speak clearly")
                    recognizer.adjust_for_ambient_noise(source)
                    audio = recognizer.listen(source)
            
                try:
                    st.success("🧠 Recognizing speech...")
                    return recognizer.recognize_google(audio)
                except sr.UnknownValueError:
                    st.error("🤷 Sorry, I couldn't understand that.")
                    return ""
                except sr.RequestError:
                    st.error("❌ Could not request results from Google Speech Recognition.")
                    return ""
            
            # ------------------ Text-to-Speech Generator ------------------ #
            def generate_speech(text):
                tts = gTTS(text)
                with tempfile.NamedTemporaryFile(delete=False, suffix=".mp3") as tmpfile:
                    tts.save(tmpfile.name)
                    return tmpfile.name
            
            # ------------------ Streamlit App UI ------------------ #
            st.set_page_config(page_title="AI Voice Assistant", page_icon="🧠")
            st.title("🧠 AI Voice Assistant")
            st.markdown("Ask anything about **Artificial Intelligence** via voice!")
            
            # --- Button to listen ---
            if st.button("🎤 Start Listening"):
                user_input = listen_to_audio()
            
                if user_input:
                    # Get bot response from Gemini
                    response = chat_session.send_message(user_input)
                    bot_response = response.text
            
                    # Display user message (right)
                    st.markdown(f"""
                    <div style="display: flex; justify-content: flex-end; margin-bottom: 10px;">
                        <div style="background-color: #fce4ec; padding: 10px; border-radius: 5px; max-width: 75%; word-wrap: break-word;">
                            <strong>You 🧑:</strong> {user_input}
                        </div>
                    </div>
                    """, unsafe_allow_html=True)
            
                    # Display bot message (left)
                    st.markdown(f"""
                    <div style="display: flex; justify-content: flex-start; margin-bottom: 10px;">
                        <div style="background-color: #e0f2f1; padding: 10px; border-radius: 5px; max-width: 75%; word-wrap: break-word;">
                            <strong>Bot 🤖:</strong> {bot_response}
                        </div>
                    </div>
                    """, unsafe_allow_html=True)
            
                    # Play bot's response using TTS
                    bot_audio_path = generate_speech(bot_response)
                    st.audio(bot_audio_path, format="audio/mp3")