Create app.py

app.py

@@ -0,0 +1,411 @@
+# config.py
+import os
+from dotenv import load_dotenv
+
+load_dotenv()
+
+class Config:
+    DEBUG = os.getenv('DEBUG', 'False').lower() == 'true'
+    LOG_LEVEL = os.getenv('LOG_LEVEL', 'INFO')
+    MODELS_CACHE_DIR = os.getenv('MODELS_CACHE_DIR', './models')
+    HISTORY_FILE = os.getenv('HISTORY_FILE', 'learning_path_history.json')
+    MAX_AUDIO_LENGTH = int(os.getenv('MAX_AUDIO_LENGTH', '600'))  # segundos
+    MAX_TEXT_LENGTH = int(os.getenv('MAX_TEXT_LENGTH', '1000'))
+    SUPPORTED_AUDIO_FORMATS = ['.wav', '.mp3', '.ogg', '.flac']
+    
+    # Configurações de visualização
+    MAX_TOPICS = int(os.getenv('MAX_TOPICS', '10'))
+    MAX_SUBTOPICS = int(os.getenv('MAX_SUBTOPICS', '5'))
+    FIGURE_DPI = int(os.getenv('FIGURE_DPI', '300'))
+    
+    # Configurações de modelo
+    MODEL_TRANSCRIBER = os.getenv('MODEL_TRANSCRIBER', 'openai/whisper-base')
+    MODEL_GENERATOR = os.getenv('MODEL_GENERATOR', 'gpt2')
+    
+    # Configurações de retry
+    MAX_RETRIES = int(os.getenv('MAX_RETRIES', '3'))
+    RETRY_DELAY = int(os.getenv('RETRY_DELAY', '1'))
+
+# utils.py
+import logging
+import json
+from typing import Dict, Any, Optional, List, Tuple
+import os
+from config import Config
+
+class Utils:
+    @staticmethod
+    def setup_logging() -> logging.Logger:
+        logger = logging.getLogger("LearningPathGenerator")
+        logger.setLevel(getattr(logging, Config.LOG_LEVEL))
+        
+        # Configuração do arquivo de log
+        handler = logging.FileHandler("app.log")
+        formatter = logging.Formatter(
+            '%(asctime)s - %(name)s - %(levelname)s - %(message)s'
+        )
+        handler.setFormatter(formatter)
+        logger.addHandler(handler)
+        
+        return logger
+    
+    @staticmethod
+    def save_json(data: Dict[str, Any], filename: str) -> bool:
+        try:
+            with open(filename, 'w', encoding='utf-8') as f:
+                json.dump(data, f, ensure_ascii=False, indent=2)
+            return True
+        except Exception as e:
+            logging.error(f"Erro ao salvar JSON: {str(e)}")
+            return False
+    
+    @staticmethod
+    def load_json(filename: str) -> Optional[Dict[str, Any]]:
+        try:
+            with open(filename, 'r', encoding='utf-8') as f:
+                return json.load(f)
+        except Exception as e:
+            logging.error(f"Erro ao carregar JSON: {str(e)}")
+            return None
+
+# validators.py
+import os
+import soundfile as sf
+from typing import Tuple, Optional
+from config import Config
+
+class Validators:
+    @staticmethod
+    def validate_audio_file(file_path: str) -> Tuple[bool, Optional[str]]:
+        try:
+            if not os.path.exists(file_path):
+                return False, "Arquivo não encontrado"
+            
+            # Verifica extensão
+            ext = os.path.splitext(file_path)[1].lower()
+            if ext not in Config.SUPPORTED_AUDIO_FORMATS:
+                return False, f"Formato não suportado. Use: {Config.SUPPORTED_AUDIO_FORMATS}"
+            
+            # Verifica conteúdo
+            data, samplerate = sf.read(file_path)
+            duration = len(data) / samplerate
+            
+            if duration > Config.MAX_AUDIO_LENGTH:
+                return False, f"Áudio muito longo. Máximo: {Config.MAX_AUDIO_LENGTH}s"
+            
+            return True, None
+            
+        except Exception as e:
+            return False, f"Erro na validação: {str(e)}"
+    
+    @staticmethod
+    def validate_path_name(name: str) -> Tuple[bool, Optional[str]]:
+        if not name:
+            return True, None
+            
+        if len(name) > 100:
+            return False, "Nome muito longo. Máximo: 100 caracteres"
+            
+        if not all(c.isprintable() for c in name):
+            return False, "Nome contém caracteres inválidos"
+            
+        return True, None
+
+# models.py
+from transformers import pipeline
+import torch
+from typing import Dict, Optional
+import logging
+from config import Config
+
+class ModelManager:
+    def __init__(self):
+        self.logger = logging.getLogger("ModelManager")
+        self.models: Dict[str, Any] = {}
+        self._initialize_models()
+    
+    def _initialize_models(self):
+        try:
+            # Verifica GPU
+            device = 0 if torch.cuda.is_available() else -1
+            
+            self.models["transcriber"] = pipeline(
+                "automatic-speech-recognition",
+                model=Config.MODEL_TRANSCRIBER,
+                device=device
+            )
+            
+            self.models["generator"] = pipeline(
+                "text-generation",
+                model=Config.MODEL_GENERATOR,
+                device=device
+            )
+            
+        except Exception as e:
+            self.logger.error(f"Erro ao inicializar modelos: {str(e)}")
+            raise
+    
+    def get_model(self, name: str):
+        return self.models.get(name)
+
+# visualization.py
+import networkx as nx
+import matplotlib.pyplot as plt
+from io import BytesIO
+import base64
+from typing import Dict, List
+from config import Config
+
+class Visualizer:
+    @staticmethod
+    def create_mind_map(topics: List[str], 
+                       subtopics: Dict[str, List[str]]) -> Optional[str]:
+        try:
+            plt.figure(figsize=(15, 10), dpi=Config.FIGURE_DPI)
+            G = nx.DiGraph()
+            
+            # Adiciona nós e arestas
+            for i, topic in enumerate(topics[:Config.MAX_TOPICS]):
+                G.add_node(topic, level=i)
+                
+                if topic in subtopics:
+                    for subtopic in subtopics[topic][:Config.MAX_SUBTOPICS]:
+                        subtopic_name = f"{topic}:\n{subtopic}"
+                        G.add_node(subtopic_name, level=i)
+                        G.add_edge(topic, subtopic_name)
+                
+                if i > 0:
+                    G.add_edge(topics[i-1], topic)
+            
+            # Layout e estilo
+            pos = nx.spring_layout(G, k=2, iterations=50)
+            
+            # Desenha nós principais
+            nx.draw_networkx_nodes(G, pos,
+                                 nodelist=[n for n in G.nodes() if ":" not in n],
+                                 node_color='lightblue',
+                                 node_size=3000)
+            
+            # Desenha subtópicos
+            nx.draw_networkx_nodes(G, pos,
+                                 nodelist=[n for n in G.nodes() if ":" in n],
+                                 node_color='lightgreen',
+                                 node_size=2000)
+            
+            # Desenha arestas e labels
+            nx.draw_networkx_edges(G, pos, edge_color='gray', arrows=True)
+            nx.draw_networkx_labels(G, pos, font_size=8, font_weight='bold')
+            
+            # Salva imagem
+            buf = BytesIO()
+            plt.savefig(buf, format='png', bbox_inches='tight')
+            buf.seek(0)
+            plt.close()
+            
+            return f"data:image/png;base64,{base64.b64encode(buf.getvalue()).decode()}"
+            
+        except Exception as e:
+            logging.error(f"Erro na visualização: {str(e)}")
+            return None
+
+# main.py
+import gradio as gr
+from typing import Dict, Any
+import sys
+import logging
+from config import Config
+from utils import Utils
+from validators import Validators
+from models import ModelManager
+from visualization import Visualizer
+
+class LearningPathGenerator:
+    def __init__(self):
+        self.logger = Utils.setup_logging()
+        self.model_manager = ModelManager()
+        self.history_file = Config.HISTORY_FILE
+        
+        # Inicialização do histórico
+        if not os.path.exists(self.history_file):
+            Utils.save_json([], self.history_file)
+    
+    def process_audio(self, 
+                     audio_path: str, 
+                     path_name: str = "", 
+                     difficulty: str = "intermediate", 
+                     include_resources: bool = True) -> Dict[str, Any]:
+        try:
+            # Validação do áudio
+            valid_audio, audio_error = Validators.validate_audio_file(audio_path)
+            if not valid_audio:
+                return self._error_response(audio_error)
+            
+            # Validação do nome
+            valid_name, name_error = Validators.validate_path_name(path_name)
+            if not valid_name:
+                return self._error_response(name_error)
+            
+            # Transcrição
+            transcriber = self.model_manager.get_model("transcriber")
+            transcription = transcriber(audio_path)["text"]
+            
+            # Geração da análise
+            generator = self.model_manager.get_model("generator")
+            analysis = self._generate_analysis(generator, transcription, difficulty)
+            
+            # Criação do mapa mental
+            topics, subtopics = self._extract_topics(analysis)
+            mind_map = Visualizer.create_mind_map(topics, subtopics)
+            
+            # Salva no histórico
+            if path_name:
+                self._save_to_history(transcription, analysis, path_name)
+            
+            return {
+                "transcription": transcription,
+                "analysis": analysis,
+                "mind_map": mind_map
+            }
+            
+        except Exception as e:
+            self.logger.error(f"Erro no processamento: {str(e)}")
+            return self._error_response(str(e))
+    
+    def create_interface(self):
+        with gr.Blocks(theme=gr.themes.Soft()) as app:
+            gr.Markdown("""
+            # 🎓 Gerador de Trilha de Aprendizado
+            
+            Carregue um arquivo de áudio descrevendo seus objetivos de aprendizado 
+            e receba uma trilha personalizada com recursos!
+            """)
+            
+            with gr.Tab("Gerar Trilha"):
+                with gr.Row():
+                    with gr.Column(scale=2):
+                        audio_input = gr.Audio(
+                            type="filepath",
+                            label="Upload do Áudio",
+                            description="Grave ou faça upload de um áudio descrevendo seus objetivos"
+                        )
+                        
+                        with gr.Row():
+                            path_name = gr.Textbox(
+                                label="Nome da Trilha",
+                                placeholder="Dê um nome para sua trilha (opcional)"
+                            )
+                            difficulty = gr.Dropdown(
+                                choices=["iniciante", "intermediário", "avançado"],
+                                value="intermediário",
+                                label="Nível de Dificuldade"
+                            )
+                        
+                        with gr.Row():
+                            include_resources = gr.Checkbox(
+                                label="Incluir Recursos Recomendados",
+                                value=True
+                            )
+                            process_btn = gr.Button(
+                                "Gerar Trilha de Aprendizado",
+                                variant="primary"
+                            )
+                
+                with gr.Row():
+                    text_output = gr.Textbox(
+                        label="Transcrição do Áudio",
+                        lines=4
+                    )
+                
+                with gr.Row():
+                    analysis_output = gr.Textbox(
+                        label="Análise e Trilha de Aprendizado",
+                        lines=10
+                    )
+                
+                with gr.Row():
+                    mind_map_output = gr.Image(
+                        label="Mapa Mental da Trilha",
+                        elem_id="mind_map"
+                    )
+            
+            with gr.Tab("Histórico"):
+                gr.Markdown("Trilhas Anteriores")
+                history_table = gr.Dataframe(
+                    headers=["Data", "Nome", "Transcrição", "Análise"],
+                    label="Histórico de Trilhas"
+                )
+                refresh_btn = gr.Button("Atualizar Histórico")
+            
+            # Event handlers
+            process_btn.click(
+                fn=self.process_audio,
+                inputs=[audio_input, path_name, difficulty, include_resources],
+                outputs={
+                    "transcription": text_output,
+                    "analysis": analysis_output,
+                    "mind_map": mind_map_output
+                }
+            )
+            
+            refresh_btn.click(
+                fn=self._load_history,
+                outputs=[history_table]
+            )
+        
+        return app
+
+    def _generate_analysis(self, 
+                         generator, 
+                         text: str, 
+                         difficulty: str) -> str:
+        prompt = f"""
+        Com base no seguinte texto, crie uma trilha de aprendizado detalhada 
+        para nível {difficulty}:
+        {text[:Config.MAX_TEXT_LENGTH]}
+        
+        Trilha de aprendizado:
+        """
+        
+        response = generator(
+            prompt,
+            max_length=300,
+            num_return_sequences=1
+        )[0]["generated_text"]
+        
+        if include_resources:
+            response += self._generate_resources()
+        
+        return response
+    
+    def _generate_resources(self) -> str:
+        return """
+        Recursos Recomendados:
+        
+        1. Livros:
+           - "Guia Essencial do Tema"
+           - "Técnicas Avançadas"
+           
+        2. Cursos Online:
+           - Coursera: "Especialização no Tema"
+           - edX: "Curso Avançado"
+           
+        3. Recursos Práticos:
+           - Tutoriais interativos
+           - Exercícios práticos
+           - Projetos do mundo real
+        """
+    
+    def _error_response(self, error_msg: str) -> Dict[str, Any]:
+        return {
+            "transcription": f"Erro: {error_msg}",
+            "analysis": "Não foi possível gerar a análise devido a um erro.",
+            "mind_map": None
+        }
+
+# Execução do app
+if __name__ == "__main__":
+    try:
+        generator = LearningPathGenerator()
+        app = generator.create_interface()
+        app.launch(debug=Config.DEBUG)
+    except Exception as e: