Update app.py

app.py

@@ -1,216 +1,29 @@
 import gradio as gr
 from transformers import pipeline
-import json
 import sqlite3
 from datetime import datetime, timedelta
-import pandas as pd
 import random
-from typing import Dict, List, Optional
+from typing import Dict, List
 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(self.db)
-from performance_analyzer import PerformanceAnalyzer
-import json
+from study_generators import StudyPlanGenerator
+import logging
+
+# Configuração de logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
 
 class CRMJABot:
     def __init__(self):
+        logger.info("Iniciando CRMJABot...")
         self.db = DatabaseManager()
-        self.material_generator = StudyMaterialGenerator(self.db.get_connection())  # Corrigido para aceitar o argumento
+        self.material_generator = StudyMaterialGenerator(self.db.get_connection())
         self.planner = StudyPlanGenerator(self.db)
         self.coach = MotivationalCoach()
-        self.analytics = StudyAnalytics(self.db.conn)
-        self.tracker = ProgressTracker(self.db.conn)
-
-        self.performance = PerformanceAnalyzer()
-        self.performance.set_db_connection(self.db.get_connection())
-        
-        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
-
-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!",
-            "💪 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.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 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 StudyMaterialGenerator:
-    def __init__(self, db_connection):
-        self.db_connection = db_connection  # Passa o argumento necessário
-        self.planner = StudyPlanGenerator(self.db)  # Certifique-se de que StudyPlanGenerator aceita a instância de db
-        self.coach = MotivationalCoach()
-        self.analytics = StudyAnalytics(self.db.conn)  # Certifique-se de que StudyAnalytics aceita db.conn
-        self.tracker = ProgressTracker(self.db.conn)  # Certifique-se de que ProgressTracker aceita db.conn
-
-        self.performance = PerformanceAnalyzer()
-        self.performance.set_db_connection(self.db.get_connection())  # Verifica o método set_db_connection
+        self.analytics = StudyAnalytics(self.db.get_connection())
 
-        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
-        
         self.commands = {
             "/start": self.start_command,
             "/plano": self.create_plan,
@@ -221,232 +34,191 @@ class StudyMaterialGenerator:
             "/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:
+            with open('data/questoes_revalida.json', 'r', encoding='utf-8') as f:
+                questoes = json.load(f)
 
-⏱ Total de horas estudadas: {metrics['total_horas']:.1f}h
-🎯 Sequência atual: {metrics['dias_consecutivos']} dias consecutivos
+            sucesso, mensagem = adicionar_lote_questoes(self.db, questoes)
 
-📈 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
-            
+            if sucesso:
+                logger.info("Questões adicionadas com sucesso!")
+            else:
+                logger.error(f"Erro ao adicionar questões: {mensagem}")
         except Exception as e:
-            return f"Erro ao gerar resumo: {str(e)}"
+            logger.error(f"Erro na inicialização do banco de questões: {e}")
+
+    def process_message(self, message: str, user_id: str, history: List) -> str:
+        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."
+
+    def start_command(self, message: str, user_id: str) -> str:
+        return "\ud83c\udf1f Bem-vindo ao crmjaBot! Use /ajuda para ver os comandos disponíveis."
 
     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"""
-
+                return "Erro: Informe horas diárias, data-alvo e áreas de estudo."
             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! 
+            areas = parts[3].split(",") if len(parts) > 3 else []
 
-{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
-            
+            plano = self.planner.create_study_plan(user_id, horas, data_alvo, areas)
+            return f"Plano criado: {plano}"
         except Exception as e:
-            return f"Erro ao criar plano: {str(e)}"
+            logger.error(f"Erro ao criar plano: {e}")
+            return "Erro ao criar plano."
 
     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)
-            
-            response = f"""📊 Seu Progresso:
-
-⭐ Incrível! Você já estudou {metrics['total_horas']:.1f} horas no total!
-🎯 Sequência atual: {metrics['dias_consecutivos']} dias consecutivos
-
-📈 Desempenho por área:"""
-            
+            response = f"\ud83d\udd04 Seu progresso:\n"
+            response += f"Total de horas estudadas: {metrics['total_horas']}\n"
+            response += f"Dias consecutivos de estudo: {metrics['dias_consecutivos']}\n"
             for area, score in metrics['desempenho_por_area'].items():
-                response += f"\n  ▪ {area}: {score:.1f}%"
-
-            response += f"\n\n{self.coach.get_motivational_message()}"
-            
-            if metrics['dias_consecutivos'] >= 7:
-                response += "\n\n🏆 Parabéns pela dedicação consistente!"
-            
+                response += f"{area}: {score:.2f}%\n"
             return response
-            
         except Exception as e:
-            return f"Erro ao verificar progresso: {str(e)}"
+            logger.error(f"Erro ao verificar progresso: {e}")
+            return "Erro ao verificar progresso."
+
+    def previous_questions(self, message: str, user_id: str) -> str:
+        return "Função de perguntas anteriores ainda não implementada."
 
     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:
+        return "Função de modo de estudo ainda não implementada."
 
-Formato: /estudo área horas
+    def get_tip(self, message: str, user_id: str) -> str:
+        return self.coach.get_study_tip()
 
-Exemplo: /estudo ClínicaMédica 2.5"""
-            
-            area = parts[1]
-            horas = float(parts[2])
-            
-            cursor = self.db.conn.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()
-            
+    def get_motivation(self, message: str, user_id: str) -> str:
+        return self.coach.get_motivational_message()
+
+    def get_summary(self, message: str, user_id: str) -> str:
+        try:
             metrics = self.analytics.calculate_study_metrics(user_id)
-            
-            response = f"""✅ Ótimo trabalho! Registrei {horas}h de estudo em {area}
+            response = "\ud83d\udd27 Resumo do desempenho:\n"
+            response += f"Total de horas estudadas: {metrics['total_horas']}\n"
+            response += f"Dias consecutivos de estudo: {metrics['dias_consecutivos']}\n"
+            for area, score in metrics['desempenho_por_area'].items():
+                response += f"{area}: {score:.2f}%\n"
+            return response
+        except Exception as e:
+            logger.error(f"Erro ao gerar resumo: {e}")
+            return "Erro ao gerar resumo."
 
-⭐ Total de horas estudadas: {metrics['total_horas']:.1f}h
-🎯 Sequência atual: {metrics['dias_consecutivos']} dias
+    def help_command(self, message: str, user_id: str) -> str:
+        return "\ud83d\udd27 Lista de comandos disponíveis: /start, /plano, /progresso, /questoes, /estudo, /dica, /motiva, /resumo, /ajuda."
 
-{self.coach.get_motivational_message()}
+class MotivationalCoach:
+    def __init__(self):
+        self.frases_motivacionais = [
+            "\ud83c\udf1f Cada hora de estudo te aproxima mais do seu objetivo!",
+            "\ud83d\udcaa Você está construindo seu futuro a cada dia!",
+            "\ud83c\udfaf Mantenha o foco! O Revalida é só uma etapa da sua jornada de sucesso!",
+            "\u2b50 Sua dedicação é inspiradora! Continue assim!",
+            "\ud83c\udf08 Acredite no seu potencial! Você está no caminho certo!",
+            "\ud83d\udcda Conhecimento é poder, e você está ficando mais forte a cada dia!",
+        ]
+        self.dicas_estudo = [
+            "\ud83d\udccc Faça pequenas pausas a cada 45 minutos de estudo",
+            "\ud83d\udca1 Revise o conteúdo do dia antes de dormir",
+            "\ud83c\udfaf Estabeleça metas diárias pequenas e alcançáveis",
+        ]
 
-💡 Dica: {self.coach.get_study_tip()}"""
-            
-            return response
-            
-        except Exception as e:
-            return f"Erro ao registrar estudo: {str(e)}"
+    def get_motivational_message(self) -> str:
+        return random.choice(self.frases_motivacionais)
 
-    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_study_tip(self) -> str:
+        return random.choice(self.dicas_estudo)
 
-{self.coach.get_motivational_message()}
+class StudyAnalytics:
+    def __init__(self, db_connection):
+        self.conn = db_connection
 
-Use /ajuda para ver os comandos disponíveis!"""
-            
+    def calculate_study_metrics(self, user_id: str) -> Dict:
+        cursor = self.conn.cursor()
         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)}"
+            cursor.execute('''
+                SELECT SUM(horas_estudadas) FROM study_progress WHERE user_id = ?
+            ''', (user_id,))
+            total_horas = cursor.fetchone()[0] or 0
 
-    def help_command(self, message: str, user_id: str) -> str:
-        """Mostra todos os comandos disponíveis"""
-        return """🤖 Comandos do crmjaBot:
+            cursor.execute('''
+                SELECT topic, AVG(performance_score) FROM study_progress 
+                WHERE user_id = ? GROUP BY topic
+            ''', (user_id,))
+            desempenho_por_area = dict(cursor.fetchall())
 
-📚 Estudos:
-/plano - Criar plano de estudos personalizado
-/estudo - Registrar sessão de estudo
-/questoes - Praticar questões anteriores
+            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)
 
-📊 Acompanhamento:
-/progresso - Ver seu progresso
-/resumo - Resumo completo do desempenho
+            cursor.execute('''
+                SELECT COUNT(DISTINCT date) as dias_estudo FROM study_progress
+                WHERE user_id = ?
+            ''', (user_id,))
+            dias_estudo = cursor.fetchone()[0] or 0
+
+            return {
+                "total_horas": total_horas,
+                "desempenho_por_area": desempenho_por_area,
+                "dias_consecutivos": dias_consecutivos,
+                "dias_estudo": dias_estudo
+            }
+        except sqlite3.Error as e:
+            logger.error(f"Erro ao calcular métricas de estudo: {e}")
+            return {}
 
-✨ Motivacional:
-/dica - Receber dica de estudo
-/motiva - Mensagem motivacional
+    @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
 
-❓ Ajuda:
-/start - Iniciar/reiniciar bot
-/ajuda - Ver esta mensagem
+class StudyMaterialGenerator:
+    def __init__(self, db_connection):
+        self.db_connection = db_connection
 
-Estou aqui para te ajudar! Como posso ser útil hoje?"""
+    def gerar_material(self, tema: str) -> str:
+        try:
+            cursor = self.db_connection.cursor()
+            query = "SELECT conteudo FROM materiais WHERE tema = ?"
+            cursor.execute(query, (tema,))
+            resultado = cursor.fetchone()
+            return resultado[0] if resultado else "Nenhum material encontrado para o tema especificado."
+        except sqlite3.Error as e:
+            logger.error(f"Erro ao gerar material: {e}")
+            return "Erro ao buscar material."
 
 def create_interface():
-    """Criar interface Gradio"""
     bot = CRMJABot()
-    
+
     with gr.Blocks(title="crmjaBot - Assistente Revalida") as interface:
-        gr.Markdown("# 🏥 crmjaBot")
+        gr.Markdown("# \ud83c\udfe5 crmjaBot")
         gr.Markdown("### Seu mentor personalizado para o Revalida")
-        
+
         with gr.Row():
             with gr.Column():
                 user_id = gr.Textbox(
                     label="Seu ID (email ou telefone)",
                     placeholder="Digite seu ID único..."
                 )
-        
+
         chatbot = gr.Chatbot()
         msg = gr.Textbox(
             placeholder="Digite sua mensagem ou comando aqui...",
@@ -465,4 +237,4 @@ def create_interface():
 
 if __name__ == "__main__":
     interface = create_interface()
-    interface.launch()
+    interface.launch()