Communitygithub.com

composants-manimater

Utilisez la bibliothèque open-source de composants Manim (manimater-components) pour animer des concepts, construire des storyboards JSON, ou contribuer de nouveaux composants.

Qu'est-ce que composants-manimater ?

Ce skill permet aux développeurs et aux non-codeurs de tirer parti de la bibliothèque manimater-components, une collection de plus de 90 composants Manim prêts à l'emploi, pilotés par JSON. Chaque composant encapsule une animation spécifique (électricité, signaux, microélectronique, apprentissage automatique, informatique, finance, physique, chimie, bases de données) sans nécessiter d'écriture de code d'animation. L'utilisateur peut soit sélectionner des composants existants pour construire un storyboard JSON valide, le prévisualiser via des commandes CLI, soit créer et contribuer un nouveau composant en suivant des règles strictes (max 5 paramètres, logique en Python pur sans Manim, tests unitaires). Le skill s'appuie sur un catalogue centralisé (catalog.json) et un validateur pour garantir la cohérence des storyboards. Il supporte les plateformes Claude Code, Cursor et Codex, et guide l'utilisateur du choix du composant jusqu'à la contribution via GitHub ou un formulaire dédié.

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

Demander à votre IA préférée

Ouvre une nouvelle conversation avec cette compétence d'agent déjà préchargée.

Documentation

Que fait composants-manimater ?

Une bibliothèque de composants Manim testés et pilotés par JSON. Un composant est un nom associé à des paramètres ; vous n'avez jamais besoin de code d'animation. Dépôt : https://github.com/bishnt/manimater-components (MIT). L'application Manimater utilise la même bibliothèque.

Deux choses que l'on peut vous demander de faire :

  1. Utiliser des composants : choisir ceux qui conviennent à un sujet, écrire un storyboard valide, le prévisualiser.
  2. Ajouter un composant : en écrire un qui respecte les règles, le tester et le faire contribuer.

Déterminez ce que l'utilisateur souhaite. S'il décrit une animation qu'aucun composant existant ne peut réaliser, passez à "Ajouter un composant".

1. Utiliser des composants

Trouver le bon composant

  1. Lisez references/catalog.md : chaque composant avec une description d'une ligne et ses paramètres. (Si vous êtes dans un clone du dépôt, catalog.json à la racine contient les détails complets des paramètres et un example pour chacun.)
  2. Choisissez le composant dont la description correspond à l'idée à montrer, pas seulement au sujet. Préférez un composant spécifique à un composant générique (synchronous_motor plutôt que bullet_points pour expliquer un moteur), et combinez-en plusieurs pour une histoire : title_card, puis les composants du concept, puis callout comme conclusion finale.
  3. Lisez l'entrée du composant choisi dans catalog.json pour connaître les noms exacts des paramètres, leurs types, choices et example.

Écrire un storyboard

Un storyboard est au format JSON ; la bibliothèque le vérifie pour vous :

{ "title": "Comment fonctionne un moteur synchrone",
  "scenes": [
    { "component": "title_card", "params": { "title": "Moteurs synchrones" }, "narration": "Pourquoi ce moteur ne patine-t-il jamais ?" },
    { "component": "synchronous_motor", "params": { "poles": 2, "frequency_hz": 50 }, "narration": "Le rotor se verrouille sur le champ tournant." },
    { "component": "callout", "params": { "text": "La vitesse est fixée par la fréquence et le nombre de pôles.", "kind": "takeaway" }, "narration": "La vitesse ne dépend donc que de la fréquence." }
  ] }

Règles appliquées par le validateur : au maximum 12 scènes, chaînes jusqu'à 300 caractères, listes jusqu'à 8 éléments, les paramètres inconnus sont ignorés, les paramètres obligatoires doivent être présents, les choices doivent correspondre. N'inventez jamais un nom de composant ou un paramètre ; si quelque chose manque, dites-le et proposez d'écrire un nouveau composant.

Valider et prévisualiser

pip install -e ".[dev]"                       # dans un clone ; nécessite ffmpeg, Cairo et Pango pour Manim
python - <<'PY'
import json
from manimate.storyboard import validate
sb, errors = validate(json.load(open("storyboard.json")))
print(errors or "valide")
PY
python -m manimate.preview <composant>                        # rend previews/<composant>.mp4 à partir de son exemple
python -m manimate.preview <composant> --params '{"...": 1}'  # avec vos propres paramètres
python -m manimate.preview --list

Si vous ne pouvez pas exécuter de code dans cet environnement, produisez le JSON du storyboard et les commandes exactes, et dites clairement que vous ne l'avez ni validé ni rendu.

2. Ajouter un composant

Lisez d'abord references/component-template.py. C'est un composant complet et fonctionnel.

Décider

  • Une idée, réutilisable. "Comment fonctionne un transformateur" est une vidéo entière ; "poids d'attention entre deux mots" est un composant. Les paramètres (nombres, étiquettes, listes) doivent le rendre utile pour de nombreux exemples.
  • Vérifiez references/catalog.md pour ne pas dupliquer un composant existant.
  • Demandez à l'utilisateur tout ce que vous ne pouvez pas décider vous-même (à qui il est destiné, ce qui doit être ajustable) mais pas plus de deux questions ; sinon, faites des choix raisonnables et énoncez-les.

L'écrire

Sauvegardez sous manimate/components/community/<nom>.py (snake_case, unique). Il est enregistré automatiquement. Suivez le modèle exactement, et ces règles :

  1. Au maximum 5 paramètres, chacun avec une description (une IA la lit), une valeur par défaut ou required=True, et un validator qui renvoie un message en français simple pour une entrée invalide. Limitez, ajustez, revenez à une valeur par défaut ; ne plantez jamais sur une entrée étrange.
  2. Le dictionnaire example doit être valide et doit pouvoir être rendu.
  3. Les maths, algorithmes et la mise en page sont des fonctions Python pures sans Manim, afin de pouvoir être testés unitairement.
  4. Utilisez uniquement les couleurs de manimate.theme (theme.ACCENT, ...), jamais de codes hexadécimaux. Texte court et simple à l'écran. ctx.fit(...) pour que rien ne sorte de la scène.
  5. Fondu de l'image finale entière avec un seul FadeIn, puis animer ce qui porte le sens. Utilisez le temps qui vous est donné (ctx.remaining, Ctx.beat). Utilisez ctx.play / ctx.wait, jamais scene.play.
  6. Code de dessin pur : pas de réseau, fichiers, sous-processus, eval, exec, getattr, ou accès dunder. Les imports sont limités à manim, numpy, la bibliothèque standard et les propres modules de la bibliothèque. L'IC et un bot rejettent toute autre chose.
  7. L'encapsulation d'un plugin Manim n'est autorisée que s'il est sous licence MIT ou Creative Commons ; suivez docs/WRITING_A_COMPONENT.md.

Écrivez un test pour la logique Python pure dans tests/community/test_<nom>.py (cas limites : vide, un élément, le maximum, étiquettes longues). Le test générique exécute déjà à sec l'exemple de chaque composant communautaire.

Le vérifier

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

Rapportez ce que vous avez exécuté et ce qui s'est passé. Si vous n'avez rien pu exécuter, dites-le.

Le contribuer

Dites à l'utilisateur, en termes simples, quel chemin lui convient :

  • Il peut utiliser git/GitHub : forker le dépôt, commiter le(s) nouveau(x) fichier(s) et le catalog.json régénéré, ouvrir une pull request. Voir CONTRIBUTING.md (il contient la liste de vérification et les cinq questions de conception à répondre dans la description).
  • Il ne code pas (la plupart des gens) : donnez-lui le fichier Python dans un bloc de code (et le test dans un second), et dites-lui d'ouvrir le formulaire de Nouveau composant (depuis un LLM) à l'adresse https://github.com/bishnt/manimater-components/issues/new?template=new-component.yml et d'y coller le code. Un bot vérifie sans l'exécuter et ouvre la pull request pour lui, à son crédit ; un mainteneur la révise.

Terminez par un résumé de trois lignes que l'utilisateur peut coller dans le formulaire : ce qu'il enseigne, les paramètres et les cas d'échec que vous avez traités.

Limites

  • N'affirmez pas qu'un composant existe s'il n'est pas dans le catalogue. N'affirmez pas qu'un rendu est correct à moins de l'avoir rendu.
  • Ne copiez pas de code d'autres dépôts dans une contribution, sauf s'il est sous licence MIT ou compatible et que vous précisez d'où il vient. Le code source, la documentation et les exemples de manim-eng ne doivent pas être utilisés comme données d'entraînement d'IA (voir docs/THIRD_PARTY.md).

Skills associés