Update app.py

app.py

@@ -1,177 +1,226 @@
-# app.py
 import gradio as gr
-from transformers import AutoModelForCausalLM, AutoTokenizer, pipeline
+from transformers import pipeline
 import json
-import os
 import sqlite3
 from datetime import datetime, timedelta
 import pandas as pd
+import random
 from typing import Dict, List, Optional
+from performance_system import PerformanceAnalyzer
+from simulado_system import SimuladoSystem, CasoClinicoSystem
+from database.db_manager import RevalidaDatabase
+from performance_system import PerformanceAnalyzer, StudyMaterialGenerator, ProgressTracker
 
-class RevalidaDatabase:
-    def __init__(self):
-        self.conn = sqlite3.connect('revalida.db')
-        self.create_tables()
-        self.load_previous_questions()
+class MotivationalCoach:
+    """Classe para gerenciar mensagens e estratégias motivacionais"""
     
-    def create_tables(self):
-        """Cria tabelas necessárias"""
-        self.conn.execute('''
-        CREATE TABLE IF NOT EXISTS users (
-            user_id TEXT PRIMARY KEY,
-            name TEXT,
-            study_hours INTEGER,
-            start_date DATE,
-            target_date DATE,
-            weak_areas TEXT
-        )''')
-        
-        self.conn.execute('''
-        CREATE TABLE IF NOT EXISTS study_progress (
-            user_id TEXT,
-            date DATE,
-            topic TEXT,
-            hours_studied FLOAT,
-            questions_answered INTEGER,
-            performance_score FLOAT,
-            FOREIGN KEY (user_id) REFERENCES users(user_id)
-        )''')
-        
-        self.conn.execute('''
-        CREATE TABLE IF NOT EXISTS previous_questions (
-            id INTEGER PRIMARY KEY,
-            year INTEGER,
-            area TEXT,
-            question_text TEXT,
-            options TEXT,
-            correct_answer TEXT,
-            explanation TEXT
-        )''')
+    def __init__(self):
+        self.frases_motivacionais = [
+            "🌟 Cada hora de estudo te aproxima mais do seu objetivo!",
+            "💪 Você está construindo seu futuro a cada dia!",
+            "🎯 Mantenha o foco! O Revalida é só uma etapa da sua jornada de sucesso!",
+            "⭐ Sua dedicação é inspiradora! Continue assim!",
+            "🌈 Acredite no seu potencial! Você está no caminho certo!",
+            "📚 Conhecimento é poder, e você está ficando mais forte a cada dia!",
+            "🌅 Um novo dia, uma nova oportunidade de aprender!",
+            "🎓 Sua aprovação no Revalida está cada vez mais próxima!"
+        ]
         
-        self.conn.commit()
-    
-    def load_previous_questions(self):
-        """Carrega questões de provas anteriores do arquivo JSON"""
-        try:
-            with open('previous_questions.json', 'r', encoding='utf-8') as f:
-                questions = json.load(f)
-                cursor = self.conn.cursor()
-                for q in questions:
-                    cursor.execute('''
-                    INSERT OR IGNORE INTO previous_questions 
-                    (year, area, question_text, options, correct_answer, explanation)
-                    VALUES (?, ?, ?, ?, ?, ?)
-                    ''', (q['year'], q['area'], q['question_text'], 
-                         json.dumps(q['options']), q['correct_answer'], q['explanation']))
-                self.conn.commit()
-        except Exception as e:
-            print(f"Erro ao carregar questões: {e}")
+        self.dicas_estudo = [
+            "📌 Faça pequenas pausas a cada 45 minutos de estudo",
+            "💡 Revise o conteúdo do dia antes de dormir",
+            "🎯 Estabeleça metas diárias pequenas e alcançáveis",
+            "📊 Alterne entre diferentes tópicos para manter o interesse",
+            "🌟 Pratique questões antigas do Revalida regularmente",
+            "💪 Mantenha uma rotina regular de estudos",
+            "🧠 Use mapas mentais para conectar conceitos",
+            "📝 Faça resumos ativos do conteúdo estudado"
+        ]
+
+    def get_motivational_message(self) -> str:
+        return random.choice(self.frases_motivacionais)
+
+    def get_study_tip(self) -> str:
+        return random.choice(self.dicas_estudo)
 
-class StudyPlanGenerator:
-    def __init__(self, db: RevalidaDatabase):
-        self.db = db
+class StudyAnalytics:
+    """Classe para análise avançada do progresso do estudante"""
     
-    def create_study_plan(self, user_id: str, available_hours: int, 
-                         target_date: str, weak_areas: List[str]) -> Dict:
-        """Gera plano de estudos personalizado"""
+    def __init__(self, db_connection):
+        self.conn = db_connection
+
+    def calculate_study_metrics(self, user_id: str) -> Dict:
+        """Calcula métricas avançadas de estudo"""
+        cursor = self.conn.cursor()
         
-        # Calcula período total de estudo
-        start_date = datetime.now()
-        target_date = datetime.strptime(target_date, '%Y-%m-%d')
-        total_days = (target_date - start_date).days
+        # Horas totais de estudo
+        cursor.execute('''
+            SELECT SUM(horas_estudadas) FROM study_progress 
+            WHERE user_id = ?
+        ''', (user_id,))
+        total_horas = cursor.fetchone()[0] or 0
         
-        # Define distribuição de tópicos
-        topics = {
-            "Clínica Médica": 0.25,
-            "Cirurgia": 0.20,
-            "Pediatria": 0.15,
-            "Ginecologia e Obstetrícia": 0.15,
-            "Medicina de Família": 0.15,
-            "Saúde Mental": 0.10
-        }
+        # Desempenho por área
+        cursor.execute('''
+            SELECT topic, AVG(performance_score) 
+            FROM study_progress 
+            WHERE user_id = ? 
+            GROUP BY topic
+        ''', (user_id,))
+        desempenho_por_area = dict(cursor.fetchall())
         
-        # Ajusta pesos para áreas fracas
-        for area in weak_areas:
-            if area in topics:
-                topics[area] += 0.05
+        # Consistência de estudos (dias consecutivos)
+        cursor.execute('''
+            SELECT date FROM study_progress 
+            WHERE user_id = ? 
+            ORDER BY date DESC
+        ''', (user_id,))
+        datas = [row[0] for row in cursor.fetchall()]
+        dias_consecutivos = self.calculate_streak(datas)
         
-        # Normaliza pesos
-        total_weight = sum(topics.values())
-        topics = {k: v/total_weight for k, v in topics.items()}
+        return {
+            "total_horas": total_horas,
+            "desempenho_por_area": desempenho_por_area,
+            "dias_consecutivos": dias_consecutivos
+        }
+
+    @staticmethod
+    def calculate_streak(dates: List[str]) -> int:
+        if not dates:
+            return 0
         
-        # Gera cronograma
-        schedule = {}
-        for week in range(total_days // 7 + 1):
-            schedule[f"Semana {week+1}"] = {
-                topic: round(hours * available_hours * topics[topic], 1)
-                for topic in topics
-            }
+        dates = [datetime.strptime(d, '%Y-%m-%d').date() for d in dates]
+        dates.sort(reverse=True)
         
-        return schedule
+        streak = 1
+        for i in range(len(dates)-1):
+            if (dates[i] - dates[i+1]).days == 1:
+                streak += 1
+            else:
+                break
+        return streak
 
-class RevalidaBot:
+class CRMJABot:
+    """Assistente de estudos aprimorado para o Revalida"""
+    
     def __init__(self):
         self.db = RevalidaDatabase()
         self.planner = StudyPlanGenerator(self.db)
+        self.coach = MotivationalCoach()
+        self.analytics = StudyAnalytics(self.db.conn)
+        self.performance = PerformanceAnalyzer(self.db.conn)
+self.material_gen = StudyMaterialGenerator(self.db.conn)
+self.tracker = ProgressTracker(self.db.conn)
+
+        try:
+            self.qa_pipeline = pipeline(
+                "question-answering",
+                model="pierreguillou/bert-base-cased-squad-v1.1-portuguese",
+                device=-1
+            )
+        except Exception as e:
+            print(f"Erro ao carregar o modelo: {e}")
+            self.qa_pipeline = None
         
-        # Modelo de linguagem
-        self.model_id = "meta-llama/Llama-2-7b-chat-hf"
-        self.tokenizer = AutoTokenizer.from_pretrained(self.model_id)
-        self.pipeline = pipeline(
-            "text-generation",
-            model=self.model_id,
-            tokenizer=self.tokenizer,
-            max_length=500
-        )
-        
-        # Comandos disponíveis
         self.commands = {
             "/start": self.start_command,
             "/plano": self.create_plan,
             "/progresso": self.check_progress,
             "/questoes": self.previous_questions,
             "/estudo": self.study_mode,
+            "/dica": self.get_tip,
+            "/motiva": self.get_motivation,
+            "/resumo": self.get_summary,
             "/ajuda": self.help_command
         }
-    
-    def process_message(self, message: str, user_id: str, history: List) -> str:
-        """Processa mensagens recebidas"""
+
+    def start_command(self, message: str, user_id: str) -> str:
+        """Mensagem inicial de boas-vindas"""
+        return f"""🌟 Olá! Eu sou o crmjaBot, seu assistente pessoal para o Revalida!
+
+Estou aqui para te ajudar a alcançar seu objetivo de aprovação! Vamos juntos nessa jornada? 
+
+Comandos principais:
+📚 /plano - Criar plano de estudos personalizado
+📊 /progresso - Verificar seu progresso
+📝 /questoes - Praticar questões anteriores
+⏱ /estudo - Registrar sessão de estudo
+💡 /dica - Receber dica de estudo
+🌟 /motiva - Mensagem motivacional
+📋 /resumo - Resumo do seu desempenho
+❓ /ajuda - Ver todos os comandos
+
+{self.coach.get_motivational_message()}
+
+Como posso te ajudar hoje?"""
+
+    def get_tip(self, message: str, user_id: str) -> str:
+        """Fornece dica de estudo"""
+        return f"💡 Dica do dia:\n\n{self.coach.get_study_tip()}"
+
+    def get_motivation(self, message: str, user_id: str) -> str:
+        """Fornece mensagem motivacional"""
+        return f"✨ Mensagem motivacional:\n\n{self.coach.get_motivational_message()}"
+
+    def get_summary(self, message: str, user_id: str) -> str:
+        """Fornece resumo completo do progresso"""
         try:
-            if message.startswith("/"):
-                command = message.split()[0]
-                if command in self.commands:
-                    return self.commands[command](message, user_id)
-                return "Comando não reconhecido. Use /ajuda para ver os comandos disponíveis."
+            metrics = self.analytics.calculate_study_metrics(user_id)
+            
+            response = f"""📊 Resumo do seu desempenho:
+
+⏱ Total de horas estudadas: {metrics['total_horas']:.1f}h
+🎯 Sequência atual: {metrics['dias_consecutivos']} dias consecutivos
+
+📈 Desempenho por área:"""
             
-            return self.generate_response(message, history)
+            for area, score in metrics['desempenho_por_area'].items():
+                response += f"\n- {area}: {score:.1f}%"
+            
+            response += f"\n\n{self.coach.get_motivational_message()}"
+            
+            return response
             
         except Exception as e:
-            return f"Desculpe, ocorreu um erro: {str(e)}"
+            return f"Erro ao gerar resumo: {str(e)}"
 
     def create_plan(self, message: str, user_id: str) -> str:
-        """Cria plano de estudos personalizado"""
+        """Criar plano de estudos personalizado com elementos motivacionais"""
         try:
-            # Extrai parâmetros da mensagem
-            # Formato: /plano horas_diarias YYYY-MM-DD área1,área2
             parts = message.split()
             if len(parts) < 3:
-                return "Formato: /plano horas_diarias YYYY-MM-DD área1,área2"
-            
-            hours = int(parts[1])
-            target_date = parts[2]
-            weak_areas = parts[3].split(',') if len(parts) > 3 else []
+                return """📚 Para criar seu plano personalizado, preciso de algumas informações:
+
+Formato: /plano horas_diarias AAAA-MM-DD área1,área2
+
+Exemplo: /plano 4 2024-07-15 ClínicaMédica,Cirurgia
+
+As áreas disponíveis são:
+- ClínicaMédica
+- Cirurgia
+- Pediatria
+- GinecologiaObstetrícia
+- MedicinaFamília
+- SaúdeMental"""
+
+            horas = int(parts[1])
+            data_alvo = parts[2]
+            areas_fracas = parts[3].split(',') if len(parts) > 3 else []
             
-            plan = self.planner.create_study_plan(
-                user_id, hours, target_date, weak_areas
-            )
+            plano = self.planner.create_study_plan(user_id, horas, data_alvo, areas_fracas)
             
-            # Formata resposta
-            response = "📚 Seu Plano de Estudos:\n\n"
-            for week, topics in plan.items():
-                response += f"{week}:\n"
-                for topic, hours in topics.items():
-                    response += f"- {topic}: {hours}h\n"
-                response += "\n"
+            response = f"""✨ Seu Plano de Estudos Personalizado está pronto! 
+
+{self.coach.get_motivational_message()}
+
+📚 Distribuição semanal:"""
+
+            for semana, topicos in plano.items():
+                response += f"\n\n📅 {semana}:"
+                for topico, horas in topicos.items():
+                    response += f"\n  ▪ {topico}: {horas}h"
+
+            response += f"\n\n💡 Dica: {self.coach.get_study_tip()}"
             
             return response
             
@@ -179,108 +228,120 @@ class RevalidaBot:
             return f"Erro ao criar plano: {str(e)}"
 
     def check_progress(self, message: str, user_id: str) -> str:
-        """Verifica progresso do usuário"""
+        """Verifica o progresso com feedback motivacional"""
         try:
-            cursor = self.db.conn.cursor()
-            cursor.execute('''
-            SELECT topic, SUM(hours_studied) as total_hours, 
-                   AVG(performance_score) as avg_score
-            FROM study_progress
-            WHERE user_id = ?
-            GROUP BY topic
-            ''', (user_id,))
+            metrics = self.analytics.calculate_study_metrics(user_id)
             
-            progress = cursor.fetchall()
-            
-            response = "📊 Seu Progresso:\n\n"
-            for topic, hours, score in progress:
-                response += f"{topic}:\n"
-                response += f"- Horas estudadas: {hours:.1f}h\n"
-                response += f"- Desempenho médio: {score:.1f}%\n\n"
-            
-            return response
-            
-        except Exception as e:
-            return f"Erro ao verificar progresso: {str(e)}"
+            response = f"""📊 Seu Progresso:
 
-    def previous_questions(self, message: str, user_id: str) -> str:
-        """Busca questões de provas anteriores"""
-        try:
-            # Formato: /questoes área [ano]
-            parts = message.split()
-            if len(parts) < 2:
-                return "Formato: /questoes área [ano]"
-            
-            area = parts[1]
-            year = int(parts[2]) if len(parts) > 2 else None
-            
-            cursor = self.db.conn.cursor()
-            if year:
-                cursor.execute('''
-                SELECT question_text, options, correct_answer, explanation
-                FROM previous_questions
-                WHERE area = ? AND year = ?
-                ORDER BY RANDOM()
-                LIMIT 1
-                ''', (area, year))
-            else:
-                cursor.execute('''
-                SELECT question_text, options, correct_answer, explanation
-                FROM previous_questions
-                WHERE area = ?
-                ORDER BY RANDOM()
-                LIMIT 1
-                ''', (area,))
+⭐ Incrível! Você já estudou {metrics['total_horas']:.1f} horas no total!
+🎯 Sequência atual: {metrics['dias_consecutivos']} dias consecutivos
+
+📈 Desempenho por área:"""
             
-            question = cursor.fetchone()
-            if not question:
-                return "Nenhuma questão encontrada com esses critérios."
+            for area, score in metrics['desempenho_por_area'].items():
+                response += f"\n  ▪ {area}: {score:.1f}%"
+
+            response += f"\n\n{self.coach.get_motivational_message()}"
             
-            response = f"📝 Questão:\n\n{question[0]}\n\n"
-            options = json.loads(question[1])
-            for letter, text in options.items():
-                response += f"{letter}) {text}\n"
-            response += f"\nResposta: {question[2]}\n"
-            response += f"Explicação: {question[3]}"
+            if metrics['dias_consecutivos'] >= 7:
+                response += "\n\n🏆 Parabéns pela dedicação consistente!"
             
             return response
             
         except Exception as e:
-            return f"Erro ao buscar questão: {str(e)}"
+            return f"Erro ao verificar progresso: {str(e)}"
 
     def study_mode(self, message: str, user_id: str) -> str:
-        """Modo estudo com acompanhamento"""
+        """Registra sessão de estudo com feedback motivacional"""
         try:
-            # Formato: /estudo área horas
             parts = message.split()
             if len(parts) < 3:
-                return "Formato: /estudo área horas"
+                return """📚 Para registrar seu estudo:
+
+Formato: /estudo área horas
+
+Exemplo: /estudo ClínicaMédica 2.5"""
             
             area = parts[1]
-            hours = float(parts[2])
+            horas = float(parts[2])
             
-            # Registra estudo
             cursor = self.db.conn.cursor()
             cursor.execute('''
             INSERT INTO study_progress
-            (user_id, date, topic, hours_studied, questions_answered, performance_score)
+            (user_id, date, topic, horas_estudadas, questions_answered, performance_score)
             VALUES (?, ?, ?, ?, ?, ?)
-            ''', (user_id, datetime.now().date(), area, hours, 0, 0.0))
+            ''', (user_id, datetime.now().date(), area, horas, 0, 0.0))
             self.db.conn.commit()
             
-            return f"✅ Registrado: {hours}h de estudo em {area}\n\nContinue assim! Use /progresso para ver seu desenvolvimento."
+            metrics = self.analytics.calculate_study_metrics(user_id)
+            
+            response = f"""✅ Ótimo trabalho! Registrei {horas}h de estudo em {area}
+
+⭐ Total de horas estudadas: {metrics['total_horas']:.1f}h
+🎯 Sequência atual: {metrics['dias_consecutivos']} dias
+
+{self.coach.get_motivational_message()}
+
+💡 Dica: {self.coach.get_study_tip()}"""
+            
+            return response
             
         except Exception as e:
             return f"Erro ao registrar estudo: {str(e)}"
 
-    # Outros métodos necessários...
+    def generate_response(self, message: str, history: List) -> str:
+        """Gera resposta personalizada usando o pipeline de QA"""
+        if not self.qa_pipeline:
+            return f"""Desculpe, o modelo de linguagem não está disponível no momento.
+
+{self.coach.get_motivational_message()}
+
+Use /ajuda para ver os comandos disponíveis!"""
+            
+        try:
+            context = "\n".join([h[1] for h in history[-3:]] if history else "")
+            
+            result = self.qa_pipeline(
+                question=message,
+                context=context or "Você é o crmjaBot, um assistente motivacional e educacional para o Revalida."
+            )
+            
+            return f"""{result['answer']}
+
+{self.coach.get_motivational_message()}"""
+        except Exception as e:
+            return f"Erro ao gerar resposta: {str(e)}"
+
+    def help_command(self, message: str, user_id: str) -> str:
+        """Mostra todos os comandos disponíveis"""
+        return """🤖 Comandos do crmjaBot:
+
+📚 Estudos:
+/plano - Criar plano de estudos personalizado
+/estudo - Registrar sessão de estudo
+/questoes - Praticar questões anteriores
+
+📊 Acompanhamento:
+/progresso - Ver seu progresso
+/resumo - Resumo completo do desempenho
+
+✨ Motivacional:
+/dica - Receber dica de estudo
+/motiva - Mensagem motivacional
+
+❓ Ajuda:
+/start - Iniciar/reiniciar bot
+/ajuda - Ver esta mensagem
+
+Estou aqui para te ajudar! Como posso ser útil hoje?"""
 
 def create_interface():
-    """Cria interface Gradio"""
-    bot = RevalidaBot()
+    """Criar interface Gradio"""
+    bot = CRMJABot()
     
-    with gr.Blocks(title="Assistente Revalida") as interface:
-        gr.Markdown("# 🏥 Assistente Revalida Pro")
+    with gr.Blocks(title="crmjaBot - Assistente Revalida") as interface:
+        gr.Markdown("# 🏥 crmjaBot")
         gr.Markdown("### Seu mentor personalizado para o Revalida")
         
         with gr.Row():
@@ -297,19 +358,15 @@ def create_interface():
         )
         clear = gr.ClearButton([msg, chatbot])
 
-        def process_message_with_user(message, history):
-            user = user_id.value if user_id.value else "default_user"
-            return bot.process_message(message, user, history)
+        def respond(message, history):
+            bot_message = bot.process_message(message, user_id.value or "default_user", history)
+            history.append((message, bot_message))
+            return "", history
 
-        msg.submit(
-            process_message_with_user, 
-            [msg, chatbot], 
-            [chatbot]
-        )
+        msg.submit(respond, [msg, chatbot], [msg, chatbot])
 
     return interface
 
-# Inicia a interface
 if __name__ == "__main__":
     interface = create_interface()
     interface.launch()