Update app.py

app.py

@@ -1,11 +1,120 @@
+# app.py
 import gradio as gr
 from transformers import AutoModelForCausalLM, AutoTokenizer, pipeline
 import json
 import os
+import sqlite3
+from datetime import datetime, timedelta
+import pandas as pd
+from typing import Dict, List, Optional
+
+class RevalidaDatabase:
+    def __init__(self):
+        self.conn = sqlite3.connect('revalida.db')
+        self.create_tables()
+        self.load_previous_questions()
+    
+    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
+        )''')
+        
+        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}")
+
+class StudyPlanGenerator:
+    def __init__(self, db: RevalidaDatabase):
+        self.db = db
+    
+    def create_study_plan(self, user_id: str, available_hours: int, 
+                         target_date: str, weak_areas: List[str]) -> Dict:
+        """Gera plano de estudos personalizado"""
+        
+        # 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
+        
+        # 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
+        }
+        
+        # Ajusta pesos para áreas fracas
+        for area in weak_areas:
+            if area in topics:
+                topics[area] += 0.05
+        
+        # Normaliza pesos
+        total_weight = sum(topics.values())
+        topics = {k: v/total_weight for k, v in topics.items()}
+        
+        # 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
+            }
+        
+        return schedule
 
 class RevalidaBot:
     def __init__(self):
-        # Inicializa o modelo
+        self.db = RevalidaDatabase()
+        self.planner = StudyPlanGenerator(self.db)
+        
+        # Modelo de linguagem
         self.model_id = "meta-llama/Llama-2-7b-chat-hf"
         self.tokenizer = AutoTokenizer.from_pretrained(self.model_id)
         self.pipeline = pipeline(
@@ -15,109 +124,171 @@ class RevalidaBot:
             max_length=500
         )
         
-        # Carrega a base de conhecimento
-        self.knowledge = self.load_knowledge()
-        
-        # Define os comandos disponíveis
+        # 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,
-            "/caso": self.clinical_case,
-            "/questao": self.question_mode,
             "/ajuda": self.help_command
         }
-
-    def load_knowledge(self):
-        """Carrega base de conhecimento do Revalida"""
-        try:
-            if os.path.exists("knowledge_base.json"):
-                with open("knowledge_base.json", "r", encoding="utf-8") as f:
-                    return json.load(f)
-            return {}
-        except Exception as e:
-            print(f"Erro ao carregar conhecimento: {e}")
-            return {}
-
-    def process_message(self, message, history):
+    
+    def process_message(self, message: str, user_id: str, history: List) -> str:
         """Processa mensagens recebidas"""
         try:
-            # Verifica se é um comando
             if message.startswith("/"):
                 command = message.split()[0]
                 if command in self.commands:
-                    return self.commands[command](message)
+                    return self.commands[command](message, user_id)
                 return "Comando não reconhecido. Use /ajuda para ver os comandos disponíveis."
             
-            # Processa pergunta normal
             return self.generate_response(message, history)
             
         except Exception as e:
             return f"Desculpe, ocorreu um erro: {str(e)}"
 
-    def generate_response(self, message, history):
-        """Gera resposta para perguntas sobre o Revalida"""
-        prompt = f"""
-        Pergunta sobre Revalida: {message}
-        
-        Como assistente especializado em Revalida, forneça uma resposta:
-        1. Objetiva e direta
-        2. Baseada em evidências
-        3. Focada no exame
-        4. Com exemplos práticos quando relevante
-        """
-        
-        response = self.pipeline(prompt, max_length=500)[0]['generated_text']
-        return response
-
-    # Comandos
-    def start_command(self, _):
-        return """🏥 Bem-vindo ao Assistente Revalida!
-
-Comandos disponíveis:
-/estudo - Modo estudo direcionado
-/caso - Gerar caso clínico
-/questao - Questão exemplo
-/ajuda - Ver ajuda
-
-Digite sua dúvida a qualquer momento!"""
-
-    def study_mode(self, message):
-        topic = message.replace("/estudo", "").strip()
-        if not topic:
-            return "Por favor, especifique o tópico após /estudo. Exemplo: /estudo clínica médica"
+    def create_plan(self, message: str, user_id: str) -> str:
+        """Cria plano de estudos personalizado"""
+        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"
             
-        prompt = f"Prepare um resumo focado para o Revalida sobre: {topic}"
-        return self.generate_response(prompt, None)
-
-    def clinical_case(self, _):
-        prompt = "Gere um caso clínico objetivo para estudo do Revalida"
-        return self.generate_response(prompt, None)
+            hours = int(parts[1])
+            target_date = parts[2]
+            weak_areas = parts[3].split(',') if len(parts) > 3 else []
+            
+            plan = self.planner.create_study_plan(
+                user_id, hours, target_date, weak_areas
+            )
+            
+            # 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"
+            
+            return response
+            
+        except Exception as e:
+            return f"Erro ao criar plano: {str(e)}"
 
-    def question_mode(self, _):
-        prompt = "Crie uma questão de múltipla escolha no estilo Revalida"
-        return self.generate_response(prompt, None)
+    def check_progress(self, message: str, user_id: str) -> str:
+        """Verifica progresso do usuário"""
+        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,))
+            
+            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)}"
 
-    def help_command(self, _):
-        return """📚 Comandos do Assistente Revalida:
+    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,))
+            
+            question = cursor.fetchone()
+            if not question:
+                return "Nenhuma questão encontrada com esses critérios."
+            
+            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]}"
+            
+            return response
+            
+        except Exception as e:
+            return f"Erro ao buscar questão: {str(e)}"
 
-/start - Iniciar/Reiniciar
-/estudo [tópico] - Estudar um tópico específico
-/caso - Gerar caso clínico para estudo
-/questao - Gerar questão exemplo
-/ajuda - Ver esta mensagem
+    def study_mode(self, message: str, user_id: str) -> str:
+        """Modo estudo com acompanhamento"""
+        try:
+            # Formato: /estudo área horas
+            parts = message.split()
+            if len(parts) < 3:
+                return "Formato: /estudo área horas"
+            
+            area = parts[1]
+            hours = 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)
+            VALUES (?, ?, ?, ?, ?, ?)
+            ''', (user_id, datetime.now().date(), area, hours, 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."
+            
+        except Exception as e:
+            return f"Erro ao registrar estudo: {str(e)}"
 
-💡 Dicas:
-- Digite sua dúvida normalmente para perguntar
-- Seja específico nas perguntas
-- Use os comandos para funções especiais"""
+    # Outros métodos necessários...
 
 def create_interface():
-    """Cria a interface Gradio"""
+    """Cria interface Gradio"""
     bot = RevalidaBot()
     
     with gr.Blocks(title="Assistente Revalida") as interface:
-        gr.Markdown("# 🏥 Assistente Revalida")
-        gr.Markdown("### Seu companheiro de estudos para o Revalida")
+        gr.Markdown("# 🏥 Assistente Revalida Pro")
+        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(
@@ -126,8 +297,12 @@ 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)
+
         msg.submit(
-            bot.process_message, 
+            process_message_with_user, 
             [msg, chatbot], 
             [chatbot]
         )