feat: criada a guia Trilhas com processamento em lote e progresso

- criada a guia Trilhas com processamento em lote e progresso por música
- simplificada a guia Trilhas para ocultar a configuração interna dos modelos

Resumo:
- 12 arquivos alterados
- 1 novos
- 11 modificados
- 0 removidos

 11 files changed, 173 insertions(+), 41 deletions(-)

Arquivos:
  - .jhonny/analises.db
  - code/cep-plugin/index.html
  - code/cep-plugin/main.js
  - code/cep-plugin/styles.css
  - code/engine/analisar_trilhas.py
  - code/engine/carregar_plano_de_edicao.py
  - code/engine/executar_scanner.py
  - code/engine/persistencia/__init__.py
  - code/engine/persistencia/repositorio_de_trilhas.py
  - code/engine/testes/test_carregar_plano_de_edicao.py
  - code/engine/testes/test_executar_scanner.py
  - code/engine/testes/test_repositorio_de_trilhas.py

code/engine/testes/test_carregar_plano_de_edicao.py

@@ -6,8 +6,10 @@ import unittest
 from pathlib import Path
 
 from engine.carregar_plano_de_edicao import carregar
+from engine.dominio import Clipe, Faixa, IntervaloDeTempo, Timeline
 from engine.persistencia import abrir_banco
 from engine.persistencia.repositorio_de_planos import RepositorioDePlanos, plano_de_dict
+from engine.persistencia.repositorio_de_timeline_sqlite import RepositorioDeTimelineSQLite
 
 
 class TesteCarregarPlanoDeEdicao(unittest.TestCase):
@@ -32,6 +34,41 @@ class TesteCarregarPlanoDeEdicao(unittest.TestCase):
         self.assertEqual(carregado["actions"][0]["kind"], "cut")
         self.assertEqual(carregado["actions"][0]["reason"], "repetição")
 
+    def test_resolve_nome_da_sequencia_para_arquivo_unico_do_video(self):
+        """Entrega ao aplicador a mídia real quando o plano histórico guardou a sequência."""
+        with tempfile.TemporaryDirectory() as pasta:
+            banco = Path(pasta) / "analises.db"
+            conexao = abrir_banco(banco)
+            RepositorioDeTimelineSQLite(conexao).registrar_timeline(Timeline(
+                identificador="video-1",
+                nome="Cópia de 0E6A8829",
+                faixas=[Faixa(
+                    identificador="video_0",
+                    nome="Vídeo 1",
+                    tipo="video",
+                    indice=0,
+                    clipes=[Clipe(
+                        identificador="clipe-1",
+                        nome="0E6A8829.MP4",
+                        intervalo_na_timeline=IntervaloDeTempo(0.0, 1018.2),
+                        intervalo_na_origem=IntervaloDeTempo(0.0, 1018.2),
+                        arquivo="/Volumes/Midia/0E6A8829.MP4",
+                    )],
+                )],
+            ))
+            repositorio = RepositorioDePlanos(conexao)
+            repositorio.registrar_plano(plano_de_dict(
+                {"source": "Cópia de 0E6A8829", "actions": [
+                    {"kind": "cut", "start": 0.0, "end": 124.79, "reason": "abertura"},
+                ]},
+                video_id="video-1",
+            ))
+            conexao.close()
+
+            carregado = carregar(banco, video_id="video-1")
+
+        self.assertEqual(carregado["source"], "/Volumes/Midia/0E6A8829.MP4")
+
 
 if __name__ == "__main__":
     unittest.main()

code/engine/testes/test_executar_scanner.py

@@ -5,6 +5,9 @@ import sys
 from pathlib import Path
 import unittest
 
+from engine.dominio import Clipe, IntervaloDeTempo
+from engine.executar_scanner import serializar_clipe_para_relatorio
+
 
 class TesteDoPontoDeEntradaDoScanner(unittest.TestCase):
     """Garante que o Scanner possa ser iniciado pelo caminho usado no painel."""
@@ -41,6 +44,22 @@ class TesteDoPontoDeEntradaDoScanner(unittest.TestCase):
 
         self.assertEqual(resultado.returncode, 0, resultado.stderr)
 
+    def test_relatorio_de_audio_preserva_caminho_e_intervalo_da_origem(self):
+        """Mantém no artefato os dados necessários para aplicar o plano depois."""
+        clipe = Clipe(
+            identificador="clipe-1",
+            nome="0E6A8829.MP4",
+            intervalo_na_timeline=IntervaloDeTempo(0.0, 100.0),
+            intervalo_na_origem=IntervaloDeTempo(20.0, 120.0),
+            arquivo="/Volumes/Midia/0E6A8829.MP4",
+        )
+
+        dados = serializar_clipe_para_relatorio(clipe)
+
+        self.assertEqual(dados["sourceFile"], "/Volumes/Midia/0E6A8829.MP4")
+        self.assertEqual(dados["inPoint"], 20.0)
+        self.assertEqual(dados["outPoint"], 120.0)
+
 
 if __name__ == "__main__":
     unittest.main()

code/engine/testes/test_repositorio_de_trilhas.py

@@ -0,0 +1,63 @@
+"""Testes do catálogo independente de trilhas musicais."""
+
+import tempfile
+import unittest
+from pathlib import Path
+
+from engine.integracoes.audio.modelos_de_analise_musical import (
+    PontuacaoDeEtiqueta,
+    ResultadoDaAnaliseMusical,
+)
+from engine.persistencia import RepositorioDeTrilhasSQLite
+
+
+class TesteRepositorioDeTrilhasSQLite(unittest.TestCase):
+    """Garante o ciclo de vida e a persistência da análise musical."""
+
+    def test_registra_pasta_atualiza_status_e_salva_etiquetas(self):
+        with tempfile.TemporaryDirectory() as diretorio:
+            pasta = Path(diretorio) / "trilhas"
+            pasta.mkdir()
+            arquivo = pasta / "tema.wav"
+            arquivo.write_bytes(b"audio de teste")
+            repositorio = RepositorioDeTrilhasSQLite(Path(diretorio) / "trilhas.db")
+
+            trilhas = repositorio.registrar_pasta_e_arquivos(pasta, (arquivo,))
+            repositorio.iniciar_analise(trilhas[0].identificador)
+            repositorio.registrar_analise(
+                trilhas[0],
+                ResultadoDaAnaliseMusical(
+                    caminho_do_arquivo=arquivo,
+                    duracao_em_segundos=12.5,
+                    generos=("Blues",),
+                    pontuacoes_de_genero=(PontuacaoDeEtiqueta("Blues", 0.91),),
+                ),
+            )
+            banco = repositorio.conexao
+            trilha = banco.execute("SELECT status, hash_do_conteudo FROM trilhas_musicais").fetchone()
+            etiqueta = banco.execute("SELECT tipo, etiqueta, confianca FROM etiquetas_musicais").fetchone()
+            banco.close()
+
+        self.assertEqual(trilha[0], "concluida")
+        self.assertEqual(len(trilha[1]), 64)
+        self.assertEqual(tuple(etiqueta), ("genero", "Blues", 0.91))
+
+    def test_reprocessamento_da_mesma_pasta_nao_duplica_trilha(self):
+        with tempfile.TemporaryDirectory() as diretorio:
+            pasta = Path(diretorio) / "trilhas"
+            pasta.mkdir()
+            arquivo = pasta / "tema.mp3"
+            arquivo.write_bytes(b"audio")
+            repositorio = RepositorioDeTrilhasSQLite(Path(diretorio) / "trilhas.db")
+
+            primeira = repositorio.registrar_pasta_e_arquivos(pasta, (arquivo,))
+            segunda = repositorio.registrar_pasta_e_arquivos(pasta, (arquivo,))
+            quantidade = repositorio.conexao.execute("SELECT COUNT(*) FROM trilhas_musicais").fetchone()[0]
+            repositorio.conexao.close()
+
+        self.assertEqual(primeira[0].identificador, segunda[0].identificador)
+        self.assertEqual(quantidade, 1)
+
+
+if __name__ == "__main__":
+    unittest.main()