pyannotators-entityfishing 1.6.87__tar.gz → 1.6.90__tar.gz

{pyannotators_entityfishing-1.6.87 → pyannotators_entityfishing-1.6.90}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: pyannotators-entityfishing
-Version: 1.6.87
+Version: 1.6.90
 Summary: Annotator based on entity-fishing
 Project-URL: Homepage, https://github.com/oterrier/pyannotators_entityfishing/
 Author-email: Olivier Terrier <olivier.terrier@kairntech.com>

{pyannotators_entityfishing-1.6.87 → pyannotators_entityfishing-1.6.90}/src/pyannotators_entityfishing/__init__.py

@@ -1,3 +1,3 @@
 """Annotator based on entity-fishing"""
 
-__version__ = "1.6.87"
+__version__ = "1.6.90"

{pyannotators_entityfishing-1.6.87 → pyannotators_entityfishing-1.6.90}/submodules/python-archetype/.claude-plugin/plugin.json

@@ -2,7 +2,7 @@
   "$schema": "https://json.schemastore.org/claude-code-plugin-manifest.json",
   "name": "python-archetype",
   "displayName": "Kairntech python-archetype",
-  "version": "1.1.0",
+  "version": "1.2.0",
   "description": "Cree et entretient les depots Python de Kairntech qui consomment python-archetype : creation d'un plugin a partir de sa graine, et mesure de la derive d'un depot par rapport a elle.",
   "author": {
     "name": "Kairntech",

{pyannotators_entityfishing-1.6.87 → pyannotators_entityfishing-1.6.90}/submodules/python-archetype/resources/Taskfile.yml

@@ -169,11 +169,14 @@ tasks:
     cmds:
       - task: sync
         vars: { EXTRAS: '{{.SYNC_EXTRAS}} sbom' }
-      # '|| true' : pip-audit sort non-zéro dès qu'il trouve quelque chose, et cette
-      # task ne rend pas le verdict. Sans ça, le rapport serait écrit puis la task
-      # échouerait, empêchant le stage suivant d'exister. Même principe que le
+      # pip-audit sort non-zéro dès qu'il trouve quelque chose, et cette task ne rend
+      # pas le verdict : son échec ne doit pas l'arrêter. Même principe que le
       # vuln-report.py de docker-image-pipeline, qui n'utilise pas le --exit-code de
       # trivy pour garantir que le rapport est écrit AVANT l'échec.
+      # '&& echo 0 || echo $?' et PAS '; echo $?' : Task exécute les cmds sous set -e,
+      # donc avec ';' le shell s'arrête sur l'échec de pip-audit avant d'écrire le code
+      # -- la task échouait, sans rapport, dans le seul cas où il sert. Une liste && ||
+      # n'est pas interrompue par set -e, et $? y est encore celui de pip-audit.
       # --skip-editable : les paquets installes en editable sont les membres du
       # workspace, qui ne peuvent figurer dans aucune base d'avis. pip-audit les
       # ignorait DEJA, faute de les trouver sur PyPI, mais en le disant -- le rapport
@@ -182,7 +185,7 @@ tasks:
       # Le code de sortie est mémorisé : c'est le verdict, et la sortie markdown seule
       # ne le porte pas.
       - task: uv
-        vars: { ARGS: 'run pip-audit {{.AUDIT_ARGS}} --skip-editable --format markdown --output {{.AUDIT_REPORT}}.tmp; echo $? > {{.AUDIT_REPORT}}.rc' }
+        vars: { ARGS: 'run pip-audit {{.AUDIT_ARGS}} --skip-editable --format markdown --output {{.AUDIT_REPORT}}.tmp && echo 0 > {{.AUDIT_REPORT}}.rc || echo $? > {{.AUDIT_REPORT}}.rc' }
       # Le verdict est ECRIT par nous, parce que pip-audit ne le dit jamais en markdown :
       # sans trouvaille il n'écrit aucun fichier, et sans trouvaille mais avec des paquets
       # ignorés il n'écrit QUE leur table « Skip Reason ». Dans les deux cas le lecteur ne

{pyannotators_entityfishing-1.6.87 → pyannotators_entityfishing-1.6.90}/submodules/python-archetype/skills/new-plugin/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: new-plugin
-description: Créer un plugin Sherpa — importeur (pyimporters), processeur ou annotateur (pymultirole), et plus tard convertisseur, formateur ou segmenteur — à partir d'un format ou d'un besoin : clone la graine du contrat, écrit la classe et ses paramètres, les tests et leurs fixtures, la table du README, et câble le plugin dans le paquet de flavor du serveur. À utiliser quand on demande un nouvel importeur, un nouveau format de thésaurus, un nouveau processeur ou un nouvel annotateur, ou un nouveau plugin pyimporters / pymultirole.
+description: Créer un plugin Sherpa — importeur (pyimporters), ou processeur, annotateur, convertisseur, formateur ou segmenteur (pymultirole) — à partir d'un format ou d'un besoin : clone la graine du contrat, écrit la classe et ses paramètres, les tests et leurs fixtures, la table du README, et câble le plugin dans le paquet de flavor du serveur. À utiliser quand on demande un nouvel importeur, un nouveau format de thésaurus, un nouveau processeur, annotateur, convertisseur (un format de fichier d'entrée), formateur (un format de sortie) ou segmenteur, ou un nouveau plugin pyimporters / pymultirole.
 ---
 
 # Créer un plugin Sherpa
@@ -65,6 +65,9 @@ d'un type à l'autre.
 - [`references/importer.md`](references/importer.md)
 - [`references/processor.md`](references/processor.md)
 - [`references/annotator.md`](references/annotator.md)
+- [`references/converter.md`](references/converter.md)
+- [`references/formatter.md`](references/formatter.md)
+- [`references/segmenter.md`](references/segmenter.md)
 
 Deux règles valent pour tous les types :
 
@@ -84,6 +87,11 @@ paquet de flavor. Un plugin non câblé ne remonte jamais dans l'API.
   (`references/<type>.md` dit lequel) ;
 - aligner la borne de `pyimporters_plugins` ou `pymultirole-plugins` sur celle des
   dépôts frères, ne pas l'élargir ;
+- **un plugin destiné à un client peut-il aller sur PyPI, qui est public ?**
+  Demander, ne pas supposer. Si non : `publish: false` et `archiveWheel: true` dans
+  le Jenkinsfile, et la roue rejoint `pymultirole_server/deps/` au lieu des
+  `dependencies` du paquet de flavor (`references/types.md`, « Un plugin propre à
+  un client ») ;
 - le dépôt Bitbucket `kairntech/<prefixe>_<nom>` (**underscore** : seul le nom de
   distribution prend le tiret) est créé par une personne, avec le script de
   création de dépôt, qui crée aussi le webhook et le job Jenkins. Il demande des

pyannotators_entityfishing-1.6.90/submodules/python-archetype/skills/new-plugin/references/converter.md

@@ -0,0 +1,66 @@
+# Converter — le contenu à écrire
+
+Graine `kairntech/pyconverters_seed`, layout `src/pyconverters_<nom>/`, fichier
+`src/pyconverters_<nom>/<nom>.py`. Modèles vivants : `pyconverters_inscriptis`
+(HTML → texte et phrases), `pyconverters_newsml` (un fichier, un document par `newsItem`).
+
+## À demander en plus
+
+- **le format d'entrée** et **un fichier d'exemple réel** : c'est la fixture des
+  tests, dans `tests/data/`. Un convertisseur testé sur un fichier fabriqué pour
+  l'occasion passe, puis casse sur le premier vrai document ;
+- **un document ou plusieurs par fichier** : une archive, un classeur, un flux
+  NewsML en donnent plusieurs ; que devient alors `identifier` ;
+- **ce qui doit sortir en plus du texte** : `title`, `metadata` (langue, dates),
+  `properties`, `sentences` ou `boundaries` si le format les porte déjà ;
+- **un service externe ?** (OCR, API de transcription) Son URL par défaut, la
+  variable d'environnement qui la surcharge, la clé et l'endroit où elle vit
+  (`tests/.env`, jamais versionné).
+
+## Le convertisseur
+
+Remplacer le corps de `src/pyconverters_<nom>/<nom>.py`, **garder la forme** :
+
+- les paramètres dérivent de `ConverterParameters`, qui est un `FormDataModel` :
+  le serveur les reçoit en JSON dans un champ de formulaire multipart, et le
+  modèle les décode lui-même. **Ne pas changer de classe de base** ;
+  `Field(défaut, description=...)` et `json_schema_extra={"extra": ...}` comme
+  pour un processeur (`advanced`, `internal`…) ;
+- `convert(source, parameters)` reçoit un `UploadFile` de Starlette et rend une
+  **liste** de `Document`, même pour un seul. `source.file` est un flux binaire
+  côté serveur : décoder soi-même, avec l'encodage des paramètres ou celui que le
+  format déclare ; `source.filename` donne le nom ;
+- `identifier` porte le nom du fichier (suffixé pour plusieurs documents), et
+  `properties["fileName"]` aussi, comme les convertisseurs frères : c'est ce qui
+  rattache le document à sa source dans Sherpa ;
+- `ConverterBase` a pour métaclasse `ABCSingleton` : un modèle lourd (OCR…) se
+  charge une fois et se met en cache par paramètres, pas dans `self` à chaque
+  appel ;
+- `get_model()` renvoie la classe de paramètres.
+
+## Les tests
+
+- le test du modèle, le test des paramètres reçus en formulaire et le test de
+  découverte par entry-point de la graine, gardés ;
+- un test par fixture de `tests/data/`, qui vérifie le **texte produit** (contre un
+  `.txt` attendu à côté quand il est long), `identifier` et ce que le format
+  apporte en plus (titre, phrases, métadonnées) ;
+- un fichier dégradé ou vide, qui doit donner un document vide ou une erreur
+  claire, pas une trace illisible ;
+- si le convertisseur appelle un service : aucun appel réseau par défaut, tests
+  live derrière `skipif` sur la clé ou un marqueur `integration`. Un dépôt dont
+  tous les tests sont sautés sans clé est **vert sans rien tester** : garder au
+  moins un test hors ligne.
+
+## Le README
+
+Compléter la table des paramètres, et dire quels formats et quels types MIME le
+convertisseur accepte.
+
+## Le câblage
+
+`"pyconverters-<nom>>=1.6.0,<1.7.0"` dans les `dependencies` du paquet de flavor de
+`pymultirole_server/packages/` : `pymultirole-builtins` pour un format générique,
+la flavor du client sinon (`references/types.md`). Un paquet système (`ffmpeg`,
+`libicu-dev`…) doit aussi être présent sur l'agent Jenkins, qui n'a pas de
+conteneur : le dire à qui gère l'agent.

pyannotators_entityfishing-1.6.90/submodules/python-archetype/skills/new-plugin/references/formatter.md

@@ -0,0 +1,54 @@
+# Formatter — le contenu à écrire
+
+Graine `kairntech/pyformatters_seed`, layout `src/pyformatters_<nom>/`, fichier
+`src/pyformatters_<nom>/<nom>.py`. Modèles vivants : `pyformatters_json` (JSON),
+`pyformatters_tabular` (CSV ou Excel selon un paramètre).
+
+## À demander en plus
+
+- **le format de sortie** et son type MIME, et **un exemple du fichier attendu** :
+  c'est la fixture des tests ;
+- **un document d'exemple réaliste**, annotations et catégories comprises : un
+  formateur rend ce que les plugins précédents ont produit, et un document nu ne
+  teste rien ;
+- **ce qui entre dans la sortie** : le texte, les annotations (et leurs `terms`),
+  les catégories, les phrases, les métadonnées — et dans quel ordre.
+
+## Le formateur
+
+Remplacer le corps de `src/pyformatters_<nom>/<nom>.py`, **garder la forme** :
+
+- les paramètres dérivent de `FormatterParameters` et se déclarent en
+  `Field(défaut, description=...)` ; `json_schema_extra={"extra": ...}` comme pour
+  un processeur ;
+- `format(document, parameters)` reçoit **un** document, pas un lot, et rend une
+  `Response` de Starlette, que le serveur transmet telle quelle au client. Poser le
+  `media_type`, et un `Content-Disposition: attachment; filename=...` comme les
+  formateurs frères, pour que le navigateur enregistre un fichier au bon nom ;
+- lire les offsets tels quels : `document.text[a.start:a.end]` est le texte d'une
+  annotation (fin exclue). Ne rien recalculer, ne rien modifier du document ;
+- `FormatterBase` a pour métaclasse `ABCSingleton` : rien dans `self` qui dépende
+  d'un appel ;
+- `get_model()` renvoie la classe de paramètres.
+
+## Les tests
+
+- le test du modèle et le test de découverte par entry-point de la graine, gardés ;
+- un test de formatage qui relit la sortie (`json.loads(resp.body)`, un lecteur CSV,
+  `openpyxl` pour un classeur) et vérifie son **contenu**, pas seulement le code
+  200 : `status_code`, `media_type` et `Content-Disposition` compris ;
+- un document sans annotation, qui doit donner une sortie valide et vide ;
+- attention au renommage de `task init` : il remplace le mot `seed` **partout**, y
+  compris dans les textes des tests. Un offset écrit en dur sur un texte qui
+  contient ce mot se décale après l'`init`.
+
+## Le README
+
+Compléter la table des paramètres, et décrire la sortie : type MIME, structure,
+ce qui y figure.
+
+## Le câblage
+
+`"pyformatters-<nom>>=1.6.0,<1.7.0"` dans les `dependencies` du paquet de flavor de
+`pymultirole_server/packages/` : `pymultirole-builtins` pour un format générique,
+la flavor du client sinon (`references/types.md`).

pyannotators_entityfishing-1.6.90/submodules/python-archetype/skills/new-plugin/references/segmenter.md

@@ -0,0 +1,55 @@
+# Segmenter — le contenu à écrire
+
+Graine `kairntech/pysegmenters_seed`, layout `src/pysegmenters_<nom>/`, fichier
+`src/pysegmenters_<nom>/<nom>.py`. Modèles vivants : `pysegmenters_syntok` et
+`pysegmenters_blingfire` (phrases, selon la langue), `pysegmenters_md_splitter`
+(sections d'un texte Markdown).
+
+## À demander en plus
+
+- **l'unité produite** : phrases, paragraphes, sections, fenêtres de N caractères ;
+- **les langues** à couvrir, et d'où vient la langue d'un document
+  (`document.metadata["language"]`, un paramètre, une détection) ;
+- **des textes d'exemple réels** et le découpage attendu, avec ses cas difficiles :
+  abréviations, listes, titres, lignes vides, texte sans ponctuation.
+
+## Le segmenteur
+
+Remplacer le corps de `src/pysegmenters_<nom>/<nom>.py`, **garder la forme** :
+
+- les paramètres dérivent de `SegmenterParameters` et se déclarent en
+  `Field(défaut, description=...)` ; `json_schema_extra={"extra": ...}` comme pour
+  un processeur ;
+- `segment(documents, parameters)` reçoit et rend **tout le lot**, sans perdre ni
+  réordonner de document ;
+- il **remplace** `document.sentences` : un segmenteur définit le découpage, il ne
+  l'enrichit pas, et segmenter deux fois doit donner le même résultat ;
+- une `Sentence` a `start` et `end` en **offsets de caractères dans
+  `document.text`, fin exclue**, sans les blancs de bord ; `metadata` et
+  `categories` sont optionnels ;
+- les phrases couvrent le texte **sans trou ni chevauchement** hors blancs : un
+  annotateur ou un processeur en aval travaille phrase par phrase, et un morceau
+  de texte hors de toute phrase n'est jamais vu ;
+- `SegmenterBase` a pour métaclasse `ABCSingleton` : un modèle de langue se charge
+  une fois, pas à chaque appel ;
+- `get_model()` renvoie la classe de paramètres.
+
+## Les tests
+
+- le test du modèle et le test de découverte par entry-point de la graine, gardés ;
+- un test de segmentation qui vérifie `text[s.start:s.end]` pour chaque phrase,
+  contre la liste attendue : c'est ce qui attrape un décalage d'un caractère ou une
+  confusion octets/caractères ;
+- un test d'idempotence (segmenter deux fois), et un document au texte vide ;
+- un test par langue couverte, sur un texte réel.
+
+## Le README
+
+Compléter la table des paramètres, et dire quelle unité le segmenteur produit et
+pour quelles langues.
+
+## Le câblage
+
+`"pysegmenters-<nom>>=1.6.0,<1.7.0"` dans les `dependencies` du paquet de flavor de
+`pymultirole_server/packages/` : `pymultirole-builtins` pour un segmenteur
+générique, la flavor du client sinon (`references/types.md`).

{pyannotators_entityfishing-1.6.87 → pyannotators_entityfishing-1.6.90}/submodules/python-archetype/skills/new-plugin/references/types.md

@@ -8,11 +8,11 @@ skill.
 | type | graine | groupe d'entry-points | classe de base | paquet de flavor | graine prête ? |
 |------|--------|-----------------------|----------------|------------------|----------------|
 | `importer` | `kairntech/pyimporters_seed` | `pyimporters.plugins` | `KnowledgeParserBase` (`pyimporters_plugins.base`) | `pyimporters_server/packages/pyimporters-builtins` | **oui** |
-| `converter` | `kairntech/pyconverters_seed` | `pyconverters.plugins` | `ConverterBase` (`pymultirole_plugins.v1.converter`) | `pymultirole_server/packages/pymultirole-builtins` | non |
+| `converter` | `kairntech/pyconverters_seed` | `pyconverters.plugins` | `ConverterBase` (`pymultirole_plugins.v1.converter`) | `pymultirole_server/packages/pymultirole-builtins` | **oui** |
 | `processor` | `kairntech/pyprocessors_seed` | `pyprocessors.plugins` | `ProcessorBase` (`pymultirole_plugins.v1.processor`) | `pymultirole-builtins` ou une flavor dédiée | **oui** |
 | `annotator` | `kairntech/pyannotators_seed` | `pyannotators.plugins` | `AnnotatorBase` (`pymultirole_plugins.v1.annotator`) | `pymultirole-builtins` ou une flavor dédiée | **oui** |
-| `formatter` | `kairntech/pyformatters_seed` | `pyformatters.plugins` | `FormatterBase` (`pymultirole_plugins.v1.formatter`) | `pymultirole-builtins` | non |
-| `segmenter` | `kairntech/pysegmenters_seed` | `pysegmenters.plugins` | `SegmenterBase` (`pymultirole_plugins.v1.segmenter`) | `pymultirole-builtins` | non |
+| `formatter` | `kairntech/pyformatters_seed` | `pyformatters.plugins` | `FormatterBase` (`pymultirole_plugins.v1.formatter`) | `pymultirole-builtins` | **oui** |
+| `segmenter` | `kairntech/pysegmenters_seed` | `pysegmenters.plugins` | `SegmenterBase` (`pymultirole_plugins.v1.segmenter`) | `pymultirole-builtins` | **oui** |
 
 ## Ce que chaque graine prête produit
 
@@ -21,13 +21,19 @@ skill.
 | `importer` | à plat : `pyimporters_<nom>/` | `pyimporters_<nom>` | `CSV` → `CSVKnowledgeParser`, `CSVOptions` | « Sherpa FOO knowledge import plugin » | [`importer.md`](importer.md) |
 | `processor` | `src/pyprocessors_<nom>/` | `src/pyprocessors_<nom>` | `Foo` → `FooProcessor`, `FooParameters` | « Processor based on foo » | [`processor.md`](processor.md) |
 | `annotator` | `src/pyannotators_<nom>/` | `src/pyannotators_<nom>` | `Foo` → `FooAnnotator`, `FooParameters` | « Annotator based on foo » | [`annotator.md`](annotator.md) |
+| `converter` | `src/pyconverters_<nom>/` | `src/pyconverters_<nom>` | `Foo` → `FooConverter`, `FooParameters` | « Converter based on foo » | [`converter.md`](converter.md) |
+| `formatter` | `src/pyformatters_<nom>/` | `src/pyformatters_<nom>` | `Foo` → `FooFormatter`, `FooParameters` | « Formatter based on foo » | [`formatter.md`](formatter.md) |
+| `segmenter` | `src/pysegmenters_<nom>/` | `src/pysegmenters_<nom>` | `Foo` → `FooSegmenter`, `FooParameters` | « Segmenter based on foo » | [`segmenter.md`](segmenter.md) |
 
 Le layout suit la famille, pas une préférence : les dépôts `pyimporters_*` ont leur
 paquet à plat, les dépôts `pymultirole` sont en `src/` — dont `pyprocessors_jev` et
 `pyannotators_entityfishing`, déjà passés sous `python-archetype`, sur lesquels les
-graines `pymultirole` sont calquées (ruff à 256 colonnes compris). Après `task init`,
-le Taskfile d'un processeur est identique octet pour octet à celui de
-`pyprocessors_jev`, celui d'un annotateur à celui de `pyannotators_entityfishing`.
+graines `pymultirole` sont calquées (ruff à 256 colonnes compris). Les cinq graines
+`pymultirole` partagent la même enveloppe au type près : après `task init`, le Taskfile
+d'un plugin est identique octet pour octet à celui des dépôts frères de sa famille
+(`pyprocessors_jev`, `pyannotators_entityfishing`, et les dépôts migrés de chaque
+famille). Quelques dépôts frères plus anciens ont leur paquet à plat
+(`pyformatters_json`, `pyprocessors_deepl`…) : un plugin neuf est en `src/`.
 
 Les paquets de flavor de `pymultirole_server/packages/` : `pymultirole-builtins`,
 `pymultirole-afp`, `pymultirole-cairn`, `pymultirole-escrim`, `pymultirole-grouperf`,
@@ -35,19 +41,38 @@ Les paquets de flavor de `pymultirole_server/packages/` : `pymultirole-builtins`
 serveur, pas une flavor). Un plugin propre à un client va dans la flavor de ce
 client ; demander, ne pas deviner.
 
-## Trois graines existent aujourd'hui
+## Les six graines existent
 
-`pyimporters_seed`, `pyprocessors_seed` et `pyannotators_seed` sont poussées, et ne
-publient rien (`publish: false`). **Les trois autres n'existent pas encore.** La
-famille `pymultirole` passe progressivement sous `python-archetype` : quelques dépôts
-sont migrés, la plupart portent encore la sortie de `cookiecutter-pymultirole`
+`pyimporters_seed`, et pour `pymultirole` `pyprocessors_seed`, `pyannotators_seed`,
+`pyconverters_seed`, `pyformatters_seed` et `pysegmenters_seed`. Elles ne publient
+rien (`publish: false`). La famille `pymultirole` est passée sous `python-archetype` ;
+les dépôts restés en flit portent encore la sortie de `cookiecutter-pymultirole`
 (`bumpversion.py`, `AUTHORS.md`, `CHANGELOG.md`, `RELEASE.md`, `mypy.ini`, `docs/`).
 
-Si on demande un type dont la graine n'existe pas : **le dire et s'arrêter.**
+Si on demande un type qui n'est pas dans la table : **le dire et s'arrêter.**
 Improviser l'enveloppe reviendrait à recréer à la main ce que la graine garantit,
 sans la garantie — et le dépôt produit devrait être migré comme les autres. La
-bonne réponse est de créer d'abord la graine du type, sur le modèle des trois
-existantes.
+bonne réponse est de créer d'abord la graine du type, sur le modèle des existantes.
+
+## Un plugin propre à un client : construit, jamais publié
+
+PyPI est public. Un plugin écrit pour un client (`pyprocessors_escrim_reconciliation`,
+`pyformatters_json_rem`) ne doit pas y aller : **demander**, pour tout plugin destiné à
+une flavor client, s'il peut être publié. Si non, remplacer dans le Jenkinsfile le
+`publishBranches` seul par :
+
+```groovy
+  publish: false,
+  archiveWheel: true,
+  publishBranches: '^master$',
+```
+
+`publish: false` est la garantie, et elle ne dépend de rien d'autre. `archiveWheel`
+demande en plus le stage `version` et l'archivage de la roue dans le build Jenkins,
+d'où elle rejoint `pymultirole_server/deps/` ; le Dockerfile de la flavor l'y prend
+(`find deps -name '<distribution>-*.whl' | sort -V | tail -n 1`). Aucun index ne la
+servant, **ne pas** l'ajouter aux `dependencies` du paquet de flavor : la résolution y
+chercherait une version publiée, qui n'existe pas ou qui est ancienne.
 
 ## Pourquoi une graine par contrat, et un seul skill
 

{pyannotators_entityfishing-1.6.87 → pyannotators_entityfishing-1.6.90}/submodules/python-archetype/vars/pythonPipeline.groovy

@@ -33,6 +33,12 @@
  * @param throttleCategory  Throttle category shared with the sibling repositories. Omit for none.
  * @param publish           Publish the wheel to PyPI. Default true; never on a pull request,
  *                          and never off a publishBranches branch.
+ * @param archiveWheel      Archive the wheel in the build, with the version bump that goes with
+ *                          it. Default false. For a client-specific plugin that must never reach
+ *                          PyPI, which is public: 'publish: false, archiveWheel: true' versions,
+ *                          builds and archives, and sends nothing out. 'publish: false' alone is
+ *                          the guarantee -- an older copy of this file ignores archiveWheel and
+ *                          still publishes nothing. Same branch and pull-request rules as publish.
  * @param publishBranches   Regex the branch must FULLY match for 'version' and 'py:publish'
  *                          to run, e.g. '^(master|py38)$'. Falls back to the
  *                          CI_PUBLISH_BRANCHES global environment variable, then '^master$'.
@@ -90,6 +96,9 @@ def call(Map config = [:]) {
     env._TIMEOUT_TIME   = buildTimeout.time as String
     env._TIMEOUT_UNIT   = buildTimeout.unit ?: 'HOURS'
     env._PUBLISH        = config.get('publish', true) ? 'true' : 'false'
+    // Versionner et archiver la roue sans la publier : un plugin propre a un client est
+    // construit ici, mais ne doit jamais partir sur PyPI, qui est public.
+    env._ARCHIVE_WHEEL  = config.get('archiveWheel', false) ? 'true' : 'false'
     // Les branches depuis lesquelles publier. Une branche de feature ne doit RIEN
     // publier : PyPI est immuable et son espace de noms est commun a toutes les
     // branches, donc une branche neuve dont le compteur de build repasse sur un numero
@@ -168,7 +177,8 @@ def call(Map config = [:]) {
                         checkStageDrift()
                         // Dire pourquoi 'version' et 'py:publish' seront joues ou non :
                         // un stage grise sans explication laisse chercher.
-                        String state = publishAllowed() ? 'activee' : 'desactivee'
+                        String state = publishAllowed() ? 'activee' :
+                                       (releaseAllowed() ? 'desactivee, roue archivee sans publication' : 'desactivee')
                         // Le '+' DOIT rester en fin de ligne. Place en tete de la ligne
                         // suivante, Groovy termine l'instruction 'echo' et lit '+ "..."'
                         // comme un plus UNAIRE sur une String : String.positive(), qui
@@ -280,7 +290,7 @@ def call(Map config = [:]) {
                 when {
                     allOf {
                         not { changeRequest() }
-                        expression { return publishAllowed() }
+                        expression { return releaseAllowed() }
                     }
                 }
                 steps {
@@ -297,11 +307,13 @@ def call(Map config = [:]) {
                 }
             }
 
+            // Publie sur PyPI, ou archive seulement la roue d'un plugin confidentiel
+            // (archiveWheel) : les deux partagent la garde de version de publishWheel().
             stage('py:publish') {
                 when {
                     allOf {
                         not { changeRequest() }
-                        expression { return publishAllowed() }
+                        expression { return releaseAllowed() }
                     }
                 }
                 steps {
@@ -379,6 +391,22 @@ private boolean publishAllowed() {
     if (env._PUBLISH != 'true') {
         return false
     }
+    return onPublishBranch()
+}
+
+/**
+ * True when this build produces a release: a version commit and a wheel that leaves the build,
+ * whether on PyPI (publish) or only as a build artifact (archiveWheel). Same branch rule as
+ * publishAllowed(): a feature branch must not push version commits either.
+ */
+private boolean releaseAllowed() {
+    if (env._PUBLISH != 'true' && env._ARCHIVE_WHEEL != 'true') {
+        return false
+    }
+    return onPublishBranch()
+}
+
+private boolean onPublishBranch() {
     String branch = currentBranch()
     return branch && (branch ==~ env._PUBLISH_BRANCHES)
 }
@@ -617,6 +645,18 @@ private void publishWheel() {
         return
     }
 
+    if (env._ARCHIVE_WHEEL == 'true') {
+        // Le nom EXACT de la roue de ce build, pas 'dist/*.whl' : dist/ vit dans le workspace
+        // persistant et garde les roues des builds precedents. Aucune roue a ce nom est une
+        // erreur -- un build qui annonce une roue archivee et n'en archive aucune ment.
+        archiveArtifacts(artifacts: "dist/*-${version}-*.whl", fingerprint: true)
+    }
+    // Test STRICT de 'true' : la publication n'a lieu que si elle est demandee, jamais par
+    // defaut d'une valeur inattendue.
+    if (env._PUBLISH != 'true') {
+        echo "publish: false -- nothing sent to PyPI."
+        return
+    }
     withEnv([
         "UV_PUBLISH_USERNAME=${credentialFrom(env._PYPI_FILE, 'FLIT_USERNAME')}",
         "UV_PUBLISH_PASSWORD=${credentialFrom(env._PYPI_FILE, 'FLIT_PASSWORD')}",