pyannotators-entityfishing 1.6.97__tar.gz → 1.6.99__tar.gz

{pyannotators_entityfishing-1.6.97 → pyannotators_entityfishing-1.6.99}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: pyannotators-entityfishing
-Version: 1.6.97
+Version: 1.6.99
 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.97 → pyannotators_entityfishing-1.6.99}/Taskfile.yml

@@ -27,7 +27,7 @@ includes:
       # les siens qui n'ont de sens que dans Jenkins (init, version, py:publish), et son
       # checkStageDrift() vérifie que cette liste en est un sous-ensemble ORDONNÉ.
       STAGES: >-
-        py:sync py:lint py:test
+        py:sync py:lint py:test py:help-check
         py:sbom py:check-vulnerabilities
         py:build py:publish
       TEST_STAGE: py:test

{pyannotators_entityfishing-1.6.97 → pyannotators_entityfishing-1.6.99}/src/pyannotators_entityfishing/__init__.py

@@ -1,3 +1,3 @@
 """Annotator based on entity-fishing"""
 
-__version__ = "1.6.97"
+__version__ = "1.6.99"

{pyannotators_entityfishing-1.6.97 → pyannotators_entityfishing-1.6.99}/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.3.2",
+  "version": "1.3.4",
   "description": "Cree et entretient les depots Python de Kairntech qui consomment python-archetype : creation d'un plugin a partir de sa graine, page d'aide Sherpa d'un plugin, et mesure de la derive d'un depot par rapport a elle.",
   "author": {
     "name": "Kairntech",

{pyannotators_entityfishing-1.6.97 → pyannotators_entityfishing-1.6.99}/submodules/python-archetype/resources/help/help_examples.py

@@ -24,6 +24,7 @@ Le dépôt du plugin rend la fixture visible depuis 'tests/conftest.py' :
     from help_examples import help_example  # noqa: E402, F401
 """
 
+import io
 import json
 from pathlib import Path
 
@@ -36,14 +37,61 @@ EXAMPLES_DIR = Path("build") / "help-examples"
 MAX_CONTENT = 100_000
 
 
-def _content(data: bytes) -> dict:
-    """Le contenu d'un fichier ou d'une réponse : son texte s'il en est un, sa taille sinon."""
-    content = {"size": len(data)}
+# Un classeur se montre par sa première feuille : au-delà, la page n'en citerait qu'un extrait.
+MAX_SHEET_ROWS = 50
+
+
+def _sheet(data: bytes) -> dict | None:
+    """La première feuille d'un classeur Excel, ou None si ce n'en est pas un (ou sans openpyxl)."""
+    if not data.startswith(b"PK"):
+        return None
     try:
-        text = data.decode("utf-8")
+        import openpyxl
+
+        workbook = openpyxl.load_workbook(io.BytesIO(data), read_only=True, data_only=True)
+    except Exception:  # noqa: BLE001 -- une archive zip qui n'est pas un classeur, ou pas d'openpyxl
+        return None
+    sheet = workbook.worksheets[0]
+    rows = []
+    for row in sheet.iter_rows(values_only=True):
+        if len(rows) == MAX_SHEET_ROWS:
+            break
+        rows.append(["" if value is None else str(value) for value in row])
+    # Sans les colonnes vides de droite, qu'openpyxl rend quand une ligne est plus longue.
+    width = max((max((i + 1 for i, v in enumerate(row) if v), default=0) for row in rows), default=0)
+    return {"name": sheet.title, "sheets": len(workbook.worksheets), "rows": [row[:width] for row in rows]}
+
+
+def _text(data: bytes) -> tuple[str, str] | None:
+    """Le texte et son encodage : UTF-8, sinon Latin-1 (cp1252) pour un texte sans octet de contrôle."""
+    try:
+        return data.decode("utf-8"), "utf-8"
     except UnicodeDecodeError:
+        pass
+    # Latin-1 décode n'importe quels octets : un octet de contrôle (hors tabulation et fins
+    # de ligne) trahit un contenu binaire.
+    if any(byte < 0x20 and byte not in b"\t\n\r\f" for byte in data):
+        return None
+    try:
+        return data.decode("cp1252"), "cp1252"
+    except UnicodeDecodeError:
+        return None
+
+
+def _content(data: bytes) -> dict:
+    """Le contenu d'un fichier ou d'une réponse : son texte, la première feuille d'un classeur, ou sa taille."""
+    content = {"size": len(data)}
+    sheet = _sheet(data)
+    if sheet is not None:
+        content["sheet"] = sheet
+        return content
+    decoded = _text(data)
+    if decoded is None:
         return content
+    text, encoding = decoded
     content["text"] = text[:MAX_CONTENT]
+    if encoding != "utf-8":
+        content["encoding"] = encoding
     if len(text) > MAX_CONTENT:
         content["truncated"] = True
     return content

{pyannotators_entityfishing-1.6.97 → pyannotators_entityfishing-1.6.99}/submodules/python-archetype/resources/help/plugin-help.py

@@ -142,11 +142,10 @@ TEXTS = {
         "sentence": "Phrase",
         "categories": "Catégories",
         "produced_text": "Texte produit :",
-        "sentences_count": "{n} phrase(s).",
         "no_sentences": "Aucune phrase.",
         "no_documents": "Aucun document.",
-        "no_concepts": "Aucun concept.",
-        "concepts_count": "{n} concept(s).",
+        "no_concepts": "Aucun terme.",
+        "concepts_count": "{n} terme(s).",
         "response": "Réponse",
         "file_named": "fichier",
         "binary": "Contenu binaire, {n} octets.",
@@ -158,6 +157,21 @@ TEXTS = {
         "score": "Score",
         "identifier": "Identifiant",
         "alt_forms": "Formes alternatives",
+        "no_parameters": "Ce plugin n'a aucun paramètre.",
+        "annotations_removed": "Annotations en entrée retirées : toutes ({n}).",
+        "categories_removed": "Catégories en entrée retirées : toutes ({n}).",
+        "sentences_removed": "Phrases en entrée retirées : toutes ({n}).",
+        "metadata_removed": "Métadonnées retirées :",
+        "sentences": "Phrases ({n}) :",
+        "empty_sentence": "*(phrase vide)*",
+        "produced_document": "Document produit",
+        "identifier_named": "identifiant",
+        "title": "Titre",
+        "properties": "Propriétés :",
+        "sheet": "Feuille `{name}`",
+        "first_sheet": "Feuille `{name}`, la première des {n}",
+        "encoding": "encodé en {encoding}",
+        "decimal": ",",
     },
     "en": {
         "languages": "**Supported languages:**",
@@ -189,11 +203,10 @@ TEXTS = {
         "sentence": "Sentence",
         "categories": "Categories",
         "produced_text": "Produced text:",
-        "sentences_count": "{n} sentence(s).",
         "no_sentences": "No sentences.",
         "no_documents": "No documents.",
-        "no_concepts": "No concepts.",
-        "concepts_count": "{n} concept(s).",
+        "no_concepts": "No terms.",
+        "concepts_count": "{n} term(s).",
         "response": "Response",
         "file_named": "file",
         "binary": "Binary content, {n} bytes.",
@@ -205,6 +218,21 @@ TEXTS = {
         "score": "Score",
         "identifier": "Identifier",
         "alt_forms": "Alternative forms",
+        "no_parameters": "This plugin has no parameters.",
+        "annotations_removed": "Input annotations removed: all of them ({n}).",
+        "categories_removed": "Input categories removed: all of them ({n}).",
+        "sentences_removed": "Input sentences removed: all of them ({n}).",
+        "metadata_removed": "Metadata removed:",
+        "sentences": "Sentences ({n}):",
+        "empty_sentence": "*(empty sentence)*",
+        "produced_document": "Produced document",
+        "identifier_named": "identifier",
+        "title": "Title",
+        "properties": "Properties:",
+        "sheet": "Sheet `{name}`",
+        "first_sheet": "Sheet `{name}`, the first of {n}",
+        "encoding": "encoded in {encoding}",
+        "decimal": ".",
     },
 }
 
@@ -287,6 +315,8 @@ def existing_rows(body: str) -> dict[str, list[str]]:
 def parameters_block(schema: dict, old_body: str, lang: str) -> str:
     texts = TEXTS[lang]
     old = existing_rows(old_body)
+    if not any("internal" not in str(prop.get("extra", "")) for prop in schema.get("properties", {}).values()):
+        return texts["no_parameters"] + "\n"
     lines = [texts["header"], "|---|---|---|"]
     for name, prop in schema.get("properties", {}).items():
         extra = {flag.strip() for flag in str(prop.get("extra", "")).split(",")}
@@ -358,17 +388,29 @@ def text_lead(doc: dict, lang: str) -> list[str]:
     return [lead + texts["colon"], *excerpt(doc.get("text", ""), lang)]
 
 
+# Une ligne indentée, un simple retour à la ligne entre deux lignes, ou des espaces alignés :
+# une citation Markdown les écraserait.
+LAYOUT = re.compile(r"^[ \t]+\S|\S[ \t]*\n[ \t]*\S|\S {2,}\S|\t", re.MULTILINE)
+
+
 def excerpt(text: str, lang: str) -> list[str]:
-    if len(text) <= MAX_TEXT:
-        return [quote(text)]
-    return [quote(text[:MAX_TEXT].rsplit(" ", 1)[0] + " …"), TEXTS[lang]["truncated_text"].format(n=len(text))]
+    """Le texte, cité ; dans un bloc de code quand sa mise en page compte, pour qu'on la voie."""
+    shown = text if len(text) <= MAX_TEXT else text[:MAX_TEXT].rsplit(" ", 1)[0] + " …"
+    parts = code_block(shown, "text", lang, max_line=None) if LAYOUT.search(text.strip("\n")) else [quote(shown)]
+    if len(text) > MAX_TEXT:
+        parts.append(TEXTS[lang]["truncated_text"].format(n=len(text)))
+    return parts
+
+
+def number(value: float, lang: str) -> str:
+    return f"{value:.2f}".replace(".", TEXTS[lang]["decimal"])
 
 
-def code_block(text: str, kind: str, lang: str) -> list[str]:
+def code_block(text: str, kind: str, lang: str, max_line: int | None = MAX_LINE) -> list[str]:
     """Un extrait de contenu dans un bloc de code ; 'kind' est un type MIME ou un nom de fichier."""
     fence_lang = next((name for name in ("json", "xml", "html", "csv", "markdown") if name in kind.lower()), "text")
-    lines = text.rstrip("\n").splitlines()
-    shown = [line if len(line) <= MAX_LINE else line[:MAX_LINE] + " …" for line in lines[:MAX_LINES]]
+    lines = text.strip("\n").splitlines()
+    shown = [line if max_line is None or len(line) <= max_line else line[:max_line] + " …" for line in lines[:MAX_LINES]]
     fence = "~~~~" if "```" in text else "```"
     parts = [f"{fence}{fence_lang}\n" + "\n".join(shown) + f"\n{fence}"]
     if len(lines) > MAX_LINES:
@@ -376,16 +418,51 @@ def code_block(text: str, kind: str, lang: str) -> list[str]:
     return parts
 
 
+# L'encodage que la fixture a reconnu, sous le nom que connaît un utilisateur.
+ENCODINGS = {"cp1252": "Latin-1 / Windows-1252"}
+
+
 def file_lead(source: dict, lang: str) -> list[str]:
     """Le fichier d'entrée d'un convertisseur ou d'un importeur : son nom, puis son contenu."""
     texts = TEXTS[lang]
     media_type = source.get("content_type")
-    lead = f"{texts['file']}{texts['colon']} `{source.get('filename', '')}`" + (f" ({media_type})" if media_type else "")
-    if "text" in source:
-        return [lead, *code_block(source["text"], media_type or source.get("filename", ""), lang)]
-    if "size" in source:
-        return [lead, texts["binary"].format(n=source["size"])]
-    return [lead]
+    details = [media_type] if media_type else []
+    if source.get("encoding"):
+        details.append(texts["encoding"].format(encoding=ENCODINGS.get(source["encoding"], source["encoding"])))
+    lead = f"{texts['file']}{texts['colon']} `{source.get('filename', '')}`" + (f" ({', '.join(details)})" if details else "")
+    return [lead, *content_view(source, media_type or source.get("filename", ""), lang)]
+
+
+def column_name(index: int) -> str:
+    """A, B, …, Z, AA, AB… : le nom d'une colonne Excel."""
+    name = ""
+    index += 1
+    while index:
+        index, rest = divmod(index - 1, 26)
+        name = chr(ord("A") + rest) + name
+    return name
+
+
+def content_view(content: dict, kind: str, lang: str) -> list[str]:
+    """Le contenu d'un fichier ou d'une réponse : son texte, la première feuille d'un classeur, ou sa taille."""
+    texts = TEXTS[lang]
+    if "text" in content:
+        return code_block(content["text"], kind, lang)
+    if "sheet" in content:
+        # La taille d'un classeur dépend de la version d'openpyxl : on montre ses cellules.
+        sheet = content["sheet"]
+        many = sheet.get("sheets", 1) > 1
+        lead = texts["first_sheet" if many else "sheet"].format(name=cell(sheet.get("name", "")), n=sheet.get("sheets", 1))
+        rows = [[cell(value) or " " for value in row] for row in sheet.get("rows", [])]
+        if not rows:
+            return [lead + texts["colon"], texts["empty"]]
+        width = max(len(row) for row in rows)
+        rows = [row + [" "] * (width - len(row)) for row in rows]
+        # Les colonnes nommées comme dans Excel : rien ne dit si la première ligne est un en-tête.
+        return [lead + texts["colon"], table([column_name(i) for i in range(width)], rows, lang)]
+    if "size" in content:
+        return [texts["binary"].format(n=content["size"])]
+    return []
 
 
 def annotations_table(annotations: list[dict], lang: str, doc_text: str = "") -> str:
@@ -424,7 +501,7 @@ def categories_table(categories: list[dict], lang: str) -> str:
     for c in categories:
         row = [f"`{cell(c.get('labelName') or c.get('label') or '')}`"]
         if with_score:
-            row.append(f"{c['score']:.2f}" if isinstance(c.get("score"), (int, float)) else "—")
+            row.append(number(c["score"], lang) if isinstance(c.get("score"), (int, float)) else "—")
         rows.append(row)
     return table(header, rows, lang)
 
@@ -446,34 +523,100 @@ def input_view(doc: dict, lang: str) -> list[str]:
     return parts
 
 
+MARKDOWN_INLINE = re.compile(r"([*_`])")
+MARKDOWN_LEAD = re.compile(r"^([-+#>])")
+MARKDOWN_NUMBER = re.compile(r"^(\d+)([.)])")
+
+
+def sentence_text(text: str, sent: dict, lang: str, limit: int | None = None) -> str:
+    # Échappée : une phrase « * Conseil » ou « 1. Bilan » deviendrait une liste dans la liste.
+    phrase = MARKDOWN_INLINE.sub(r"\\\1", cell(text[sent["start"] : sent["end"]]))
+    phrase = MARKDOWN_NUMBER.sub(r"\1\\\2", MARKDOWN_LEAD.sub(r"\\\1", phrase))
+    if not phrase:
+        return TEXTS[lang]["empty_sentence"]
+    return phrase if limit is None or len(phrase) <= limit else phrase[:limit].rsplit(" ", 1)[0] + " …"
+
+
+def sentences_list(doc: dict, lang: str) -> list[str]:
+    """Les phrases, numérotées ; une phrase vide est dite, pas sautée."""
+    texts = TEXTS[lang]
+    sentences = doc.get("sentences") or []
+    if not sentences:
+        return [texts["no_sentences"]]
+    text = doc.get("text", "")
+    parts = ["\n".join(f"{n}. {sentence_text(text, s, lang)}" for n, s in enumerate(sentences[:MAX_ROWS], start=1))]
+    if len(sentences) > MAX_ROWS:
+        parts.append(texts["truncated_rows"].format(n=len(sentences)))
+    return parts
+
+
+def sentence_categories(doc: dict, lang: str) -> list[str]:
+    """Un processeur peut catégoriser chaque phrase plutôt que le document : phrase, labels et scores."""
+    texts = TEXTS[lang]
+    text = doc.get("text", "")
+    rows = []
+    for sent in doc["sentences"]:
+        if not sent.get("categories"):
+            continue
+        labels = []
+        for c in sent["categories"]:
+            label = f"`{cell(c.get('labelName') or c.get('label') or '')}`"
+            labels.append(label + (f" ({number(c['score'], lang)})" if isinstance(c.get("score"), (int, float)) else ""))
+        rows.append([sentence_text(text, sent, lang, limit=80), ", ".join(labels)])
+    return [texts["sentence_categories"], table([texts["sentence"], texts["categories"]], rows, lang)] if rows else []
+
+
+def document_lead(doc: dict, lang: str) -> list[str]:
+    """Un document produit sans document en entrée (un convertisseur) : identifiant, titre, propriétés."""
+    texts = TEXTS[lang]
+    lead = texts["produced_document"]
+    if doc.get("identifier"):
+        lead += f", {texts['identifier_named']} `{cell(doc['identifier'])}`"
+    parts = [lead + "."]
+    if doc.get("title"):
+        parts.append(f"{texts['title']}{texts['colon']} {cell(doc['title'])}")
+    if doc.get("properties"):
+        parts += [texts["properties"], metadata_table(doc["properties"], lang)]
+    return parts
+
+
 def output_view(doc: dict, before: dict | None, lang: str) -> list[str]:
-    """Un document en sortie : ce qui a changé par rapport à l'entrée, ou tout s'il n'y en a pas."""
+    """Un document en sortie : ce qui a changé par rapport à l'entrée, ce qui a été retiré compris."""
     texts = TEXTS[lang]
+    parts = document_lead(doc, lang) if before is None else []
     before = before or {}
-    parts = []
     if doc.get("text", "") != before.get("text", ""):
         parts += [texts["produced_text"], *excerpt(doc.get("text", ""), lang)]
-    if doc.get("sentences") and doc.get("sentences") != before.get("sentences"):
-        parts.append(texts["sentences_count"].format(n=len(doc["sentences"])))
-        # Un processeur peut catégoriser chaque phrase plutôt que le document.
-        categorized = [sent for sent in doc["sentences"] if sent.get("categories")]
-        if categorized:
-            text = doc.get("text", "")
-            rows = []
-            for sent in categorized:
-                phrase = cell(text[sent["start"] : sent["end"]])
-                phrase = phrase if len(phrase) <= 80 else phrase[:80].rsplit(" ", 1)[0] + " …"
-                labels = ", ".join(f"`{cell(c.get('labelName') or c.get('label') or '')}`" for c in sent["categories"])
-                rows.append([phrase, labels])
-            parts += [texts["sentence_categories"], table([texts["sentence"], texts["categories"]], rows, lang)]
-    if doc.get("annotations") and doc.get("annotations") != before.get("annotations"):
-        parts += [texts["annotations_out"], annotations_table(doc["annotations"], lang, doc.get("text", ""))]
-    if doc.get("categories") and doc.get("categories") != before.get("categories"):
-        parts += [texts["categories_out"], categories_table(doc["categories"], lang)]
+    # Une liste vide vaut une liste absente (exclude_none ne retire que les None).
+    if (doc.get("sentences") or []) != (before.get("sentences") or []):
+        if doc.get("sentences"):
+            categorized = sentence_categories(doc, lang)
+            if categorized:
+                parts += categorized
+            else:
+                parts += [texts["sentences"].format(n=len(doc["sentences"])), *sentences_list(doc, lang)]
+        else:
+            parts.append(texts["sentences_removed"].format(n=len(before["sentences"])))
+    # Une liste qui disparaît se dit : sans quoi un processeur qui vide le document paraîtrait inactif.
+    tables = {
+        "annotations": lambda: annotations_table(doc["annotations"], lang, doc.get("text", "")),
+        "categories": lambda: categories_table(doc["categories"], lang),
+    }
+    for key, table_of in tables.items():
+        if (doc.get(key) or []) == (before.get(key) or []):
+            continue
+        if doc.get(key):
+            parts += [texts[f"{key}_out"], table_of()]
+        else:
+            parts.append(texts[f"{key}_removed"].format(n=len(before[key])))
     old_metadata = before.get("metadata") or {}
-    changed = {key: value for key, value in (doc.get("metadata") or {}).items() if old_metadata.get(key) != value}
+    metadata = doc.get("metadata") or {}
+    changed = {key: value for key, value in metadata.items() if old_metadata.get(key) != value}
     if changed:
         parts += [texts["metadata_out"], metadata_table(changed, lang)]
+    removed = [key for key in old_metadata if key not in metadata]
+    if removed:
+        parts.append(f"{texts['metadata_removed']} " + ", ".join(f"`{cell(key)}`" for key in removed) + ".")
     return parts or [texts["unchanged"]]
 
 
@@ -516,19 +659,10 @@ def processor_example(example: dict, schema: dict, lang: str) -> str:
 
 def segmenter_example(example: dict, schema: dict, lang: str) -> str:
     """Le texte, les paramètres, puis les phrases, numérotées."""
-    texts = TEXTS[lang]
     parts = [part for doc in as_list(example["inputs"]) for part in text_lead(doc, lang)]
     parts.append(parameters_line(example["parameters"], schema, lang))
     for doc in as_list(example["outputs"]):
-        sentences = doc.get("sentences") or []
-        if not sentences:
-            parts.append(texts["no_sentences"])
-            continue
-        text = doc.get("text", "")
-        items = [f"{n}. {cell(text[s['start'] : s['end']])}" for n, s in enumerate(sentences[:MAX_ROWS], start=1)]
-        parts.append("\n".join(items))
-        if len(sentences) > MAX_ROWS:
-            parts.append(texts["truncated_rows"].format(n=len(sentences)))
+        parts += sentences_list(doc, lang)
     return "\n\n".join(parts) + "\n"
 
 
@@ -552,10 +686,7 @@ def formatter_example(example: dict, schema: dict, lang: str) -> str:
         if filename:
             lead += f", {texts['file_named']} `{filename.group(1)}`"
         parts.append(lead)
-        if "text" in response:
-            parts += code_block(response["text"], media_type or "", lang)
-        elif "size" in response:
-            parts.append(texts["binary"].format(n=response["size"]))
+        parts += content_view(response, media_type or "", lang)
     return "\n\n".join(parts) + "\n"
 
 

{pyannotators_entityfishing-1.6.97 → pyannotators_entityfishing-1.6.99}/submodules/python-archetype/skills/plugin-help/SKILL.md

@@ -115,11 +115,11 @@ que le test passe à `help_example` aussi :
 | type | `inputs` | `outputs` | ce que la page montre |
 |------|----------|-----------|------------------------|
 | annotateur | les documents | les documents | le texte, puis les annotations |
-| processeur | les documents | les documents | le texte et ce qu'il porte déjà, puis **ce qui a changé** : texte, phrases, annotations, catégories (du document ou par phrase), métadonnées |
+| processeur | les documents | les documents | le texte et ce qu'il porte déjà, puis **ce qui a changé** : texte, phrases, annotations, catégories (du document ou par phrase, avec leur score), métadonnées — **et ce qui a été retiré** |
 | segmenteur | les documents | les documents | le texte, puis les phrases numérotées |
-| convertisseur | l'`UploadFile` | les documents | le fichier (extrait), puis les documents produits |
-| formateur | le document | la `Response` | le document, puis le type, le nom de fichier et un extrait de la réponse — ou sa taille si elle est binaire |
-| importeur | le chemin du fichier | **la liste** des concepts | le fichier (extrait), puis les concepts : identifiant, forme préférée, formes alternatives |
+| convertisseur | l'`UploadFile` | les documents | le fichier (extrait), puis chaque document produit : identifiant, titre, propriétés, texte et phrases numérotées (les phrases vides comprises) |
+| formateur | le document | la `Response` | le document, puis le type, le nom de fichier et un extrait de la réponse — la première feuille pour un classeur Excel, la taille pour un autre contenu binaire |
+| importeur | le chemin du fichier | **la liste** des concepts | le fichier (extrait, ou la première feuille d'un classeur Excel), puis les termes : identifiant, forme préférée, formes alternatives |
 
 Trois pièges, que la fixture signale ou ne peut pas rattraper :
 
@@ -136,6 +136,14 @@ Les textes, fichiers et réponses longs sont tronqués au rendu (1 000 caractèr
 20 lignes de 160 caractères, 20 lignes de tableau) : choisir des fixtures courtes
 plutôt que compter sur la troncature.
 
+Un texte dont la mise en page compte (une ligne indentée, un simple retour à la
+ligne, des espaces alignés) est montré dans un bloc de code plutôt qu'en citation,
+qui l'écraserait. Un fichier qui n'est pas en UTF-8 est lu en Latin-1 et le rendu le
+dit. Un classeur Excel est montré par sa première feuille, pas par sa taille : la
+taille d'un `.xlsx` change avec la version d'openpyxl et ferait échouer
+`py:help-check`. Il faut openpyxl dans l'environnement de test, ce qui est déjà le
+cas d'un plugin qui lit ou écrit de l'Excel.
+
 Un exemple dans une langue (un texte français dans la page anglaise) se garde tel
 quel — la langue du document est indiquée par le rendu (« Text (French) ») : le
 traduire, c'est montrer une sortie que personne n'a obtenue.