joaohenrique/jhonny-editor
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

feat: Instalado essentia-tensorflow no venv whisperx-transcricao (

Browse Source 
- Instalado essentia-tensorflow no venv whisperx-transcricao (usado pelo painel CEP), corrigindo erro "A classificação musical precisa do suporte TensorFlow do Essentia" no catálogo de trilhas.
- Ligada a classificação de emoção da fala (ProviderDeEmocaoHuggingFace) ao scanner via nova flag `classificar_emocao`, e adicionado emoção/confiança como critério de desempate secundário no zoom da skill editar-por-voz.
- Zoom do caminho Python (aplicar_plano_de_edicao.py) passou a usar adjustment layer numa faixa de vídeo própria, em vez de escalar o clipe inteiro via set_clip_properties — mesma técnica já usada pelo executor .mjs do painel CEP.
- Adicionado campo "Carregar por ID" na aba Editar Vídeo do painel CEP (step 2), para carregar um plano do SQLite direto pelo plano_id quando ele não está associado a nenhum video_id conhecido (ex.: plano de um vídeo que este banco nunca escaneou).
- Trocado o campo de ID numérico por uma lista suspensa (novo listar_planos_de_edicao.py + RepositorioDePlanos.listar_todos_os_planos) que mostra data/hora e a intenção registrada pela skill em cada plano salvo, para escolher sem decorar o id.

Resumo:
- 15 arquivos alterados
- 2 novos
- 13 modificados
- 0 removidos

 13 files changed, 451 insertions(+), 65 deletions(-)

Arquivos:
  - .jhonny/analises.db
  - code/cep-plugin/index.html
  - code/cep-plugin/main.js
  - code/engine/editor/aplicador_de_plano_de_edicao.py
  - code/engine/editor/escrita/escrita_no_editor.py
  - code/engine/executar_scanner.py
  - code/engine/persistencia/repositorio_de_planos.py
  - code/engine/scanner/configuracao_visual.py
  - code/engine/testes/duplos_de_premiere.py
  - code/engine/testes/test_aplicador_de_plano_de_edicao.py
  - code/engine/testes/test_escrita_no_editor.py
  - code/plugins/premiere-pro/skills/editar-por-voz/criterios/01-leitura-do-json.md
  - code/plugins/premiere-pro/skills/editar-por-voz/criterios/05-zoom.md
  - code/engine/listar_planos_de_edicao.py
  - code/engine/testes/test_configuracao_visual_do_scanner.py
This commit is contained in:
João Henrique
2026-09-10 16:04:15 -04:00
parent 2c9bdf2ff0
commit dd341e7d4c
15 changed files with 520 additions and 64 deletions
Download Patch File Download Diff File Expand all files Collapse all files
code/engine/testes/duplos_de_premiere.py
+127 -9
View File
@@ -6,7 +6,9 @@ descompasso encontrado no projeto real entre ``inicio_na_timeline`` e
``inicio_na_origem`` do banco de análises. Implementa só as ferramentas MCP
que o módulo ``engine.editor`` usa: ``get_active_sequence``, ``split_clip``,
``remove_from_timeline``, ``remove_linked_from_timeline``,
``duplicate_linked_range_to_start``, ``set_clip_properties`` e ``add_marker``.
``duplicate_linked_range_to_start``, ``set_clip_properties``, ``add_marker``,
``add_track``, ``set_playhead_position``, ``add_adjustment_layer``,
``get_clip_at_position``, ``trim_clip`` e ``move_clip``.
"""
from __future__ import annotations
@@ -63,6 +65,7 @@ class ClienteMCPFalso(ClienteMCP):
self.chamadas: list[tuple[str, dict[str, Any]]] = []
self._proximo_id = 0
self._historico: list[dict[str, list[_ClipeFalso]]] = []
self._playhead = 0.0
self._faixas: dict[str, list[_ClipeFalso]] = {
"video_0": [self._novo_clipe(self._ARQUIVO, 0.0, 200.0, 0.0, 200.0, "clipe_unico_video")],
"audio_0": [self._novo_clipe(self._ARQUIVO, 0.0, 200.0, 0.0, 200.0, "clipe_unico_audio")],
@@ -105,6 +108,12 @@ class ClienteMCPFalso(ClienteMCP):
"set_clip_properties": self._simular_set_clip_properties,
"add_marker": self._simular_add_marker,
"undo": self._simular_undo,
"add_track": self._simular_add_track,
"set_playhead_position": self._simular_set_playhead_position,
"add_adjustment_layer": self._simular_add_adjustment_layer,
"get_clip_at_position": self._simular_get_clip_at_position,
"trim_clip": self._simular_trim_clip,
"move_clip": self._simular_move_clip,
}
simulador = despachantes.get(nome_da_ferramenta)
if simulador is None:
@@ -141,6 +150,14 @@ class ClienteMCPFalso(ClienteMCP):
"clips": [_clipe_como_dict(clipe, tipo) for clipe in self._faixas[identificador]],
}
faixas_de_video = sorted(
(identificador for identificador in self._faixas if identificador.startswith("video_")),
key=lambda identificador: int(identificador.split("_")[1]),
)
faixas_de_audio = sorted(
(identificador for identificador in self._faixas if identificador.startswith("audio_")),
key=lambda identificador: int(identificador.split("_")[1]),
)
dados = {
"id": "sequencia_falsa",
"name": "Sequência de teste",
@@ -148,8 +165,14 @@ class ClienteMCPFalso(ClienteMCP):
"frameRate": 29.97,
"frameSizeHorizontal": 3840,
"frameSizeVertical": 2160,
"videoTracks": [_faixa_como_dict("video_0", "video", 0)],
"audioTracks": [_faixa_como_dict("audio_0", "audio", 0)],
"videoTracks": [
_faixa_como_dict(identificador, "video", int(identificador.split("_")[1]))
for identificador in faixas_de_video
],
"audioTracks": [
_faixa_como_dict(identificador, "audio", int(identificador.split("_")[1]))
for identificador in faixas_de_audio
],
}
return {"structuredContent": {"data": dados}}
@@ -226,7 +249,13 @@ class ClienteMCPFalso(ClienteMCP):
return {"removed": True, "verified": True}
def _simular_gancho_vinculado_no_inicio(self, argumentos: dict[str, Any]) -> dict[str, Any]:
"""Duplica um par isolado no início e preserva sua ocorrência original."""
"""Duplica um par já isolado no início e preserva sua ocorrência original.
Espelha o bridge real: não recebe limites de origem à parte, lê o
in/out do próprio clipe. Por isso os identificadores precisam já
corresponder a um par isolado por ``split_clip`` — o mesmo clipe
inteiro, sem sobra de trecho vizinho.
"""
identificadores = argumentos["node_ids"]
encontrados: list[tuple[str, _ClipeFalso]] = []
for identificador_da_faixa, clipes in self._faixas.items():
@@ -239,11 +268,11 @@ class ClienteMCPFalso(ClienteMCP):
fins = {round(clipe.fim_na_timeline, 6) for _, clipe in encontrados}
if len(inicios) != 1 or len(fins) != 1:
raise ErroDeFerramentaMCP("O par não ocupa o mesmo intervalo.")
if next(iter(inicios)) <= 0.0:
raise ErroDeFerramentaMCP("O trecho pedido já está no início da sequência.")
self._salvar_estado()
inicio_na_origem = float(argumentos["source_in_seconds"])
fim_na_origem = float(argumentos["source_out_seconds"])
duracao = fim_na_origem - inicio_na_origem
duracao = next(iter(fins)) - next(iter(inicios))
novos_ids: list[str] = []
for identificador_da_faixa, clipe in encontrados:
faixa = self._faixas[identificador_da_faixa]
@@ -254,8 +283,8 @@ class ClienteMCPFalso(ClienteMCP):
clipe.nome,
0.0,
duracao,
inicio_na_origem,
fim_na_origem,
clipe.inicio_na_origem,
clipe.fim_na_origem,
)
faixa.append(novo)
faixa.sort(key=lambda item: item.inicio_na_timeline)
@@ -267,6 +296,95 @@ class ClienteMCPFalso(ClienteMCP):
del argumentos
return {"updated": True}
def _simular_add_track(self, argumentos: dict[str, Any]) -> dict[str, Any]:
"""Cria ``count`` faixas de vídeo novas, vazias, no topo da pilha.
Espelha ``add_track`` do bridge real (usado pelo `.mjs` para criar a
track de camada de ajuste): devolve ``totalTracks`` já contando as
novas, de forma que ``totalTracks - 1`` seja o índice da última
faixa criada.
"""
if argumentos.get("track_type") != "video":
raise ErroDeFerramentaMCP("Este dublê só simula add_track para vídeo.")
contagem = int(argumentos.get("count", 1))
indices_existentes = [
int(identificador.split("_")[1])
for identificador in self._faixas
if identificador.startswith("video_")
]
proximo_indice = max(indices_existentes, default=-1) + 1
for deslocamento in range(contagem):
self._faixas[f"video_{proximo_indice + deslocamento}"] = []
total_de_faixas_de_video = proximo_indice + contagem
return {"totalTracks": total_de_faixas_de_video}
def _simular_set_playhead_position(self, argumentos: dict[str, Any]) -> dict[str, Any]:
"""Guarda a posição do playhead, usada por :meth:`_simular_add_adjustment_layer`."""
self._playhead = float(argumentos["time_seconds"])
return {"positioned": True}
def _simular_add_adjustment_layer(self, argumentos: dict[str, Any]) -> dict[str, Any]:
"""Cria uma camada de ajuste na track pedida, no instante atual do playhead.
A camada nasce com uma duração fixa arbitrária (o `.mjs` real conta
com isso: sempre chama ``trim_clip``/``move_clip`` em seguida para
ajustar duração e posição definitivas).
"""
indice_da_faixa = int(argumentos["track_index"])
identificador_da_faixa = self._identificador_da_faixa(indice_da_faixa, "video")
if identificador_da_faixa not in self._faixas:
raise ErroDeFerramentaMCP(f"Faixa de vídeo inexistente: {identificador_da_faixa!r}.")
duracao_inicial = 5.0
clipe = self._novo_clipe(
"Adjustment Layer",
self._playhead,
self._playhead + duracao_inicial,
self._playhead,
self._playhead + duracao_inicial,
)
self._faixas[identificador_da_faixa].append(clipe)
self._faixas[identificador_da_faixa].sort(key=lambda item: item.inicio_na_timeline)
return {"added": True, "nodeId": clipe.identificador}
def _simular_get_clip_at_position(self, argumentos: dict[str, Any]) -> dict[str, Any]:
"""Devolve o clipe da faixa pedida que cobre ``time_seconds``."""
identificador_da_faixa = self._identificador_da_faixa(argumentos["track_index"], argumentos["track_type"])
instante = float(argumentos["time_seconds"])
faixa = self._faixas.get(identificador_da_faixa, [])
clipe = next(
(c for c in faixa if c.inicio_na_timeline <= instante < c.fim_na_timeline), None
)
if clipe is None:
raise ErroDeFerramentaMCP(f"Nenhum clipe em {identificador_da_faixa!r} no instante {instante}s.")
return {"nodeId": clipe.identificador}
def _simular_trim_clip(self, argumentos: dict[str, Any]) -> dict[str, Any]:
"""Ajusta a duração do clipe, medida a partir do próprio início atual."""
clipe = self._localizar_clipe(argumentos["node_id"])
nova_duracao = float(argumentos["new_out_seconds"])
clipe.fim_na_timeline = clipe.inicio_na_timeline + nova_duracao
clipe.fim_na_origem = clipe.inicio_na_origem + nova_duracao
return {"trimmed": True}
def _simular_move_clip(self, argumentos: dict[str, Any]) -> dict[str, Any]:
"""Move o clipe para ``new_start_seconds``, preservando sua duração."""
clipe = self._localizar_clipe(argumentos["node_id"])
duracao = clipe.fim_na_timeline - clipe.inicio_na_timeline
novo_inicio = float(argumentos["new_start_seconds"])
clipe.inicio_na_timeline = novo_inicio
clipe.fim_na_timeline = novo_inicio + duracao
for faixa in self._faixas.values():
faixa.sort(key=lambda item: item.inicio_na_timeline)
return {"moved": True}
def _localizar_clipe(self, identificador_do_clipe: str) -> _ClipeFalso:
"""Encontra um clipe pelo identificador em qualquer faixa, ou levanta erro."""
for faixa in self._faixas.values():
for clipe in faixa:
if clipe.identificador == identificador_do_clipe:
return clipe
raise ErroDeFerramentaMCP(f"Clipe não encontrado: {identificador_do_clipe!r}.")
def _simular_add_marker(self, argumentos: dict[str, Any]) -> dict[str, Any]:
"""Aceita a criação de marcador sem manter estado (a chamada já fica em :attr:`chamadas`)."""
del argumentos