Communitygithub.com

manimater-components (Componentes Manimater)

Use a biblioteca de componentes Manim de código aberto Manimater (manimater-components). Utilize quando o usuário quiser animar ou explicar um conceito com Manim, construir ou validar um storyboard JSON a partir de componentes reutilizáveis, consultar qual dos mais de 90 componentes (elétricos, potência, sinais, microeletrônica, aprendizado de máquina, ciência da computação, finanças, física, química, bancos de dados) se adequa a um tópico, pré-visualizar um componente, ou escrever e contribuir com um novo componente para a biblioteca. Use também quando alguém que não programa quiser descrever uma animação e obter um componente para contribuir.

O que é manimater-components (Componentes Manimater)?

Esta skill capacita o assistente de IA a trabalhar com a biblioteca **manimater-components**, um conjunto de mais de 90 componentes Manim prontos para uso, controlados por JSON. Em vez de escrever código de animação manualmente, o usuário (ou o assistente) pode selecionar componentes específicos para tópicos como engenharia, ciência da computação, finanças e física, combiná-los em um storyboard JSON, e validá-lo automaticamente. A skill também permite criar novos componentes seguindo regras rigorosas: no máximo 5 parâmetros com validação, lógica separada do Manim para testabilidade, e uso exclusivo de cores do tema da biblioteca. O assistente pode guiar tanto programadores (via pull request no GitHub) quanto não programadores (usando um formulário de issues com template) para contribuir com novos componentes. Tudo é feito sem inventar nomes ou parâmetros: o assistente consulta o catálogo existente e, se faltar um componente adequado, oferece-se para criá-lo. A skill suporta pré-visualização local com comandos como `python -m manimate.preview <componente>` e validação com `validate()` do próprio pacote.

Funciona com~Claude Code~Codex CLI~Cursor
npx skills add https://github.com/bishnt/manimater-components/tree/HEAD/skills/manimater-components

Perguntar na sua IA favorita

Abre um novo chat com esta habilidade de agente já pré-carregada.

Documentação

O que manimater-components (Componentes Manimater) faz?

Uma biblioteca de componentes Manim testados e orientados por JSON. Um componente é um nome mais parâmetros; nunca precisa de código de animação seu. Repositório: https://github.com/bishnt/manimater-components (MIT). O aplicativo Manimater usa a mesma biblioteca.

Duas coisas que podem ser solicitadas a você:

  1. Usar componentes: escolher os certos para um tópico, escrever um storyboard válido, pré-visualizá-lo.
  2. Adicionar um componente: escrever um que siga as regras, testá-lo e contribuí-lo.

Descubra qual delas o usuário deseja. Se ele descrever uma animação que nenhum componente existente pode fazer, vá para "Adicionar um componente".

1. Usar componentes

Encontrar o componente certo

  1. Leia references/catalog.md: todo componente com uma descrição de uma linha e seus parâmetros. (Se você estiver dentro de um clone do repositório, catalog.json na raiz tem detalhes completos dos parâmetros e um example para cada.)
  2. Escolha o componente cuja descrição corresponda à ideia a ser mostrada, não apenas ao tópico. Prefira um componente específico a um genérico (synchronous_motor em vez de bullet_points para uma explicação de motor), e combine alguns para uma história: title_card, depois os componentes do conceito, depois callout como conclusão final.
  3. Leia a entrada do componente escolhido em catalog.json para seus nomes de parâmetros exatos, tipos, choices e example.

Escrever um storyboard

Um storyboard é JSON; a biblioteca o verifica para você:

{ "title": "Como um motor síncrono funciona",
  "scenes": [
    { "component": "title_card", "params": { "title": "Motores síncronos" }, "narration": "Por que este motor nunca derrapa?" },
    { "component": "synchronous_motor", "params": { "poles": 2, "frequency_hz": 50 }, "narration": "O rotor trava no campo girante." },
    { "component": "callout", "params": { "text": "A velocidade é fixada pela frequência e pelo número de polos.", "kind": "takeaway" }, "narration": "Então a velocidade depende apenas da frequência." }
  ] }

Regras que o validador aplica: no máximo 12 cenas, strings de até 300 caracteres, listas de até 8 itens, parâmetros desconhecidos são ignorados, parâmetros obrigatórios devem estar presentes, choices devem corresponder. Nunca invente um nome de componente ou um parâmetro; se um estiver faltando, diga isso e ofereça-se para escrever um novo componente.

Validar e pré-visualizar

pip install -e ".[dev]"                       # em um clone; precisa de ffmpeg, Cairo e Pango para Manim
python - <<'PY'
import json
from manimate.storyboard import validate
sb, errors = validate(json.load(open("storyboard.json")))
print(errors or "válido")
PY
python -m manimate.preview <component>                        # renderiza previews/<component>.mp4 a partir do example
python -m manimate.preview <component> --params '{"...": 1}'  # com seus próprios parâmetros
python -m manimate.preview --list

Se você não puder executar código neste ambiente, produza o JSON do storyboard e os comandos exatos, e diga claramente que não validou ou renderizou.

2. Adicionar um componente

Leia references/component-template.py primeiro. É um componente completo e funcional.

Decidir

  • Uma ideia, reutilizável. "Como um transformador funciona" é um vídeo inteiro; "pesos de atenção entre duas palavras" é um componente. Parâmetros (números, rótulos, listas) devem torná-lo útil para muitos exemplos.
  • Verifique references/catalog.md para não duplicar um componente existente.
  • Pergunte ao usuário qualquer coisa que você não puder decidir sozinho (para quem é, o que deve ser ajustável), mas no máximo duas perguntas; caso contrário, faça escolhas sensatas e declare-as.

Escrevê-lo

Salve como manimate/components/community/<nome>.py (snake_case, único). É registrado automaticamente. Siga o template exatamente, e estas regras:

  1. No máximo 5 parâmetros, cada um com uma descrição (uma IA a lê), um valor padrão ou required=True, e um validator que retorna uma mensagem em linguagem natural para entrada inválida. Ajuste, corte, recorra a fallbacks; nunca falhe em entrada estranha.
  2. O dict example deve ser válido e deve renderizar.
  3. Matemática, algoritmos e layout são funções Python puras sem Manim, para que possam ser testadas unitariamente.
  4. Apenas cores de manimate.theme (theme.ACCENT, ...), nunca hex. Texto curto e simples na tela. ctx.fit(...) para que nada saia do palco.
  5. Faça o fade da imagem finalizada como um todo com um FadeIn, depois anime o que carrega o significado. Use o tempo que você tem (ctx.remaining, Ctx.beat). Use ctx.play / ctx.wait, nunca scene.play.
  6. Código puro de desenho: sem rede, arquivos, subprocessos, eval, exec, getattr, ou acesso a dunder. Importações são limitadas a manim, numpy, a biblioteca padrão e os próprios módulos da biblioteca. CI e um bot rejeitam qualquer outra coisa.
  7. Encapsular um plugin Manim é permitido apenas se for licenciado MIT ou Creative Commons; siga docs/WRITING_A_COMPONENT.md.

Escreva um teste para a lógica Python pura em tests/community/test_<nome>.py (casos extremos: vazio, um item, o máximo, rótulos longos). O teste genérico já executa a seco o exemplo de cada componente da comunidade.

Verificá-lo

python -m manimate.preview <nome>
python -m pytest tests/community
python -m manimate.catalog > catalog.json
python scripts/gen_docs.py

Relate o que você executou e o que aconteceu. Se não pôde executar nada, diga isso.

Contribuí-lo

Diga ao usuário, em palavras simples, qual caminho se adequa a ele:

  • Eles podem usar git/GitHub: faça um fork do repositório, faça commit do(s) novo(s) arquivo(s) e do catalog.json regenerado, abra um pull request. Veja CONTRIBUTING.md (tem a lista de verificação e as cinco perguntas de design para responder na descrição).
  • Eles não programam (a maioria das pessoas): dê a eles o arquivo Python em um bloco de código (e o teste em um segundo), e diga a eles para abrir o formulário de issue Novo componente (de um LLM) em https://github.com/bishnt/manimater-components/issues/new?template=new-component.yml e colar o código lá. Um bot verifica sem executá-lo e abre o pull request para eles, creditado a eles; um mantenedor revisa.

Termine com um resumo de três linhas que o usuário pode colar no formulário: o que ensina, os parâmetros e os casos de falha que você

Limites

  • Não afirme que um componente existe a menos que esteja no catálogo. Não afirme que uma renderização parece correta a menos que você a tenha renderizado.
  • Não copie código de outros repositórios para uma contribuição a menos que seja MIT ou compatível e você diga de onde é. O código-fonte, documentação e exemplos do manim-eng não devem ser usados como dados de treinamento de IA (veja docs/THIRD_PARTY.md).

Habilidades Relacionadas