Update app.py

app.py

@@ -3,11 +3,14 @@ from transformers import AutoTokenizer, AutoModelForQuestionAnswering
 import torch
 import logging
 import warnings
-from typing import List, Tuple, Dict
+from typing import List, Tuple, Dict, Optional
 import random
 from datetime import datetime
 from dataclasses import dataclass
 from enum import Enum
+from difflib import SequenceMatcher
+import numpy as np
+import re
 
 logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
@@ -29,6 +32,96 @@ class BiblicalExample:
     base_response: str
     application: str
     sentiment: str
+    keywords: List[str] = None
+    theme: str = ""
+
+    def __post_init__(self):
+        if self.keywords is None:
+            self.keywords = self.extract_keywords()
+
+    def extract_keywords(self) -> List[str]:
+        """Extract meaningful keywords from question and response."""
+        text = f"{self.question} {self.base_response}"
+        words = text.lower().split()
+        # Remove common Portuguese stop words
+        stop_words = {'a', 'o', 'e', 'de', 'do', 'da', 'em', 'para', 'com', 'um', 'uma'}
+        keywords = [word for word in words if len(word) > 3 and word not in stop_words]
+        return list(set(keywords))
+
+class TextProcessor:
+    @staticmethod
+    def normalize_text(text: str) -> str:
+        """Normalize text by removing special characters and extra spaces."""
+        text = re.sub(r'[^\w\s]', ' ', text)
+        text = ' '.join(text.lower().split())
+        return text
+
+    @staticmethod
+    def extract_main_concepts(text: str) -> List[str]:
+        """Extract main concepts from text using basic NLP techniques."""
+        # Remove common words and keep meaningful terms
+        stop_words = {'a', 'o', 'e', 'de', 'do', 'da', 'em', 'para', 'com', 'um', 'uma', 'que', 'como'}
+        words = TextProcessor.normalize_text(text).split()
+        concepts = [word for word in words if word not in stop_words and len(word) > 3]
+        return list(set(concepts))
+
+class ResponseValidator:
+    def __init__(self):
+        self.text_processor = TextProcessor()
+        self.similarity_threshold = 0.3
+        self.keyword_threshold = 0.2
+        self.concept_match_threshold = 0.25
+
+    def calculate_text_similarity(self, text1: str, text2: str) -> float:
+        """Calculate text similarity using SequenceMatcher."""
+        normalized_text1 = self.text_processor.normalize_text(text1)
+        normalized_text2 = self.text_processor.normalize_text(text2)
+        return SequenceMatcher(None, normalized_text1, normalized_text2).ratio()
+
+    def calculate_keyword_similarity(self, text1: str, text2: str) -> float:
+        """Calculate keyword similarity between texts."""
+        keywords1 = set(self.text_processor.extract_main_concepts(text1))
+        keywords2 = set(self.text_processor.extract_main_concepts(text2))
+        if not keywords1 or not keywords2:
+            return 0.0
+        return len(keywords1.intersection(keywords2)) / len(keywords1.union(keywords2))
+
+    def calculate_concept_similarity(self, question: str, example: BiblicalExample) -> float:
+        """Calculate concept similarity between question and example."""
+        question_concepts = set(self.text_processor.extract_main_concepts(question))
+        example_concepts = set(example.keywords)
+        if not question_concepts or not example_concepts:
+            return 0.0
+        return len(question_concepts.intersection(example_concepts)) / len(question_concepts.union(example_concepts))
+
+    def validate_response(self, question: str, example: BiblicalExample) -> Tuple[bool, Dict[str, float]]:
+        """Validate response relevance using multiple metrics."""
+        text_similarity = self.calculate_text_similarity(question, example.question)
+        keyword_similarity = self.calculate_keyword_similarity(question, example.question)
+        concept_similarity = self.calculate_concept_similarity(question, example)
+
+        # Calculate weighted score
+        weights = {'text': 0.4, 'keyword': 0.3, 'concept': 0.3}
+        total_score = (
+            text_similarity * weights['text'] +
+            keyword_similarity * weights['keyword'] +
+            concept_similarity * weights['concept']
+        )
+
+        metrics = {
+            'text_similarity': round(text_similarity, 3),
+            'keyword_similarity': round(keyword_similarity, 3),
+            'concept_similarity': round(concept_similarity, 3),
+            'total_score': round(total_score, 3)
+        }
+
+        is_valid = (
+            text_similarity >= self.similarity_threshold or
+            keyword_similarity >= self.keyword_threshold or
+            concept_similarity >= self.concept_match_threshold
+        )
+
+        return is_valid, metrics
 
 class SapienciaBiblica:
     def __init__(self):
@@ -37,6 +130,7 @@ class SapienciaBiblica:
         self.model_name = "pierreguillou/bert-base-cased-squad-v1.1-portuguese"
         self.session_history = []
         self.biblical_examples = self.get_default_examples_dict()
+        self.validator = ResponseValidator()
         self.setup_model()
 
     def setup_model(self):
@@ -57,109 +151,36 @@ class SapienciaBiblica:
                     passage="Efésios 4:29",
                     text="Não saia da vossa boca nenhuma palavra torpe, mas só a que for boa para promover a edificação, para que dê graça aos que a ouvem.",
                     base_response="A comunicação efetiva no casamento requer sabedoria, paciência e amor. A Bíblia nos ensina a usar palavras que edificam e não destroem.",
-                    application="Pratique escuta ativa, escolha momentos adequados para conversas importantes.",
-                    sentiment="supportive"
+                    application="Pratique escuta ativa, escolha momentos adequados para conversas importantes, e sempre fale com amor e respeito.",
+                    sentiment="supportive",
+                    theme="casamento"
                 ),
                 BiblicalExample(
-                    question="Como resolver conflitos no casamento?",
-                    passage="Efésios 4:26-32",
-                    text="Não se ponha o sol sobre a vossa ira. Não deis lugar ao diabo.",
-                    base_response="Resolva os conflitos rapidamente, não permita que a raiva se acumule.",
-                    application="Resolução diária de conflitos e perdão mútuo.",
-                    sentiment="instructive"
+                    question="Como lidar com conflitos no casamento?",
+                    passage="Efésios 4:26-27",
+                    text="Irai-vos e não pequeis; não se ponha o sol sobre a vossa ira. Não deis lugar ao diabo.",
+                    base_response="Os conflitos são naturais, mas devem ser resolvidos com sabedoria e amor, sem deixar que a raiva tome conta.",
+                    application="Resolva os conflitos no mesmo dia, pratique o perdão e busque entender o ponto de vista do cônjuge.",
+                    sentiment="instructive",
+                    theme="casamento"
                 )
             ],
             "familia": [
                 BiblicalExample(
-                    question="Como criar filhos segundo a Bíblia?",
+                    question="Como educar filhos segundo a Bíblia?",
                     passage="Provérbios 22:6",
                     text="Instrui o menino no caminho em que deve andar, e até quando envelhecer não se desviará dele.",
-                    base_response="A criação dos filhos requer dedicação e instrução consistente.",
-                    application="Estabeleça momentos diários de devocional em família.",
-                    sentiment="instructive"
-                )
-            ],
-            "vida_espiritual": [
-                BiblicalExample(
-                    question="Como desenvolver uma vida de oração?",
-                    passage="1 Tessalonicenses 5:17",
-                    text="Orai sem cessar.",
-                    base_response="A vida de oração se desenvolve através da prática constante.",
-                    application="Reserve um tempo diário para oração.",
-                    sentiment="spiritual"
-                )
-            ],
-            "trabalho": [
-                BiblicalExample(
-                    question="Como ter integridade no trabalho?",
-                    passage="Colossenses 3:23",
-                    text="E tudo quanto fizerdes, fazei-o de coração, como ao Senhor.",
-                    base_response="Trabalhe com excelência e integridade como para o Senhor.",
-                    application="Pratique ética e dedicação no trabalho.",
-                    sentiment="professional"
+                    base_response="A educação dos filhos deve ser baseada em princípios bíblicos, com amor, disciplina e exemplo.",
+                    application="Estabeleça rotinas de devocional em família, seja exemplo de caráter e aplique disciplina com amor.",
+                    sentiment="instructive",
+                    theme="familia"
                 )
             ],
-            "relacionamentos": [
-                BiblicalExample(
-                    question="Como construir amizades verdadeiras?",
-                    passage="Provérbios 17:17",
-                    text="Em todo tempo ama o amigo, e na angústia nasce o irmão.",
-                    base_response="Amizades verdadeiras são construídas com amor e lealdade.",
-                    application="Seja presente e fiel nas amizades.",
-                    sentiment="friendly"
-                )
-            ],
-            "geral": [
-                BiblicalExample(
-                    question="Como encontrar paz em tempos difíceis?",
-                    passage="João 14:27",
-                    text="Deixo-vos a paz, a minha paz vos dou.",
-                    base_response="A verdadeira paz vem de Deus e permanece nas tribulações.",
-                    application="Confie em Deus em todas as circunstâncias.",
-                    sentiment="comforting"
-                )
-            ]
+            # Add more categories and examples as needed
         }
 
-    def get_examples_for_interface(self) -> List[List[str]]:
-        examples = []
-        for theme in self.biblical_examples:
-            for example in self.biblical_examples[theme]:
-                examples.append([theme, example.question])
-        return examples
-
-    def get_verse_of_day(self) -> str:
-        verses = [
-            ("João 3:16", "Porque Deus amou o mundo de tal maneira que deu o seu Filho unigênito..."),
-            ("Salmos 23:1", "O Senhor é meu pastor e nada me faltará."),
-            ("Filipenses 4:13", "Posso todas as coisas em Cristo que me fortalece."),
-            ("Jeremias 29:11", "Porque eu bem sei os pensamentos que tenho a vosso respeito...")
-        ]
-        verse = random.choice(verses)
-        return f"📖 Versículo do Dia:\n{verse[0]}\n\n{verse[1]}"
-
-    def get_daily_prayer_focus(self) -> str:
-        focuses = [
-            "Gratidão e Louvor",
-            "Família e Relacionamentos",
-            "Sabedoria e Direção",
-            "Paz e Serenidade",
-            "Cura e Restauração"
-        ]
-        focus = random.choice(focuses)
-        return f"🙏 Foco de Oração:\n{focus}"
-
-    def analyze_sentiment(self, text: str) -> str:
-        positive_words = {'alegria', 'esperança', 'paz', 'amor', 'gratidão', 'feliz', 'bem'}
-        negative_words = {'tristeza', 'medo', 'ansiedade', 'preocupação', 'angústia', 'mal', 'dor'}
-        
-        text_words = set(text.lower().split())
-        pos_count = len(text_words.intersection(positive_words))
-        neg_count = len(text_words.intersection(negative_words))
-        
-        return 'positive' if pos_count > neg_count else 'negative' if neg_count > pos_count else 'neutral'
-
     def find_best_theme(self, question: str) -> str:
+        """Find the most relevant theme for the question."""
         question = question.lower()
         theme_keywords = {
             "casamento": ["casamento", "cônjuge", "esposa", "marido", "casal"],
@@ -169,26 +190,73 @@ class SapienciaBiblica:
             "relacionamentos": ["amizade", "relacionamento", "conflito", "perdão"],
         }
         
+        max_matches = 0
+        best_theme = "geral"
+        
         for theme, keywords in theme_keywords.items():
-            if any(keyword in question for keyword in keywords):
-                return theme
-        return "geral"
+            matches = sum(1 for keyword in keywords if keyword in question)
+            if matches > max_matches:
+                max_matches = matches
+                best_theme = theme
+        
+        return best_theme
+
+    def find_best_example(self, question: str, theme: str) -> Tuple[Optional[BiblicalExample], Dict[str, float]]:
+        """Find the most relevant example and return validation metrics."""
+        examples = self.biblical_examples.get(theme, self.biblical_examples["geral"])
+        best_score = 0
+        best_example = None
+        best_metrics = {}
+        
+        for example in examples:
+            is_valid, metrics = self.validator.validate_response(question, example)
+            
+            if is_valid and metrics['total_score'] > best_score:
+                best_score = metrics['total_score']
+                best_example = example
+                best_metrics = metrics
+        
+        return best_example, best_metrics
 
     def get_unique_response(self, question: str, theme: str = None) -> Tuple[str, Dict, str]:
+        """Get a validated response for the given question."""
+        if not question.strip():
+            return "Por favor, faça uma pergunta específica.", {}, self.format_history()
+            
         if not theme or theme not in self.biblical_examples:
             theme = self.find_best_theme(question)
-            
-        examples = self.biblical_examples[theme]
-        example = random.choice(examples)
-        sentiment = self.analyze_sentiment(question)
         
-        response = self.format_response(example, sentiment)
-        metadata = self.create_metadata(example, theme)
+        best_example, validation_metrics = self.find_best_example(question, theme)
+        
+        if not best_example:
+            response = self.generate_fallback_response(question, theme)
+            metadata = {
+                "theme": theme,
+                "status": "no_matching_example",
+                "validation_metrics": validation_metrics
+            }
+            return response, metadata, self.format_history()
+        
+        sentiment = self.analyze_sentiment(question)
+        response = self.format_response(best_example, sentiment)
+        metadata = self.create_metadata(best_example, theme, validation_metrics)
         history = self.save_to_history(question, theme, response, metadata)
         
         return response, metadata, history
 
+    def analyze_sentiment(self, text: str) -> str:
+        """Analyze the sentiment of the input text."""
+        positive_words = {'alegria', 'esperança', 'paz', 'amor', 'gratidão', 'feliz', 'bem'}
+        negative_words = {'tristeza', 'medo', 'ansiedade', 'preocupação', 'angústia', 'mal', 'dor'}
+        
+        text_words = set(text.lower().split())
+        pos_count = len(text_words.intersection(positive_words))
+        neg_count = len(text_words.intersection(negative_words))
+        
+        return 'positive' if pos_count > neg_count else 'negative' if neg_count > pos_count else 'neutral'
+
     def format_response(self, example: BiblicalExample, sentiment: str) -> str:
+        """Format the response with appropriate introduction based on sentiment."""
         intro = {
             'positive': "Que bom que você está buscando orientação! ",
             'negative': "Entendo seu momento e estou aqui para ajudar. ",
@@ -210,15 +278,47 @@ Esta orientação é baseada em princípios bíblicos. Para questões específic
 considere consultar sua liderança espiritual local.
 """
 
-    def create_metadata(self, example: BiblicalExample, theme: str) -> Dict:
+    def generate_fallback_response(self, question: str, theme: str) -> str:
+        """Generate a thoughtful fallback response when no good match is found."""
+        theme_verses = {
+            "casamento": ("Efésios 5:25", "Maridos, amai vossas mulheres, como também Cristo amou a igreja..."),
+            "familia": ("Salmos 127:3", "Eis que os filhos são herança do Senhor..."),
+            "vida_espiritual": ("Filipenses 4:6", "Não andeis ansiosos por coisa alguma..."),
+            "trabalho": ("Colossenses 3:23", "E tudo quanto fizerdes, fazei-o de coração..."),
+            "relacionamentos": ("João 13:34", "Um novo mandamento vos dou: Que vos ameis uns aos outros..."),
+            "geral": ("Provérbios 3:5-6", "Confia no Senhor de todo o teu coração...")
+        }
+        
+        verse = theme_verses.get(theme, theme_verses["geral"])
+        
+        return f"""
+🤔 Compreendo sua busca por orientação sobre {theme}...
+
+Para melhor atendê-lo, considere reformular sua pergunta de forma mais específica, 
+mencionando detalhes da situação que você gostaria de abordar.
+
+📖 Enquanto isso, reflita sobre esta passagem:
+{verse[0]}: "{verse[1]}"
+
+🙏 Lembre-se: 
+"Porque o SENHOR dá a sabedoria, e da sua boca vem o conhecimento e o entendimento." 
+- Provérbios 2:6
+"""
+
+    def create_metadata(self, example: BiblicalExample, theme: str, validation_metrics: Dict[str, float]) -> Dict:
+        """Create comprehensive metadata for the response."""
         return {
-            "passagem": example.passage,
-            "tema": theme,
-            "aplicacao": example.application,
-            "contexto": "Baseado em princípios bíblicos"
+            "theme": theme,
+            "passage": example.passage,
+            "application": example.application,
+            "sentiment": example.sentiment,
+            "validation_metrics": validation_metrics,
+            "keywords_matched": example.keywords,
+            "response_quality": "high" if validation_metrics['total_score'] > 0.6 else "medium" if validation_metrics['total_score'] > 0.4 else "low"
         }
 
     def save_to_history(self, question: str, theme: str, response: str, metadata: Dict) -> str:
+        """Save interaction to history and return formatted history."""
         self.session_history.append({
             "timestamp": datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
             "theme": theme,
@@ -229,17 +329,52 @@ considere consultar sua liderança espiritual local.
         return self.format_history()
 
     def format_history(self) -> str:
+        """Format the session history for display."""
         if not self.session_history:
             return "Nenhuma consulta realizada ainda."
             
         history_text = "📚 Histórico de Consultas:\n\n"
-        for entry in reversed(self.session_history[-5:]):
+        for entry in reversed(self.session_history[-5:]):  # Show last 5 entries
             history_text += f"🕒 {entry['timestamp']}\n"
             history_text += f"📌 Tema: {entry['theme']}\n"
             history_text += f"❓ Pergunta: {entry['question']}\n"
+            if 'validation_metrics' in entry['metadata']:
+                history_text += f"📊 Relevância: {entry['metadata']['validation_metrics']['total_score']:.2f}\n"
             history_text += "─" * 40 + "\n"
         return history_text
 
+    def get_verse_of_day(self) -> str:
+        """Get a random verse of the day."""
+        verses = [
+            ("João 3:16", "Porque Deus amou o mundo de tal maneira que deu o seu Filho unigênito, para que todo aquele que nele crê não pereça, mas tenha a vida eterna."),
+            ("Salmos 23:1", "O Senhor é meu pastor e nada me faltará."),
+            ("Filipenses 4:13", "Posso todas as coisas em Cristo que me fortalece."),
+            ("Jeremias 29:11", "Porque eu bem sei os pensamentos que tenho a vosso respeito, diz o Senhor; pensamentos de paz, e não de mal, para vos dar o fim que esperais."),
+            ("Provérbios 3:5-6", "Confia no Senhor de todo o teu coração, e não te estribes no teu próprio entendimento. Reconhece-o em todos os teus caminhos, e ele endireitará as tuas veredas.")
+        ]
+        verse = random.choice(verses)
+        return f"📖 Versículo do Dia:\n{verse[0]}\n\n{verse[1]}"
+
+    def get_daily_prayer_focus(self) -> str:
+        """Get a random prayer focus for the day."""
+        focuses = [
+            ("Gratidão e Louvor", "Agradecer a Deus por suas bênçãos e manifestar louvor"),
+            ("Família e Relacionamentos", "Orar pela harmonia e proteção familiar"),
+            ("Sabedoria e Direção", "Buscar orientação divina para decisões"),
+            ("Paz e Serenidade", "Cultivar a paz interior e confiar em Deus"),
+            ("Cura e Restauração", "Buscar a cura emocional e espiritual")
+        ]
+        focus = random.choice(focuses)
+        return f"🙏 Foco de Oração:\n{focus[0]}\n{focus[1]}"
+
+    def get_examples_for_interface(self) -> List[List[str]]:
+        """Get formatted examples for the Gradio interface."""
+        examples = []
+        for theme in self.biblical_examples:
+            for example in self.biblical_examples[theme]:
+                examples.append([theme, example.question])
+        return examples
+
 def create_interface():
     counselor = SapienciaBiblica()
 
@@ -300,7 +435,7 @@ def create_interface():
                         interactive=False
                     )
 
-        # Exemplos para a interface
+        # Examples for the interface
         gr.Examples(
             examples=counselor.get_examples_for_interface(),
             inputs=[theme, question],