feat: criado monitoramento contínuo de trilhas com varredura recur
- criado monitoramento contínuo de trilhas com varredura recursiva e baixa prioridade - gerado e validado plano editorial revisável do depoimento da Erika sem aplicação na timeline - adicionada leitura e comparação estrutural da timeline após aplicar planos de edição - limitadas as classificações de trilhas às duas maiores probabilidades de cada categoria - limpo o catálogo musical para reiniciar as análises sem remover dados de vídeo Resumo: - 34 arquivos alterados - 6 novos - 28 modificados - 0 removidos 28 files changed, 833 insertions(+), 75 deletions(-) Arquivos: - .jhonny/analises.db - code/cep-plugin/index.html - code/cep-plugin/main.js - code/engine/analisar_trilhas.py - code/engine/aplicar_plano_de_edicao.py - code/engine/consultar_detalhes_de_trilha.py - code/engine/editor/__init__.py - code/engine/editor/aplicador_de_plano_de_edicao.py - code/engine/editor/backup_de_sequencia.py - code/engine/editor/escrita/escrita_no_editor.py - code/engine/editor/modelos.py - code/engine/editor/validacao_semantica.py - code/engine/integracoes/audio/classificador_de_musica_essentia.py - code/engine/integracoes/audio/modelos_de_analise_musical.py - code/engine/integracoes/audio/provider_de_analise_musical_essentia.py - code/engine/persistencia/esquema.py - code/engine/persistencia/repositorio_de_trilhas.py - code/engine/testes/duplos_de_premiere.py - code/engine/testes/test_aplicador_de_plano_de_edicao.py - code/engine/testes/test_aplicar_plano_de_edicao.py - code/engine/testes/test_escrita_no_editor.py - code/engine/testes/test_leitor_de_plano_de_edicao.py - code/engine/testes/test_validador_semantico_de_plano.py - code/plugins/premiere-pro/skills/editar-por-voz/SKILL.md - code/plugins/premiere-pro/skills/editar-por-voz/criterios/08-formato-de-saida.md - code/plugins/premiere-pro/skills/editar-por-voz/criterios/10-revisao-humana.md - code/src/tools/timeline.ts - code/tests/tools/tool-modules.test.ts - .jhonny/planos/ - code/.jhonny/analises.db-shm - code/.jhonny/analises.db-wal - code/engine/editor/verificador_da_aplicacao.py - code/engine/testes/test_verificador_da_aplicacao.py - code/plugins/premiere-pro/skills/editar-por-voz/criterios/11-gancho.md
This commit is contained in:
João Henrique
@@ -1,4 +1,4 @@
|
||||
"""Aplicação de planos de edição (cortes, zooms, marcadores) na timeline do Premiere.
|
||||
"""Aplicação de planos de edição (cortes, ganchos e destaques) no Premiere.
|
||||
|
||||
Lê o JSON de ações produzido pelas skills de seleção de trechos
|
||||
(``kind``/``start``/``end``/``params``/``reason``), traduz os tempos de
|
||||
@@ -19,6 +19,7 @@ from .leitura import LeitorDePlanoDeEdicao
|
||||
from .mapeamento import MapeadorDeTempoDeOrigemParaTimeline
|
||||
from .modelos import AcaoDeEdicao, PlanoDeEdicao, TipoDeAcao
|
||||
from .validacao_semantica import ProblemaSemanticoDoPlano, ValidadorSemanticoDePlano
|
||||
from .verificador_da_aplicacao import ResultadoDaVerificacao, VerificadorDaAplicacao
|
||||
|
||||
__all__ = [
|
||||
"AcaoDeEdicao",
|
||||
@@ -37,4 +38,6 @@ __all__ = [
|
||||
"ResultadoDaAplicacao",
|
||||
"TipoDeAcao",
|
||||
"ValidadorSemanticoDePlano",
|
||||
"ResultadoDaVerificacao",
|
||||
"VerificadorDaAplicacao",
|
||||
]
|
||||
|
||||
@@ -60,7 +60,9 @@ class AplicadorDePlanoDeEdicao:
|
||||
tudo que vem depois dele. Processar do fim para o começo garante que
|
||||
a posição de um corte ainda não aplicado nunca é afetada pelos
|
||||
cortes já aplicados.
|
||||
2. Marcadores e zooms por último, depois que a timeline já está no
|
||||
2. O gancho para abertura vem depois dos cortes. Ele localiza o trecho por
|
||||
tempo da mídia original e cria uma cópia no começo da sequência.
|
||||
3. Marcadores e zooms por último, depois que a timeline já está no
|
||||
formato final. Zoom (``set_clip_properties``) muda uma propriedade do
|
||||
*clipe inteiro*, não de um trecho dele — se dois zooms caíssem em
|
||||
instantes diferentes do mesmo clipe ainda não dividido pelos cortes,
|
||||
@@ -107,10 +109,15 @@ class AplicadorDePlanoDeEdicao:
|
||||
|
||||
def aplicar(self, plano: PlanoDeEdicao) -> ResultadoDaAplicacao:
|
||||
"""Aplica todas as ações de ``plano`` e devolve o resultado de cada uma."""
|
||||
pontuais = [acao for acao in plano.acoes if acao.tipo is not TipoDeAcao.CORTE]
|
||||
ganchos = plano.acoes_do_tipo(TipoDeAcao.GANCHO)
|
||||
pontuais = [
|
||||
acao for acao in plano.acoes
|
||||
if acao.tipo not in {TipoDeAcao.CORTE, TipoDeAcao.GANCHO}
|
||||
]
|
||||
cortes = sorted(plano.acoes_do_tipo(TipoDeAcao.CORTE), key=lambda acao: acao.inicio, reverse=True)
|
||||
|
||||
resultados = [self._aplicar_corte(acao, plano.arquivo_de_origem) for acao in cortes]
|
||||
resultados += [self._aplicar_gancho(acao, plano.arquivo_de_origem) for acao in ganchos]
|
||||
resultados += [self._aplicar_acao_pontual(acao, plano.arquivo_de_origem) for acao in pontuais]
|
||||
return ResultadoDaAplicacao(tuple(resultados))
|
||||
|
||||
@@ -189,6 +196,78 @@ class AplicadorDePlanoDeEdicao:
|
||||
except ErroDeEdicao as erro:
|
||||
return ResultadoDaAcao(acao, False, str(erro))
|
||||
|
||||
def _aplicar_gancho(self, acao: AcaoDeEdicao, arquivo_de_origem: str) -> ResultadoDaAcao:
|
||||
"""Recorta uma cópia de um par simples e a insere na abertura."""
|
||||
try:
|
||||
faixas = self._timeline_atual().faixas
|
||||
faixas_afetadas = [
|
||||
faixa for faixa in faixas
|
||||
if any(
|
||||
self._sobrepoe(clipe, acao.inicio, acao.fim)
|
||||
for clipe in self._clipes_do_arquivo(faixa, arquivo_de_origem)
|
||||
)
|
||||
]
|
||||
videos = [faixa for faixa in faixas_afetadas if faixa.tipo == "video"]
|
||||
audios = [faixa for faixa in faixas_afetadas if faixa.tipo == "audio"]
|
||||
if len(videos) != 1 or len(audios) != 1:
|
||||
raise ErroDeMapeamentoDeTempo(
|
||||
"A ação hook exige exatamente uma faixa de vídeo e uma de áudio com o trecho de origem."
|
||||
)
|
||||
faixas_adicionais_ocupadas = [
|
||||
faixa.identificador
|
||||
for faixa in faixas
|
||||
if faixa not in faixas_afetadas and faixa.clipes
|
||||
]
|
||||
if faixas_adicionais_ocupadas:
|
||||
raise ErroDeMapeamentoDeTempo(
|
||||
"A ação hook exige uma sequência simples; há conteúdo nas faixas adicionais: "
|
||||
+ ", ".join(faixas_adicionais_ocupadas)
|
||||
)
|
||||
for faixa in faixas_afetadas:
|
||||
afetados = [
|
||||
clipe for clipe in self._clipes_do_arquivo(faixa, arquivo_de_origem)
|
||||
if self._sobrepoe(clipe, acao.inicio, acao.fim)
|
||||
]
|
||||
if len(afetados) != 1:
|
||||
raise ErroDeMapeamentoDeTempo(
|
||||
f"A ação hook precisa estar contida em um único clipe da faixa {faixa.identificador!r}."
|
||||
)
|
||||
intervalo_na_origem = afetados[0].intervalo_na_origem
|
||||
if (
|
||||
intervalo_na_origem is None
|
||||
or acao.inicio < intervalo_na_origem.inicio - _TOLERANCIA_DE_BORDA_EM_SEGUNDOS
|
||||
or acao.fim > intervalo_na_origem.fim + _TOLERANCIA_DE_BORDA_EM_SEGUNDOS
|
||||
):
|
||||
raise ErroDeMapeamentoDeTempo(
|
||||
f"A ação hook ultrapassa o clipe da faixa {faixa.identificador!r}."
|
||||
)
|
||||
inicio_na_timeline = self._borda_de_entrada(afetados[0], acao.inicio)
|
||||
if inicio_na_timeline <= _TOLERANCIA_DE_BORDA_EM_SEGUNDOS:
|
||||
raise ErroDeMapeamentoDeTempo("O trecho da ação hook já está no início da sequência.")
|
||||
if min(clipe.intervalo_na_timeline.inicio for clipe in faixa.clipes) > _TOLERANCIA_DE_BORDA_EM_SEGUNDOS:
|
||||
raise ErroDeMapeamentoDeTempo(
|
||||
f"A faixa {faixa.identificador!r} não começa em 0s; o gancho foi recusado."
|
||||
)
|
||||
|
||||
alvos = [
|
||||
clipe
|
||||
for faixa in faixas_afetadas
|
||||
for clipe in self._clipes_do_arquivo(faixa, arquivo_de_origem)
|
||||
if self._sobrepoe(clipe, acao.inicio, acao.fim)
|
||||
]
|
||||
if len(alvos) != 2:
|
||||
raise ErroDeMapeamentoDeTempo(
|
||||
"O Premiere não localizou exatamente um clipe de vídeo e um de áudio para a ação hook."
|
||||
)
|
||||
self.escrita.duplicar_trecho_vinculado_para_o_inicio(
|
||||
[clipe.identificador for clipe in alvos],
|
||||
acao.inicio,
|
||||
acao.fim,
|
||||
)
|
||||
return ResultadoDaAcao(acao, True, "gancho vinculado duplicado no início")
|
||||
except ErroDeEdicao as erro:
|
||||
return ResultadoDaAcao(acao, False, str(erro))
|
||||
|
||||
def _preparar_alvos_da_faixa(
|
||||
self, faixa: Faixa, acao: AcaoDeEdicao, arquivo_de_origem: str
|
||||
) -> list[Clipe]:
|
||||
|
||||
@@ -21,8 +21,8 @@ class BackupDaSequencia:
|
||||
def criar_backup(self, identificador_da_sequencia: str) -> bool:
|
||||
"""Duplica a sequência. Devolve ``True`` se conseguiu, ``False`` se o Premiere recusou.
|
||||
|
||||
Não levanta exceção numa recusa: a engine registra a falha e continua
|
||||
a aplicação solicitada, deixando a ausência de backup visível.
|
||||
Não levanta exceção numa recusa: o chamador decide se a ação pode
|
||||
continuar. Ganchos estruturais são bloqueados sem essa confirmação.
|
||||
"""
|
||||
try:
|
||||
self.cliente_mcp.chamar("duplicate_sequence", {"sequence_id": identificador_da_sequencia})
|
||||
|
||||
@@ -1,8 +1,9 @@
|
||||
"""Escrita de mutações na sequência ativa do Premiere via MCP.
|
||||
|
||||
Isola o nome das ferramentas MCP e o formato de argumentos externos
|
||||
(``split_clip``, ``remove_from_timeline``, ``remove_linked_from_timeline``, ``set_clip_properties``,
|
||||
``add_marker``) do resto do domínio. Quem chama esta classe fala só em
|
||||
(``split_clip``, ``remove_from_timeline``, ``remove_linked_from_timeline``,
|
||||
``duplicate_linked_range_to_start``, ``set_clip_properties``, ``add_marker``) do
|
||||
resto do domínio. Quem chama esta classe fala só em
|
||||
segundos de timeline, identificador de clipe e fator de escala — nunca em
|
||||
nomes de ferramenta ou ticks do Premiere.
|
||||
"""
|
||||
@@ -113,6 +114,34 @@ class EscritaNoEditor:
|
||||
f"Não foi possível remover o par vinculado {identificadores_dos_clipes!r}: {erro}"
|
||||
) from erro
|
||||
|
||||
def duplicar_trecho_vinculado_para_o_inicio(
|
||||
self,
|
||||
identificadores_dos_clipes: list[str],
|
||||
inicio_na_origem: float,
|
||||
fim_na_origem: float,
|
||||
) -> None:
|
||||
"""Copia parte de um par de vídeo e áudio para o início da sequência.
|
||||
|
||||
A ferramenta externa executa inserção com ripple, mantém a ocorrência
|
||||
original intacta e confirma posição, duração e sincronismo. A operação
|
||||
é recusada quando os identificadores não formam um par simples.
|
||||
"""
|
||||
if len(identificadores_dos_clipes) != 2:
|
||||
raise ErroDeEscritaNoEditor("O gancho exige exatamente um clipe de vídeo e um de áudio.")
|
||||
try:
|
||||
self.cliente_mcp.chamar(
|
||||
"duplicate_linked_range_to_start",
|
||||
{
|
||||
"node_ids": identificadores_dos_clipes,
|
||||
"source_in_seconds": inicio_na_origem,
|
||||
"source_out_seconds": fim_na_origem,
|
||||
},
|
||||
)
|
||||
except ErroDeFerramentaMCP as erro:
|
||||
raise ErroDeEscritaNoEditor(
|
||||
f"Não foi possível duplicar o par vinculado {identificadores_dos_clipes!r} no início: {erro}"
|
||||
) from erro
|
||||
|
||||
def aplicar_zoom(self, identificador_do_clipe: str, fator_de_escala: float) -> None:
|
||||
"""Aplica um punch-in no clipe, escalando-o por ``fator_de_escala`` (1.0 = tamanho original).
|
||||
|
||||
|
||||
@@ -14,12 +14,13 @@ from typing import Any
|
||||
|
||||
|
||||
class TipoDeAcao(str, Enum):
|
||||
"""Os quatro tipos de ação que o plano de edição pode descrever."""
|
||||
"""Os tipos de ação que o plano de edição pode descrever."""
|
||||
|
||||
CORTE = "cut"
|
||||
ZOOM = "zoom"
|
||||
TEXTO = "text"
|
||||
MARCADOR = "marker"
|
||||
GANCHO = "hook"
|
||||
|
||||
|
||||
@dataclass(frozen=True)
|
||||
@@ -46,6 +47,13 @@ class AcaoDeEdicao:
|
||||
)
|
||||
if not self.motivo.strip():
|
||||
raise ValueError("Ação inválida: motivo não pode ser vazio.")
|
||||
if self.tipo is TipoDeAcao.GANCHO:
|
||||
destino = self.parametros.get("target", 0)
|
||||
manter_original = self.parametros.get("keep_original", True)
|
||||
if isinstance(destino, bool) or not isinstance(destino, (int, float)) or float(destino) != 0.0:
|
||||
raise ValueError("Gancho inválido: params.target precisa ser 0 nesta versão.")
|
||||
if manter_original is not True:
|
||||
raise ValueError("Gancho inválido: params.keep_original precisa ser true.")
|
||||
|
||||
@property
|
||||
def duracao(self) -> float:
|
||||
@@ -63,6 +71,16 @@ class PlanoDeEdicao:
|
||||
def __post_init__(self) -> None:
|
||||
if not self.arquivo_de_origem.strip():
|
||||
raise ValueError("Plano de edição inválido: arquivo de origem não informado.")
|
||||
ganchos = self.acoes_do_tipo(TipoDeAcao.GANCHO)
|
||||
if len(ganchos) > 1:
|
||||
raise ValueError("Plano de edição inválido: esta versão aceita somente uma ação hook.")
|
||||
if ganchos:
|
||||
gancho = ganchos[0]
|
||||
for acao in self.acoes:
|
||||
if acao is gancho:
|
||||
continue
|
||||
if acao.inicio < gancho.fim and gancho.inicio < acao.fim:
|
||||
raise ValueError("Plano de edição inválido: outra ação não pode sobrepor o trecho do hook.")
|
||||
|
||||
def acoes_do_tipo(self, tipo: TipoDeAcao) -> tuple[AcaoDeEdicao, ...]:
|
||||
"""Devolve, na ordem original, só as ações do tipo informado."""
|
||||
|
||||
@@ -1,4 +1,4 @@
|
||||
"""Validação semântica das bordas de cortes antes de alterar a timeline."""
|
||||
"""Validação semântica de cortes e ganchos antes de alterar a timeline."""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
@@ -21,7 +21,7 @@ class ProblemaSemanticoDoPlano:
|
||||
|
||||
|
||||
class ValidadorSemanticoDePlano:
|
||||
"""Protege palavras, frases completas e respiros nas emendas de cortes."""
|
||||
"""Protege palavras, frases completas e respiros nas emendas editoriais."""
|
||||
|
||||
_TOLERANCIA_EM_SEGUNDOS = 0.01
|
||||
_PONTUACAO_DE_FECHAMENTO = (".", "!", "?", "…")
|
||||
@@ -37,12 +37,17 @@ class ValidadorSemanticoDePlano:
|
||||
plano: PlanoDeEdicao,
|
||||
falas: tuple[SegmentoDeTranscricao, ...],
|
||||
) -> tuple[ProblemaSemanticoDoPlano, ...]:
|
||||
"""Devolve todos os problemas semânticos encontrados nas ações de corte."""
|
||||
"""Devolve os problemas semânticos encontrados em cortes e ganchos."""
|
||||
cortes = tuple(
|
||||
(indice, acao)
|
||||
for indice, acao in enumerate(plano.acoes)
|
||||
if acao.tipo is TipoDeAcao.CORTE
|
||||
)
|
||||
ganchos = tuple(
|
||||
(indice, acao)
|
||||
for indice, acao in enumerate(plano.acoes)
|
||||
if acao.tipo is TipoDeAcao.GANCHO
|
||||
)
|
||||
palavras = tuple(
|
||||
sorted(
|
||||
(palavra for fala in falas for palavra in fala.palavras),
|
||||
@@ -54,6 +59,9 @@ class ValidadorSemanticoDePlano:
|
||||
problemas.extend(self._validar_palavras_interceptadas(indice, corte, palavras))
|
||||
problemas.extend(self._validar_borda_inicial(indice, corte, cortes, palavras))
|
||||
problemas.extend(self._validar_borda_final(indice, corte, cortes, falas, palavras))
|
||||
for indice, gancho in ganchos:
|
||||
problemas.extend(self._validar_palavras_interceptadas(indice, gancho, palavras))
|
||||
problemas.extend(self._validar_frase_do_gancho(indice, gancho, falas, palavras))
|
||||
return tuple(problemas)
|
||||
|
||||
def garantir_valido(
|
||||
@@ -61,7 +69,7 @@ class ValidadorSemanticoDePlano:
|
||||
plano: PlanoDeEdicao,
|
||||
falas: tuple[SegmentoDeTranscricao, ...],
|
||||
) -> None:
|
||||
"""Levanta erro explicativo quando qualquer corte ameaça a fala mantida."""
|
||||
"""Levanta erro explicativo quando uma emenda ameaça a integridade da fala."""
|
||||
problemas = self.validar(plano, falas)
|
||||
if not problemas:
|
||||
return
|
||||
@@ -70,6 +78,71 @@ class ValidadorSemanticoDePlano:
|
||||
"Plano bloqueado pela validação de integridade da fala: " + detalhes
|
||||
)
|
||||
|
||||
def _validar_frase_do_gancho(
|
||||
self,
|
||||
indice: int,
|
||||
gancho: AcaoDeEdicao,
|
||||
falas: tuple[SegmentoDeTranscricao, ...],
|
||||
palavras: tuple[PalavraDeTranscricao, ...],
|
||||
) -> list[ProblemaSemanticoDoPlano]:
|
||||
"""Confirma que o gancho duplicado começa e termina como uma fala completa."""
|
||||
contidas = tuple(
|
||||
palavra for palavra in palavras
|
||||
if gancho.inicio - self._TOLERANCIA_EM_SEGUNDOS <= palavra.inicio
|
||||
and palavra.fim <= gancho.fim + self._TOLERANCIA_EM_SEGUNDOS
|
||||
)
|
||||
if not contidas:
|
||||
return [ProblemaSemanticoDoPlano(
|
||||
codigo="gancho_sem_fala",
|
||||
mensagem=f"ação {indice + 1}: o trecho do gancho não contém palavras temporizadas",
|
||||
indice_da_acao=indice,
|
||||
instante=gancho.inicio,
|
||||
)]
|
||||
|
||||
primeira, ultima = contidas[0], contidas[-1]
|
||||
problemas: list[ProblemaSemanticoDoPlano] = []
|
||||
if primeira.inicio - gancho.inicio < self._margem_minima - self._TOLERANCIA_EM_SEGUNDOS:
|
||||
problemas.append(ProblemaSemanticoDoPlano(
|
||||
codigo="margem_inicial_do_gancho_insuficiente",
|
||||
mensagem=(
|
||||
f"ação {indice + 1}: deixe ao menos {self._margem_minima:.2f}s antes "
|
||||
f'da primeira palavra do gancho "{primeira.texto}"'
|
||||
),
|
||||
indice_da_acao=indice,
|
||||
instante=gancho.inicio,
|
||||
))
|
||||
if gancho.fim - ultima.fim < self._margem_minima - self._TOLERANCIA_EM_SEGUNDOS:
|
||||
problemas.append(ProblemaSemanticoDoPlano(
|
||||
codigo="margem_final_do_gancho_insuficiente",
|
||||
mensagem=(
|
||||
f"ação {indice + 1}: deixe ao menos {self._margem_minima:.2f}s após "
|
||||
f'a última palavra do gancho "{ultima.texto}"'
|
||||
),
|
||||
indice_da_acao=indice,
|
||||
instante=gancho.fim,
|
||||
))
|
||||
fala_inicial = self._fala_da_palavra(primeira, falas)
|
||||
primeira_letra = next((letra for letra in primeira.texto if letra.isalpha()), "")
|
||||
comeca_no_meio = (
|
||||
fala_inicial is not None
|
||||
and primeira.inicio > fala_inicial.inicio + self._TOLERANCIA_EM_SEGUNDOS
|
||||
) or bool(primeira_letra and primeira_letra.islower())
|
||||
if comeca_no_meio:
|
||||
problemas.append(ProblemaSemanticoDoPlano(
|
||||
codigo="gancho_comeca_no_meio_da_frase",
|
||||
mensagem=f'ação {indice + 1}: o gancho começa em "{primeira.texto}", no meio da frase',
|
||||
indice_da_acao=indice,
|
||||
instante=gancho.inicio,
|
||||
))
|
||||
if not ultima.texto.rstrip().endswith(self._PONTUACAO_DE_FECHAMENTO):
|
||||
problemas.append(ProblemaSemanticoDoPlano(
|
||||
codigo="gancho_termina_no_meio_da_frase",
|
||||
mensagem=f'ação {indice + 1}: o gancho termina em "{ultima.texto}" sem concluir a frase',
|
||||
indice_da_acao=indice,
|
||||
instante=gancho.fim,
|
||||
))
|
||||
return problemas
|
||||
|
||||
def _validar_palavras_interceptadas(
|
||||
self,
|
||||
indice: int,
|
||||
|
||||
@@ -0,0 +1,183 @@
|
||||
"""Verificação estrutural da timeline depois da aplicação de um plano.
|
||||
|
||||
Compara a cobertura de origem que deveria sobreviver aos cortes com a
|
||||
cobertura realmente lida no Premiere depois da mutação. A verificação não
|
||||
avalia pixels, áudio ou qualidade editorial; ela detecta sobras, lacunas e
|
||||
desalinhamentos estruturais em cada tipo de faixa.
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
from dataclasses import dataclass
|
||||
|
||||
from ..dominio import Clipe, Faixa, IntervaloDeTempo, Timeline
|
||||
from .modelos import PlanoDeEdicao, TipoDeAcao
|
||||
|
||||
|
||||
_TOLERANCIA_EM_SEGUNDOS = 0.05
|
||||
|
||||
|
||||
@dataclass(frozen=True)
|
||||
class ResultadoDaVerificacao:
|
||||
"""Resultado da comparação entre a timeline esperada e a timeline lida."""
|
||||
|
||||
aprovada: bool
|
||||
divergencias: tuple[str, ...] = ()
|
||||
avisos: tuple[str, ...] = ()
|
||||
|
||||
@property
|
||||
def mensagem(self) -> str:
|
||||
"""Resume a verificação em uma mensagem adequada para o histórico."""
|
||||
if self.aprovada:
|
||||
mensagem = "verificação pós-aplicação aprovada"
|
||||
else:
|
||||
mensagem = "verificação pós-aplicação reprovada: " + " | ".join(self.divergencias)
|
||||
if self.avisos:
|
||||
mensagem += "; avisos: " + " | ".join(self.avisos)
|
||||
return mensagem
|
||||
|
||||
|
||||
class VerificadorDaAplicacao:
|
||||
"""Confere se a cobertura de mídia depois da aplicação bate com o plano."""
|
||||
|
||||
def __init__(self, tolerancia_em_segundos: float = _TOLERANCIA_EM_SEGUNDOS) -> None:
|
||||
"""Configura a tolerância de arredondamento do Premiere."""
|
||||
if tolerancia_em_segundos < 0:
|
||||
raise ValueError("A tolerância da verificação não pode ser negativa.")
|
||||
self._tolerancia = tolerancia_em_segundos
|
||||
|
||||
def verificar(
|
||||
self,
|
||||
timeline_antes: Timeline,
|
||||
timeline_depois: Timeline,
|
||||
plano: PlanoDeEdicao,
|
||||
) -> ResultadoDaVerificacao:
|
||||
"""Compara os intervalos de origem sobreviventes antes e depois da aplicação."""
|
||||
tipos_de_faixa = {faixa.tipo for faixa in timeline_antes.faixas}
|
||||
divergencias: list[str] = []
|
||||
avisos: list[str] = []
|
||||
cortes = tuple(
|
||||
acao for acao in plano.acoes if acao.tipo is TipoDeAcao.CORTE
|
||||
)
|
||||
for tipo_de_faixa in sorted(tipos_de_faixa):
|
||||
esperados = self._intervalos_esperados(
|
||||
timeline_antes, tipo_de_faixa, plano.arquivo_de_origem, cortes
|
||||
)
|
||||
encontrados = self._intervalos_da_timeline(
|
||||
timeline_depois, tipo_de_faixa, plano.arquivo_de_origem
|
||||
)
|
||||
if not self._intervalos_equivalentes(esperados, encontrados):
|
||||
divergencias.append(
|
||||
f"faixa {tipo_de_faixa}: esperado {self._formatar_intervalos(esperados)}, "
|
||||
f"encontrado {self._formatar_intervalos(encontrados)}"
|
||||
)
|
||||
avisos.extend(self._avisar_material_posterior_à_ultima_acao(
|
||||
timeline_depois, plano, tipo_de_faixa
|
||||
))
|
||||
return ResultadoDaVerificacao(not divergencias, tuple(divergencias), tuple(avisos))
|
||||
|
||||
def _avisar_material_posterior_à_ultima_acao(
|
||||
self, timeline: Timeline, plano: PlanoDeEdicao, tipo_de_faixa: str
|
||||
) -> list[str]:
|
||||
"""Sinaliza material depois da última ação para revisão editorial."""
|
||||
if not plano.acoes:
|
||||
return []
|
||||
ultima_acao = max(plano.acoes, key=lambda acao: acao.fim)
|
||||
if ultima_acao.tipo is not TipoDeAcao.CORTE:
|
||||
return []
|
||||
sobras = [
|
||||
clipe.intervalo_na_origem.fim
|
||||
for faixa in timeline.faixas
|
||||
if faixa.tipo == tipo_de_faixa
|
||||
for clipe in self._clipes_do_arquivo(faixa, plano.arquivo_de_origem)
|
||||
if clipe.intervalo_na_origem.inicio >= ultima_acao.fim - self._tolerancia
|
||||
and clipe.intervalo_na_origem.fim > ultima_acao.fim + self._tolerancia
|
||||
]
|
||||
if not sobras:
|
||||
return []
|
||||
return [
|
||||
f"faixa {tipo_de_faixa}: há material após a última ação, "
|
||||
f"a partir de {ultima_acao.fim:.2f}s; conferir possível sobra"
|
||||
]
|
||||
|
||||
def _intervalos_esperados(
|
||||
self,
|
||||
timeline: Timeline,
|
||||
tipo_de_faixa: str,
|
||||
arquivo_de_origem: str,
|
||||
cortes: tuple,
|
||||
) -> tuple[tuple[float, float], ...]:
|
||||
intervalos: list[tuple[float, float]] = []
|
||||
for faixa in timeline.faixas:
|
||||
if faixa.tipo != tipo_de_faixa:
|
||||
continue
|
||||
for clipe in self._clipes_do_arquivo(faixa, arquivo_de_origem):
|
||||
intervalos.extend(self._subtrair_cortes(clipe.intervalo_na_origem, cortes))
|
||||
return self._normalizar_intervalos(intervalos)
|
||||
|
||||
def _intervalos_da_timeline(
|
||||
self, timeline: Timeline, tipo_de_faixa: str, arquivo_de_origem: str
|
||||
) -> tuple[tuple[float, float], ...]:
|
||||
intervalos = [
|
||||
(clipe.intervalo_na_origem.inicio, clipe.intervalo_na_origem.fim)
|
||||
for faixa in timeline.faixas
|
||||
if faixa.tipo == tipo_de_faixa
|
||||
for clipe in self._clipes_do_arquivo(faixa, arquivo_de_origem)
|
||||
]
|
||||
return self._normalizar_intervalos(intervalos)
|
||||
|
||||
def _subtrair_cortes(self, intervalo: IntervaloDeTempo, cortes: tuple) -> list[tuple[float, float]]:
|
||||
partes = [(intervalo.inicio, intervalo.fim)]
|
||||
for corte in cortes:
|
||||
novas_partes: list[tuple[float, float]] = []
|
||||
for inicio, fim in partes:
|
||||
if corte.fim <= inicio or corte.inicio >= fim:
|
||||
novas_partes.append((inicio, fim))
|
||||
continue
|
||||
if inicio < corte.inicio:
|
||||
novas_partes.append((inicio, min(fim, corte.inicio)))
|
||||
if corte.fim < fim:
|
||||
novas_partes.append((max(inicio, corte.fim), fim))
|
||||
partes = novas_partes
|
||||
return partes
|
||||
|
||||
def _intervalos_equivalentes(
|
||||
self, esperados: tuple[tuple[float, float], ...], encontrados: tuple[tuple[float, float], ...]
|
||||
) -> bool:
|
||||
if len(esperados) != len(encontrados):
|
||||
return False
|
||||
return all(
|
||||
abs(inicio_esperado - inicio_encontrado) <= self._tolerancia
|
||||
and abs(fim_esperado - fim_encontrado) <= self._tolerancia
|
||||
for (inicio_esperado, fim_esperado), (inicio_encontrado, fim_encontrado)
|
||||
in zip(esperados, encontrados)
|
||||
)
|
||||
|
||||
def _clipes_do_arquivo(self, faixa: Faixa, arquivo_de_origem: str) -> list[Clipe]:
|
||||
nome_alvo = arquivo_de_origem.rsplit("/", 1)[-1].lower()
|
||||
return [
|
||||
clipe for clipe in faixa.clipes
|
||||
if clipe.intervalo_na_origem is not None
|
||||
and (clipe.nome or "").rsplit("/", 1)[-1].lower() == nome_alvo
|
||||
]
|
||||
|
||||
def _normalizar_intervalos(
|
||||
self, intervalos: list[tuple[float, float]]
|
||||
) -> tuple[tuple[float, float], ...]:
|
||||
ordenados = sorted(intervalos)
|
||||
unidos: list[list[float]] = []
|
||||
for inicio, fim in ordenados:
|
||||
if fim <= inicio + self._tolerancia:
|
||||
continue
|
||||
if unidos and inicio <= unidos[-1][1] + self._tolerancia:
|
||||
unidos[-1][1] = max(unidos[-1][1], fim)
|
||||
else:
|
||||
unidos.append([inicio, fim])
|
||||
return tuple((inicio, fim) for inicio, fim in unidos)
|
||||
|
||||
@staticmethod
|
||||
def _formatar_intervalos(intervalos: tuple[tuple[float, float], ...]) -> str:
|
||||
"""Formata intervalos para mensagens curtas e conferíveis."""
|
||||
if not intervalos:
|
||||
return "[]"
|
||||
return "[" + ", ".join(f"{inicio:.2f}-{fim:.2f}s" for inicio, fim in intervalos) + "]"
|
||||
Reference in New Issue
Block a user