Update app.py

app.py

@@ -6,99 +6,17 @@ 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
-import json
 from database.db_manager import DatabaseManager
 from database.db_operations import adicionar_lote_questoes
-from study_generators import StudyMaterialGenerator, StudyPlanGenerator
-from performance_analyzer import PerformanceAnalyzer
-import json
-
-class CRMJABot:
-    def __init__(self):
-        self.db = DatabaseManager()
-        self.material_generator = StudyMaterialGenerator(self.db)
-        self.planner = StudyPlanGenerator(self.db)
-        self.performance = PerformanceAnalyzer(self.db.get_connection())  # Corrigido aqui
-        
-        try:
-            with open('data/questoes_revalida.json', 'r', encoding='utf-8') as f:
-                questoes = json.load(f)
-            
-            sucesso, mensagem = adicionar_lote_questoes(self.db, questoes)
-            
-            if sucesso:
-                print("Questões adicionadas com sucesso!")
-            else:
-                print(f"Erro: {mensagem}")
-                
-        except Exception as e:
-            print(f"Erro na inicialização: {str(e)}")
-
-def create_interface():
-    return CRMJABot()
-
-if __name__ == "__main__":
-    interface = create_interface()
-def buscar_questoes_para_simulado(db: DatabaseManager, usuario_id: str, 
-                                 num_questoes: int = 10, 
-                                 areas: list = None,
-                                 dificuldade: str = None):
-    """Busca questões para gerar simulado personalizado"""
-    try:
-        conn = db.get_connection()
-        cursor = conn.cursor()
-        
-        # Busca áreas fracas do usuário
-        user_profile = db.get_user_profile(usuario_id)
-        weak_areas = user_profile.get('weak_areas', [])
-        
-        # Monta a query
-        query = '''
-        SELECT * FROM previous_questions 
-        WHERE 1=1
-        '''
-        params = []
-        
-        if areas:
-            query += ' AND area IN ({})'.format(','.join(['?']*len(areas)))
-            params.extend(areas)
-            
-        if dificuldade:
-            query += ' AND difficulty = ?'
-            params.append(dificuldade)
-            
-        # Prioriza áreas fracas
-        if weak_areas:
-            query += f''' 
-            ORDER BY 
-            CASE 
-                WHEN area IN ({','.join(['?']*len(weak_areas))}) THEN 1 
-                ELSE 2 
-            END, 
-            RANDOM()
-            '''
-            params.extend(weak_areas)
-        else:
-            query += ' ORDER BY RANDOM()'
-            
-        query += ' LIMIT ?'
-        params.append(num_questoes)
-        
-        cursor.execute(query, params)
-        questoes = cursor.fetchall()
-        
-        return [dict(q) for q in questoes]
-        
-    except Exception as e:
-        logger.error(f"Erro ao buscar questões: {e}")
-        return []
-from performance_system import PerformanceAnalyzer, StudyMaterialGenerator, ProgressTracker
+from study_generators import StudyPlanGenerator
+from performance_system import (
+    PerformanceAnalyzer, 
+    StudyMaterialGenerator, 
+    ProgressTracker,
+    initialize_performance_system
+)
 
 class MotivationalCoach:
-    """Classe para gerenciar mensagens e estratégias motivacionais"""
-    
     def __init__(self):
         self.frases_motivacionais = [
             "🌟 Cada hora de estudo te aproxima mais do seu objetivo!",
@@ -110,7 +28,6 @@ class MotivationalCoach:
             "🌅 Um novo dia, uma nova oportunidade de aprender!",
             "🎓 Sua aprovação no Revalida está cada vez mais próxima!"
         ]
-        
         self.dicas_estudo = [
             "📌 Faça pequenas pausas a cada 45 minutos de estudo",
             "💡 Revise o conteúdo do dia antes de dormir",
@@ -128,75 +45,18 @@ class MotivationalCoach:
     def get_study_tip(self) -> str:
         return random.choice(self.dicas_estudo)
 
-class StudyAnalytics:
-    """Classe para análise avançada do progresso do estudante"""
-    
-    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()
-        
-        # 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
-        
-        # 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())
-        
-        # 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)
-        
-        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
-        
-        dates = [datetime.strptime(d, '%Y-%m-%d').date() for d in dates]
-        dates.sort(reverse=True)
-        
-        streak = 1
-        for i in range(len(dates)-1):
-            if (dates[i] - dates[i+1]).days == 1:
-                streak += 1
-            else:
-                break
-        return streak
-
 class CRMJABot:
-    """Assistente de estudos aprimorado para o Revalida"""
-    
     def __init__(self):
         self.db = DatabaseManager()
+        
+        # Inicializa sistema de performance
+        self.performance, self.material_generator, self.tracker = initialize_performance_system(
+            self.db.get_connection()
+        )
+        
         self.planner = StudyPlanGenerator(self.db)
         self.coach = MotivationalCoach()
-        self.analytics = StudyAnalytics(self.db.conn)
-        self.performance = PerformanceAnalyzer(self.db.get_connection())  # Linha corrigida
-        self.material_gen = StudyMaterialGenerator(self.db.conn)
-        self.tracker = ProgressTracker(self.db.conn)
-
+        
         try:
             self.qa_pipeline = pipeline(
                 "question-answering",
@@ -206,138 +66,50 @@ class CRMJABot:
         except Exception as e:
             print(f"Erro ao carregar o modelo: {e}")
             self.qa_pipeline = None
-        
-        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,
-            "/simulado": self.start_simulado,
-            "/caso": self.start_caso_clinico,
-            "/bancoquestoes": self.banco_questoes,
-            "/revisao": self.modo_revisao,
-            "/meta": self.set_goal,
-            "/perfil": self.show_profile,
-            "/configurar": self.configure_preferences
-        }
-        
-    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:
-            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:"""
-            
-            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"Erro ao gerar resumo: {str(e)}"
-
-    def create_plan(self, message: str, user_id: str) -> str:
-        """Criar plano de estudos personalizado com elementos motivacionais"""
-        try:
-            parts = message.split()
-            if len(parts) < 3:
-                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 []
-            
-            plano = self.planner.create_study_plan(user_id, horas, data_alvo, areas_fracas)
-            
-            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
-            
+            with open('data/questoes_revalida.json', 'r', encoding='utf-8') as f:
+                questoes = json.load(f)
+            sucesso, mensagem = adicionar_lote_questoes(self.db, questoes)
+            print("Questões adicionadas com sucesso!" if sucesso else f"Erro: {mensagem}")
         except Exception as e:
-            return f"Erro ao criar plano: {str(e)}"
+            print(f"Erro na inicialização: {str(e)}")
 
     def check_progress(self, message: str, user_id: str) -> str:
-        """Verifica o progresso com feedback motivacional"""
         try:
-            metrics = self.analytics.calculate_study_metrics(user_id)
+            # Obtém métricas detalhadas usando o novo sistema
+            metrics = self.performance.get_performance_metrics(user_id)
+            streak_info = self.tracker.calculate_study_streak(user_id)
             
-            response = f"""📊 Seu Progresso:
+            response = f"""📊 Análise Detalhada do seu Progresso:
 
-⭐ Incrível! Você já estudou {metrics['total_horas']:.1f} horas no total!
-🎯 Sequência atual: {metrics['dias_consecutivos']} dias consecutivos
+⭐ Total de horas estudadas: {metrics['overall_metrics']['total_hours']:.1f}h
+🎯 Média de desempenho: {metrics['overall_metrics']['avg_performance']:.1f}%
+📅 Dias de estudo: {metrics['overall_metrics']['study_days']}
+🔥 Sequência atual: {streak_info['current_streak']} dias
+🏆 Maior sequência: {streak_info['longest_streak']} dias
 
 📈 Desempenho por área:"""
             
-            for area, score in metrics['desempenho_por_area'].items():
-                response += f"\n  ▪ {area}: {score:.1f}%"
+            for topic, data in metrics['topic_metrics'].items():
+                avg_score = np.mean(data['scores']) if data['scores'] else 0
+                response += f"\n  ▪ {topic}: {avg_score:.1f}% ({data['total_hours']}h)"
 
-            response += f"\n\n{self.coach.get_motivational_message()}"
+            # Adiciona recomendações baseadas no desempenho
+            weak_topics = [topic for topic, data in metrics['topic_metrics'].items() 
+                         if np.mean(data['scores']) < 70]
             
-            if metrics['dias_consecutivos'] >= 7:
-                response += "\n\n🏆 Parabéns pela dedicação consistente!"
+            if weak_topics:
+                response += "\n\n📚 Áreas que precisam de mais atenção:"
+                for topic in weak_topics:
+                    resources = self.material_generator.get_recommended_resources(
+                        topic, metrics['topic_metrics'][topic]
+                    )
+                    response += f"\n  ▪ {topic}:"
+                    for resource in resources[:2]:  # Limita a 2 recursos por tópico
+                        response += f"\n    - {resource}"
+
+            response += f"\n\n{self.coach.get_motivational_message()}"
             
             return response
             
@@ -345,91 +117,87 @@ As áreas disponíveis são:
             return f"Erro ao verificar progresso: {str(e)}"
 
     def study_mode(self, message: str, user_id: str) -> str:
-        """Registra sessão de estudo com feedback motivacional"""
         try:
             parts = message.split()
             if len(parts) < 3:
                 return """📚 Para registrar seu estudo:
-
+                
 Formato: /estudo área horas
-
 Exemplo: /estudo ClínicaMédica 2.5"""
             
             area = parts[1]
             horas = float(parts[2])
             
-            cursor = self.db.conn.cursor()
+            # Registra a sessão
+            cursor = self.db.get_connection().cursor()
             cursor.execute('''
             INSERT INTO study_progress
-            (user_id, date, topic, horas_estudadas, questions_answered, performance_score)
-            VALUES (?, ?, ?, ?, ?, ?)
-            ''', (user_id, datetime.now().date(), area, horas, 0, 0.0))
-            self.db.conn.commit()
-            
-            metrics = self.analytics.calculate_study_metrics(user_id)
+            (user_id, date, topic, horas_estudadas, performance_score)
+            VALUES (?, ?, ?, ?, ?)
+            ''', (user_id, datetime.now().date(), area, horas, 0.0))
+            self.db.get_connection().commit()
+            
+            # Obtém métricas atualizadas
+            metrics = self.performance.get_performance_metrics(user_id)
+            streak_info = self.tracker.calculate_study_streak(user_id)
+            
+            # Gera plano personalizado para próxima sessão
+            next_plan = self.material_generator.generate_daily_plan(
+                user_id, horas, metrics['topic_metrics']
+            )
             
             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
+📊 Status atual:
+⭐ Total de horas: {metrics['overall_metrics']['total_hours']:.1f}h
+🔥 Sequência: {streak_info['current_streak']} dias
+🏆 Recorde: {streak_info['longest_streak']} dias
 
-{self.coach.get_motivational_message()}
+📚 Sugestões para próxima sessão:"""
 
-💡 Dica: {self.coach.get_study_tip()}"""
+            for area, horas in next_plan['distribuicao_horas'].items():
+                response += f"\n  ▪ {area}: {horas}h"
+                
+            response += f"\n\n{self.coach.get_motivational_message()}"
+            response += f"\n\n💡 Dica: {self.coach.get_study_tip()}"
             
             return response
             
         except Exception as e:
             return f"Erro ao registrar estudo: {str(e)}"
 
-    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.
+    def get_summary(self, message: str, user_id: str) -> str:
+        try:
+            metrics = self.performance.get_performance_metrics(user_id)
+            streak_info = self.tracker.calculate_study_streak(user_id)
+            
+            response = f"""📊 Resumo Completo do seu Desempenho:
 
-{self.coach.get_motivational_message()}
+⏱ Métricas Gerais:
+▪ Total de horas estudadas: {metrics['overall_metrics']['total_hours']:.1f}h
+▪ Média de desempenho: {metrics['overall_metrics']['avg_performance']:.1f}%
+▪ Dias de estudo: {metrics['overall_metrics']['study_days']}
+▪ Sequência atual: {streak_info['current_streak']} dias
+▪ Maior sequência: {streak_info['longest_streak']} dias
 
-Use /ajuda para ver os comandos disponíveis!"""
+📈 Progresso por Área:"""
             
-        try:
-            context = "\n".join([h[1] for h in history[-3:]] if history else "")
+            for topic, data in metrics['topic_metrics'].items():
+                avg_score = np.mean(data['scores']) if data['scores'] else 0
+                last_study = data['last_study']
+                response += f"\n\n📌 {topic}:"
+                response += f"\n  ▪ Desempenho: {avg_score:.1f}%"
+                response += f"\n  ▪ Horas dedicadas: {data['total_hours']}h"
+                response += f"\n  ▪ Último estudo: {last_study}"
+
+            response += f"\n\n{self.coach.get_motivational_message()}"
             
-            result = self.qa_pipeline(
-                question=message,
-                context=context or "Você é o crmjaBot, um assistente motivacional e educacional para o Revalida."
-            )
+            return response
             
-            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?"""
+            return f"Erro ao gerar resumo: {str(e)}"
 
 def create_interface():
-    """Criar interface Gradio"""
     bot = CRMJABot()
     
     with gr.Blocks(title="crmjaBot - Assistente Revalida") as interface: