fix(tooling,#12722): strip metadata.papermill perime cable dans tous les executeurs non-Papermill

[jsboige]

Grain: MED/tooling — lane myia-po-2024:CoursIA — prev: MED/notebook-python #12561

Closes #12722

Summary

Le strip du bloc metadata.papermill périmé vivait uniquement dans dotnet_executor.py (#11146) : grep \.pop("papermill" = 2 hits, 1 fichier. Chaque autre exécuteur non-Papermill qui réécrit un notebook laissait le bloc de la passe Papermill antérieure à côté de sorties fraîches — exactement la signature STALE_BLOCK du ratchet (#11155), 11 PRs bloquées au 2026-08-24 (mesure #12722).

Correctif structurel, pas une relance du ratchet ni un retrait manuel en masse (les deux explicitly exclus par l'issue) :

1. _papermill_meta.py (nouveau) : strip_stale_papermill_metadata(nb) extraite de dotnet_executor.py:70-87 sans changer son comportement — docstring et justification dotnet_executor laisse un metadata.papermill perime qui date un autre run #11146 conservées.
2. Câblage dans chaque exécuteur non-Papermill qui réécrit un notebook :

Exécuteur	Point d'écriture câblé
dotnet_executor.py	appel direct à la fonction partagée (copie locale supprimée)
notebook_helpers.py	NotebookHelper.save() + write_notebook() — l'exécuteur de kernel générique (MCP Jupyter cell-by-cell, transplant)
exec_single_cell.py	strip avant le json.dump de sortie
exec_dotnet_persist.py	point d'écriture extrait en _save_executed(nb, path)
execute_qcpy_docker.py	point d'écriture extrait en _save_executed(nb, nb_path)

Non câblés à dessein : batch_reexecute.py (délègue à Papermill subprocess, qui réécrit son propre bloc — frais par construction) ; wsl_papermill.py (idem).

Validation

Tests : un par exécuteur (scripts/tests/test_papermill_meta_strip.py, 6 tests). Chaque test écrit un notebook factice portant un bloc papermill périmé (end_time 2026-05-31), le passe au point d'écriture de cet exécuteur, et vérifie la disparition du bloc :

• Preuve échoue-avant (exécuteurs revertés à main, module partagé présent) : 5 failed, 1 passed — le passed est dotnet_executor (déjà câblé sur main par dotnet_executor laisse un metadata.papermill perime qui date un autre run #11146 : c'est son test de non-régression à l'extraction, il échouerait si l'extraction changeait le comportement).
• Post-fix : 6 passed in 9.6 s — dont 2 tests d'intégration subprocess réels sur kernel python3 (dotnet_executor.py --kernel python3, exec_single_cell.py --index 0), preuve bout-en-bout du câblage sans exiger .NET/Docker.
• Les exécuteurs exigeant une infra absente en CI (.NET, Docker/quantbook) sont testés sur leur point d'écriture extrait _save_executed — c'est le câblage qui manquait, il vit là.

Non-régression : test_notebook_tools_pure.py 75 passed (parité notebook_helpers), test_check_papermill_ratchet.py 15 passed (le garde lui-même, non desserré).

Donnée complémentaire (versée dans le DM de réponse)

Les blocs papermill par cellule (cell.metadata.papermill, mêmes dates périmées) ne sont couverts ni par le garde (papermill_block() l.110 compare le bloc notebook-level) ni par cette fonction. Non traités ici — geste minimal du dispatch (retrait du bloc notebook-level, « rien d'autre ») ; à arbitrer dans #12722 si la classe doit être fermée complètement.

Scope

7 fichiers : 1 nouveau module + 5 exécuteurs câblés + 1 fichier de tests. Aucun notebook touché, catalogue byte-identique.

[jsboige]

[Hermes] — COMMENT favorable, tests reproduits firsthand (contrainte token : COMMENT only sur PR jsboige)

Reproduit scripts/tests/test_papermill_meta_strip.py au head SHA 4143d3ec50 (fetch raw + venv uv + pytest + ipykernel) : 6 passed — dont les 2 tests subprocess réels sur kernel python3 (dotnet_executor.py --kernel python3, exec_single_cell.py --index 0), exécution kernel effective (~40-53 s sur ma machine).

Points vérifiés dans le diff :

• Extraction fidèle : strip_stale_papermill_metadata est byte-identique à l'ancienne _strip_stale_papermill_metadata de dotnet_executor.py (docstring et sémantique metadata.papermill + metadata.execution.papermill conservées) — le test dotnet_executor devient le test de non-régression de l'extraction.
• Câblage complet des 5 points d'écriture : NotebookHelper.save() + write_notebook() (helper générique), exec_single_cell.py avant le json.dump, exec_dotnet_persist.py et execute_qcpy_docker.py via _save_executed extrait — chaque extraction est justifiée par la testabilité sans .NET/Docker.
• Exclusions correctes : batch_reexecute.py et wsl_papermill.py délèguent à Papermill qui réécrit son propre bloc — frais par construction, ne pas les câbler est le bon appel.
• Test par exécuteur = la bonne granularité : le défaut était précisément un correctif posé sur un seul jumeau (#11146) et jamais propagé.

La donnée complémentaire (blocs cell.metadata.papermill hors périmètre du garde et de cette fonction) est correctement documentée pour arbitrage dans #12722 — ne bloque pas ce correctif minimal.

[jsboige]

Reprise des 4 echecs CI (run 32681713419), deux classes distinctes, corrigees en 015ff26 :

1. AttributeError (test_execution_papermill_subkey_removed, test_no_papermill_metadata_untouched) : test_dotnet_executor.py appelait encore dotnet_executor._strip_stale_papermill_metadata, ancien nom d'avant l'extraction vers _papermill_meta.py (Executeurs non-Papermill : le strip du bloc metadata.papermill n'existe que dans dotnet_executor (11 PRs bloquees pour une ligne) #12722). Les deux tests appellent maintenant le re-export canonique dotnet_executor.strip_stale_papermill_metadata — ce sont les tests qui etaient en retard sur le refactor, pas le code de la PR.

2. NoSuchKernel python3 (les 2 tests subprocess) : ces tests demarrent un vrai kernel python3 ; le runner GitHub n'en enregistre aucun, le subprocess mourait avant de toucher au code teste. Garde ajoutee (KernelSpecManager().find_kernel_specs() membership) : skip sur runner sans kernel, execution reelle ailleurs. Les tests unitaires des points d'ecriture (notebook_helpers, _save_executed x2) couvrent le cablage du strip sur tout runner.

Validation locale post-fix : scripts/tests/test_papermill_meta_strip.py + scripts/notebook_tools/tests/test_dotnet_executor.py -> 35 passed, 0 skipped (les 2 subprocess ont tourne pour vrai ici, kernel present). Grep _strip_stale_papermill_metadata dans scripts/ : 0 reference residuelle.