Update app.py

app.py

@@ -21,7 +21,6 @@ class GeradorTrilhaAprendizado:
                                    device=self.device)
             self.historico: List[Dict] = []
             
-            # Download NLTK data only if not already present
             for resource in ['punkt', 'stopwords']:
                 try:
                     nltk.data.find(f'tokenizers/{resource}')
@@ -71,6 +70,33 @@ class GeradorTrilhaAprendizado:
             logging.error(f"Processing error: {str(e)}")
             return ("", "", self._formatar_historico(), f"❌ Erro: {str(e)}")
 
+    def _gerar_trilha_personalizada(self, transcricao: str, nivel: str, area: str, duracao: str) -> str:
+        try:
+            palavras_chave = self._extrair_palavras_chave(transcricao)
+            modulos = self._get_modulos_por_area(area, nivel)
+            duracao_meses = int(duracao.split()[0])
+            tempo_por_modulo = duracao_meses / len(modulos)
+
+            return f"""
+            🎯 Objetivos Identificados:
+            {self._formatar_objetivos(palavras_chave, area)}
+            
+            📚 Trilha Personalizada para {area.title()} - Nível {nivel}:
+            {self._formatar_modulos(modulos, tempo_por_modulo)}
+            
+            🚀 Projetos Práticos Sugeridos:
+            {self._gerar_projetos(area, nivel)}
+            
+            📅 Cronograma ({duracao}):
+            {self._gerar_cronograma(duracao_meses, modulos)}
+            
+            🎖️ Marcos de Avaliação:
+            {self._gerar_marcos_avaliacao(nivel)}
+            """
+        except Exception as e:
+            logging.error(f"Error generating learning path: {str(e)}")
+            return "Erro ao gerar trilha de aprendizado"
+
     def _extrair_palavras_chave(self, texto: str) -> List[str]:
         try:
             tokens = word_tokenize(texto.lower())
@@ -83,6 +109,202 @@ class GeradorTrilhaAprendizado:
             logging.error(f"Keyword extraction error: {str(e)}")
             return ["erro ao extrair palavras-chave"]
 
+    def _get_modulos_por_area(self, area: str, nivel: str) -> List[str]:
+        modulos = {
+            "programação": {
+                "iniciante": [
+                    "Lógica de Programação Básica",
+                    "Introdução a Algoritmos",
+                    "Fundamentos de HTML/CSS",
+                    "JavaScript Básico"
+                ],
+                "intermediário": [
+                    "Estruturas de Dados",
+                    "Programação Orientada a Objetos",
+                    "Frameworks Front-end",
+                    "Banco de Dados"
+                ],
+                "avançado": [
+                    "Arquitetura de Software",
+                    "DevOps e CI/CD",
+                    "Microsserviços",
+                    "Segurança e Performance"
+                ]
+            },
+            "data science": {
+                "iniciante": [
+                    "Estatística Básica",
+                    "Python para Análise de Dados",
+                    "SQL Fundamental",
+                    "Visualização de Dados"
+                ],
+                "intermediário": [
+                    "Machine Learning Básico",
+                    "Deep Learning Fundamentos",
+                    "Big Data Analytics",
+                    "Feature Engineering"
+                ],
+                "avançado": [
+                    "MLOps",
+                    "Análise Avançada",
+                    "IA Generativa",
+                    "Pesquisa Aplicada"
+                ]
+            },
+            "design": {
+                "iniciante": [
+                    "Teoria das Cores",
+                    "Tipografia",
+                    "UI Básica",
+                    "Ferramentas de Design"
+                ],
+                "intermediário": [
+                    "Design Systems",
+                    "UX Research",
+                    "Prototipagem",
+                    "Design Visual"
+                ],
+                "avançado": [
+                    "Design Leadership",
+                    "Design Estratégico",
+                    "Design para Produto",
+                    "Design Thinking Avançado"
+                ]
+            }
+        }
+
+        if area not in modulos:
+            return [
+                "Fundamentos da Área",
+                "Conceitos Intermediários",
+                "Práticas Avançadas",
+                "Especialização"
+            ]
+
+        return modulos[area].get(nivel, modulos[area]["intermediário"])
+
+    def _formatar_objetivos(self, palavras_chave: List[str], area: str) -> str:
+        objetivos = {
+            "programação": [
+                "Desenvolver habilidades técnicas em {}",
+                "Criar projetos práticos usando {}",
+                "Dominar conceitos de {}"
+            ],
+            "data science": [
+                "Analisar dados usando {}",
+                "Construir modelos de {}",
+                "Implementar soluções com {}"
+            ],
+            "design": [
+                "Criar interfaces usando {}",
+                "Desenvolver projetos de {}",
+                "Aplicar princípios de {}"
+            ]
+        }
+        
+        templates = objetivos.get(area, objetivos["programação"])
+        return "\n".join(
+            f"• {template.format(palavra)}"
+            for palavra, template in zip(palavras_chave[:3], templates)
+        )
+
+    def _formatar_modulos(self, modulos: List[str], tempo: float) -> str:
+        return "\n".join(
+            f"Módulo {i+1}: {modulo} ({tempo:.1f} meses)"
+            for i, modulo in enumerate(modulos)
+        )
+
+    def _gerar_projetos(self, area: str, nivel: str) -> str:
+        projetos = {
+            "iniciante": [
+                "Projeto Tutorial Guiado",
+                "Mini-Projeto Prático",
+                "Exercícios Fundamentais"
+            ],
+            "intermediário": [
+                "Projeto Individual",
+                "Projeto em Equipe",
+                "Case Study Prático"
+            ],
+            "avançado": [
+                "Projeto Complexo",
+                "Contribuição Open Source",
+                "Projeto de Pesquisa"
+            ]
+        }
+        
+        return "\n".join(f"• {projeto}" for projeto in projetos.get(nivel, projetos["intermediário"]))
+
+    def _gerar_cronograma(self, duracao: int, modulos: List[str]) -> str:
+        meses_por_modulo = duracao / len(modulos)
+        return "\n".join(
+            f"Mês {i*meses_por_modulo+1:.1f}-{(i+1)*meses_por_modulo:.1f}: {modulo}"
+            for i, modulo in enumerate(modulos)
+        )
+
+    def _gerar_marcos_avaliacao(self, nivel: str) -> str:
+        marcos = {
+            "iniciante": [
+                "Quiz de Conceitos Básicos",
+                "Exercícios Práticos",
+                "Projeto Final Básico"
+            ],
+            "intermediário": [
+                "Avaliação Técnica",
+                "Projeto Individual",
+                "Apresentação de Resultados"
+            ],
+            "avançado": [
+                "Defesa de Projeto",
+                "Contribuição Técnica",
+                "Artigo/Publicação"
+            ]
+        }
+        
+        return "\n".join(f"• {marco}" for marco in marcos.get(nivel, marcos["intermediário"]))
+
+    def _gerar_recursos(self, nivel: str, area: str, objetivo: str) -> str:
+        recursos = {
+            "iniciante": {
+                "cursos": ["Fundamentos Básicos", "Introdução Prática"],
+                "livros": ["Guia do Iniciante", "Primeiros Passos"],
+                "projetos": ["Projeto inicial guiado", "Mini-projetos práticos"]
+            },
+            "intermediário": {
+                "cursos": ["Especialização Prática", "Técnicas Avançadas"],
+                "livros": ["Guia Completo", "Estudos de Caso"],
+                "projetos": ["Projetos médios", "Desafios práticos"]
+            },
+            "avançado": {
+                "cursos": ["Masterclass", "Especialização Pro"],
+                "livros": ["Técnicas Avançadas", "Estado da Arte"],
+                "projetos": ["Projetos complexos", "Open-source"]
+            }
+        }
+
+        r = recursos.get(nivel, recursos["intermediário"])
+        return f"""
+        📚 Recursos Recomendados:
+        
+        1. Cursos:
+           - {r['cursos'][0]}
+           - {r['cursos'][1]}
+           
+        2. Material:
+           - {r['livros'][0]}
+           - {r['livros'][1]}
+           
+        3. Projetos:
+           - {r['projetos'][0]}
+           - {r['projetos'][1]}
+           
+        4. Extras:
+           - Comunidades de prática
+           - Mentoria entre pares
+           - Workshops práticos
+           - Avaliações periódicas
+        """
+
     def _formatar_historico(self) -> str:
         if not self.historico:
             return "Nenhuma trilha gerada ainda"
@@ -92,8 +314,6 @@ class GeradorTrilhaAprendizado:
             for h in self.historico[-5:]
         )
 
-    # Rest of the methods remain the same, but with added error handling and type hints
-
 def criar_interface() -> gr.Blocks:
     with gr.Blocks(theme=gr.themes.Soft()) as app:
         gr.Markdown("""
@@ -157,10 +377,10 @@ def criar_interface() -> gr.Blocks:
             5. O histórico mostra suas últimas 5 trilhas geradas
             """)
 
-        gerador = GeradorTrilhaAprendizado()  # Create single instance
+        gerador = GeradorTrilhaAprendizado()
         
         processar_btn.click(
-            fn=gerador.processar_audio,  # Use instance method
+            fn=gerador.processar_audio,
             inputs=[audio_input, nome_trilha, nivel, area, duracao, incluir_recursos],
             outputs=[transcricao, analise, historico, status]
         )