Add application file

main.py

@@ -0,0 +1,406 @@
+import os
+import speech_recognition as sr
+import difflib
+import time
+from langchain_groq.chat_models import ChatGroq
+from dotenv import load_dotenv
+import tempfile
+import gradio as gr
+
+# Load environment variables
+load_dotenv()
+
+class PronunciaPratica:
+    def __init__(self, idioma='pt-BR'):
+        """
+        Initializes the pronunciation practice application.
+        
+        Args:
+            idioma (str): Language code for speech recognition (e.g., 'pt-BR', 'en-US')
+        """
+        self.idioma = idioma
+        self.recognizer = sr.Recognizer()
+        
+        # Configure the Groq client using an environment variable
+        api_key = os.getenv("GROQ_API_KEY")
+        if not api_key:
+            raise ValueError("⚠️ Groq API key not found. Set the GROQ_API_KEY environment variable.")
+        
+        self.chat = ChatGroq(model="llama-3.1-8b-instant", api_key=api_key)
+        
+    def gerar_frase(self):
+        """Generate a random phrase for pronunciation practice."""
+        try:
+            # Map language code to language name for better prompt
+            language_map = {
+                'pt-BR': 'português',
+                'en-US': 'inglês',
+                'es-ES': 'espanhol',
+                'fr-FR': 'francês',
+                'it-IT': 'italiano',
+                'de-DE': 'alemão'
+            }
+            
+            language_name = language_map.get(self.idioma, 'português')
+            
+            # Create a more explicit prompt that specifies the language
+            prompt = f"""
+            Forneça uma frase curta em {language_name} para treinar pronúncia.
+            A frase deve ter entre 5 e 10 palavras.
+            Responda APENAS com a frase em {language_name}, sem explicações.
+            É MUITO IMPORTANTE que a frase seja apenas em {language_name} e não em qualquer outro idioma.
+            """
+            
+            resposta = self.chat.invoke([{
+                "role": "system", 
+                "content": prompt
+            }])
+            
+            return resposta.content.strip()
+        except Exception as e:
+            # Default phrases based on language
+            default_phrases = {
+                'pt-BR': "O sol está brilhando hoje.",
+                'en-US': "The sun is shining today.",
+                'es-ES': "El sol está brillando hoy.",
+                'fr-FR': "Le soleil brille aujourd'hui.",
+                'it-IT': "Il sole splende oggi.",
+                'de-DE': "Die Sonne scheint heute."
+            }
+            return f"{default_phrases.get(self.idioma, 'O sol está brilhando hoje.')} (Erro: {str(e)})"
+    
+    def reconhecer_audio(self, audio_path):
+        """Convert recorded audio to text."""
+        try:
+            # Load the audio file
+            with sr.AudioFile(audio_path) as source:
+                audio_data = self.recognizer.record(source)
+                
+            # Recognize the text
+            texto_falado = self.recognizer.recognize_google(audio_data, language=self.idioma)
+            return texto_falado
+        except sr.UnknownValueError:
+            return "Erro: Não foi possível entender o áudio."
+        except sr.RequestError as e:
+            return f"Erro: Problema na requisição do serviço de reconhecimento. {e}"
+        except Exception as e:
+            return f"Erro: {e}"
+    
+    def avaliar_pronuncia(self, frase_original, frase_falada):
+        """
+        Evaluate the similarity between the original phrase and the spoken phrase.
+        
+        Returns:
+            tuple: (similarity percentage, incorrect words)
+        """
+        # Normalize phrases (remove punctuation and convert to lowercase)
+        import re
+        normalizar = lambda texto: re.sub(r'[^\w\s]', '', texto.lower())
+        
+        original_norm = normalizar(frase_original)
+        falada_norm = normalizar(frase_falada)
+        
+        # Calculate similarity
+        sequencia = difflib.SequenceMatcher(None, original_norm, falada_norm)
+        similaridade = sequencia.ratio() * 100
+        
+        # Identify incorrect words
+        palavras_originais = original_norm.split()
+        palavras_faladas = falada_norm.split()
+        
+        palavras_incorretas = []
+        for palavra in palavras_originais:
+            if palavra not in palavras_faladas:
+                palavras_incorretas.append(palavra)
+                
+        return similaridade, palavras_incorretas
+    
+    def obter_feedback(self, similaridade, palavras_incorretas, frase_original, frase_falada):
+        """Generate detailed feedback on pronunciation."""
+        # Determine language for feedback based on idioma
+        feedback_lang = self.idioma
+        
+        # Choose appropriate language for the feedback prompt
+        if feedback_lang.startswith('pt'):
+            prompt_template = """
+            Analise a pronúncia do usuário e forneça feedback específico:
+            
+            Frase original: "{frase_original}"
+            Frase falada: "{frase_falada}"
+            Similaridade: {similaridade:.2f}%
+            Palavras possivelmente problemáticas: {palavras_prob}
+            
+            Ofereça dicas específicas para melhorar a pronúncia, focando nos erros mais comuns.
+            Seja breve e construtivo, máximo de 3 linhas.
+            """
+            palavras_prob = ', '.join(palavras_incorretas) if palavras_incorretas else 'Nenhuma'
+        elif feedback_lang.startswith('en'):
+            prompt_template = """
+            Analyze the user's pronunciation and provide specific feedback:
+            
+            Original phrase: "{frase_original}"
+            Spoken phrase: "{frase_falada}"
+            Similarity: {similaridade:.2f}%
+            Potentially problematic words: {palavras_prob}
+            
+            Offer specific tips to improve pronunciation, focusing on the most common errors.
+            Be brief and constructive, maximum of 3 lines.
+            """
+            palavras_prob = ', '.join(palavras_incorretas) if palavras_incorretas else 'None'
+        else:
+            # Default to English for other languages
+            prompt_template = """
+            Analyze the user's pronunciation and provide specific feedback:
+            
+            Original phrase: "{frase_original}"
+            Spoken phrase: "{frase_falada}"
+            Similarity: {similaridade:.2f}%
+            Potentially problematic words: {palavras_prob}
+            
+            Offer specific tips to improve pronunciation, focusing on the most common errors.
+            Be brief and constructive, maximum of 3 lines.
+            """
+            palavras_prob = ', '.join(palavras_incorretas) if palavras_incorretas else 'None'
+            
+        prompt = prompt_template.format(
+            frase_original=frase_original,
+            frase_falada=frase_falada,
+            similaridade=similaridade,
+            palavras_prob=palavras_prob
+        )
+        
+        try:
+            resposta = self.chat.invoke([{"role": "system", "content": prompt}])
+            return resposta.content.strip()
+        except Exception as e:
+            # Default feedback in case of error, based on language
+            if feedback_lang.startswith('pt'):
+                if similaridade > 90:
+                    return "Excelente pronúncia! Continue praticando."
+                elif similaridade > 70:
+                    return f"Boa pronúncia, mas pode melhorar. Preste atenção em: {', '.join(palavras_incorretas)}"
+                else:
+                    return "Tente novamente, focando na pronúncia clara de cada palavra."
+            else:
+                if similaridade > 90:
+                    return "Excellent pronunciation! Keep practicing."
+                elif similaridade > 70:
+                    return f"Good pronunciation, but can be improved. Pay attention to: {', '.join(palavras_incorretas)}"
+                else:
+                    return "Try again, focusing on clear pronunciation of each word."
+
+# Function to map language dropdown to language code
+def get_language_code(language_name):
+    idiomas = {
+        "Português (Brasil)": "pt-BR",
+        "Inglês (EUA)": "en-US", 
+        "Espanhol": "es-ES",
+        "Francês": "fr-FR",
+        "Italiano": "it-IT",
+        "Alemão": "de-DE"
+    }
+    return idiomas.get(language_name, "pt-BR")
+
+# Create a global instance of the app
+app_instance = None
+
+# Track the current language
+current_language_code = "pt-BR"
+
+# Functions for Gradio interface
+def gerar_nova_frase(language_name):
+    global app_instance, current_language_code
+    language_code = get_language_code(language_name)
+    
+    # Only create a new instance if the language has changed
+    if app_instance is None or current_language_code != language_code:
+        app_instance = PronunciaPratica(idioma=language_code)
+        current_language_code = language_code
+    
+    return app_instance.gerar_frase()
+
+def process_audio(audio_path, frase_atual, language_name, historico):
+    global app_instance, current_language_code
+    
+    if audio_path is None:
+        return "Nenhum áudio gravado", "", 0, "", historico, ""
+    
+    # Make sure we have an app instance with the current language
+    language_code = get_language_code(language_name)
+    if app_instance is None or current_language_code != language_code:
+        app_instance = PronunciaPratica(idioma=language_code)
+        current_language_code = language_code
+    
+    # Recognize the speech
+    texto_falado = app_instance.reconhecer_audio(audio_path)
+    
+    if texto_falado.startswith("Erro"):
+        return texto_falado, "", 0, "", historico, ""
+    
+    # Evaluate pronunciation
+    similaridade, palavras_incorretas = app_instance.avaliar_pronuncia(frase_atual, texto_falado)
+    
+    # Get detailed feedback
+    feedback = app_instance.obter_feedback(similaridade, palavras_incorretas, frase_atual, texto_falado)
+    
+    # Add to history
+    entry = {
+        "frase": frase_atual,
+        "falado": texto_falado,
+        "similaridade": f"{similaridade:.1f}%",
+        "feedback": feedback,
+        "timestamp": time.strftime("%H:%M:%S")
+    }
+    
+    historico = [entry] + historico
+    if len(historico) > 5:
+        historico = historico[:5]
+    
+    # Modificação aqui para melhorar a visibilidade do histórico
+    history_html = ""
+    for entry in historico:
+        history_html += f"""
+        <div class="history-entry">
+            <b>{entry['timestamp']}</b> - Precisão: {entry['similaridade']}<br>
+            <b>Original:</b> "{entry['frase']}"<br>
+            <b>Sua fala:</b> "{entry['falado']}"<br>
+            <b>Feedback:</b> {entry['feedback']}
+        </div>
+        """
+    
+    return texto_falado, f"{similaridade:.1f}%", similaridade, feedback, historico, history_html
+
+def initialize_app_and_get_phrase(language_name="Português (Brasil)"):
+    """Initialize the app with a specific language and get first phrase"""
+    global app_instance, current_language_code
+    
+    language_code = get_language_code(language_name)
+    app_instance = PronunciaPratica(idioma=language_code)
+    current_language_code = language_code
+    
+    return app_instance.gerar_frase()
+
+def main():
+    # Get initial phrase (will also initialize app_instance)
+    initial_phrase = initialize_app_and_get_phrase()
+    
+    # CSS for styling 
+    css = """
+    .gradio-container {
+        font-family: 'Helvetica Neue', Arial, sans-serif;
+    }
+    .phrase-box {
+        background-color: #828181;
+        padding: 20px;
+        border-radius: 10px;
+        border-left: 5px solid #1e3d59;
+        font-size: 22px;
+        margin: 20px 0;
+    }
+    .spoken-box {
+        background-color: #e6f7ff;
+        padding: 15px;
+        border-radius: 10px;
+        border-left: 5px solid #0074cc;
+    }
+    .score-display {
+        font-size: 36px;
+        font-weight: bold;
+        text-align: center;
+    }
+    .feedback-box {
+        background-color: #e8f4ea;
+        padding: 15px;
+        border-radius: 10px;
+        border-left: 5px solid #4CAF50;
+    }
+    .history-entry {
+        margin-bottom: 15px;
+        padding: 10px;
+        border-left: 3px solid #4CAF50;
+        background-color: #2a2a2a;
+        color: white;
+        border-radius: 8px;
+    }
+    """
+    
+    with gr.Blocks(css=css) as demo:
+        gr.Markdown("# 🎤 Pronúncia Prática")
+        gr.Markdown("### Melhore sua pronúncia com feedback em tempo real")
+        
+        with gr.Row():
+            with gr.Column(scale=2):
+                idioma_dropdown = gr.Dropdown(
+                    choices=["Português (Brasil)", "Inglês (EUA)", "Espanhol", "Francês", "Italiano", "Alemão"],
+                    value="Português (Brasil)",
+                    label="Selecione o idioma para praticar:"
+                )
+            
+            with gr.Column(scale=1):
+                gerar_frase_btn = gr.Button("🔄 Gerar nova frase")
+        
+        frase_atual = gr.Textbox(
+            value=initial_phrase,
+            label="Frase para praticar:",
+            elem_classes=["phrase-box"]
+        )
+        
+        with gr.Row():
+            audio_input = gr.Audio(
+                sources=["microphone"],
+                type="filepath",
+                label="🎙️ Grave sua voz"
+            )
+        
+        with gr.Row():
+            texto_reconhecido = gr.Textbox(label="Você disse:")
+        
+        with gr.Row():
+            score_text = gr.Textbox(label="Pontuação:")
+            score_progress = gr.Slider(minimum=0, maximum=100, label="", interactive=False)
+        
+        feedback_box = gr.Textbox(label="Feedback:")
+        
+        # Hidden state for history
+        historico_state = gr.State([])
+        
+        with gr.Accordion("📜 Histórico de Prática", open=False):
+            history_display = gr.HTML()
+        
+        # Event handlers
+        gerar_frase_btn.click(
+            fn=gerar_nova_frase,
+            inputs=[idioma_dropdown],
+            outputs=[frase_atual]
+        )
+        
+        idioma_dropdown.change(
+            fn=gerar_nova_frase,
+            inputs=[idioma_dropdown],
+            outputs=[frase_atual]
+        )
+        
+        audio_input.change(
+            fn=process_audio,
+            inputs=[audio_input, frase_atual, idioma_dropdown, historico_state],
+            outputs=[texto_reconhecido, score_text, score_progress, feedback_box, historico_state, history_display]
+        )
+        
+        # Instructions in the footer
+        gr.Markdown("""
+        ### 📝 Como usar:
+        1. Selecione o idioma que deseja praticar
+        2. Clique em 'Gerar nova frase' para mudar a frase (opcional)
+        3. Leia a frase em voz alta
+        4. Clique no botão de microfone e fale a frase
+        5. Veja o feedback e sua pontuação
+        
+        ---
+        Desenvolvido com ❤️ usando Gradio e IA
+        """)
+    
+    # Launch the app with share=True to create a shareable link
+    demo.launch(share=True, server_name="0.0.0.0")
+
+if __name__ == "__main__":
+    main()