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

pyannotators_entityfishing-1.6.103/LICENSE

@@ -0,0 +1,17 @@
+Copyright (c) 2026 Kairntech. All rights reserved.
+
+This software and its documentation are the proprietary and confidential
+property of Kairntech. They are protected by copyright law and international
+treaties.
+
+No part of this software may be used, copied, modified, merged, published,
+distributed, sublicensed or sold, in source or binary form, without the prior
+written permission of Kairntech, except as expressly permitted by a separate
+license agreement signed with Kairntech.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+KAIRNTECH BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

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

@@ -1,15 +1,16 @@
 Metadata-Version: 2.5
 Name: pyannotators-entityfishing
-Version: 1.6.99
+Version: 1.6.103
 Summary: Annotator based on entity-fishing
 Project-URL: Homepage, https://github.com/oterrier/pyannotators_entityfishing/
 Author-email: Olivier Terrier <olivier.terrier@kairntech.com>
-License: MIT
+License: Proprietary
+License-File: LICENSE
 Classifier: Development Status :: 4 - Beta
 Classifier: Intended Audience :: Developers
 Classifier: Intended Audience :: Information Technology
 Classifier: Intended Audience :: System Administrators
-Classifier: License :: OSI Approved :: MIT License
+Classifier: License :: Other/Proprietary License
 Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Topic :: Software Development
@@ -48,6 +49,10 @@ Description-Content-Type: text/markdown
 
 # pyannotators-entityfishing
 
+[![license](https://img.shields.io/badge/license-proprietary-red)](LICENSE)
+[![version](https://img.shields.io/pypi/v/pyannotators-entityfishing)](https://pypi.org/project/pyannotators-entityfishing/)
+[![PyPI - Python Version](https://img.shields.io/pypi/pyversions/pyannotators-entityfishing)](https://pypi.org/project/pyannotators-entityfishing/)
+
 Annotator based on [entity-fishing](https://github.com/kermitt2/entity-fishing) for named entity recognition and disambiguation against Wikidata.
 
 ## Installation

{pyannotators_entityfishing-1.6.99 → pyannotators_entityfishing-1.6.103}/README.md

@@ -1,5 +1,9 @@
 # pyannotators-entityfishing
 
+[![license](https://img.shields.io/badge/license-proprietary-red)](LICENSE)
+[![version](https://img.shields.io/pypi/v/pyannotators-entityfishing)](https://pypi.org/project/pyannotators-entityfishing/)
+[![PyPI - Python Version](https://img.shields.io/pypi/pyversions/pyannotators-entityfishing)](https://pypi.org/project/pyannotators-entityfishing/)
+
 Annotator based on [entity-fishing](https://github.com/kermitt2/entity-fishing) for named entity recognition and disambiguation against Wikidata.
 
 ## Installation

{pyannotators_entityfishing-1.6.99 → pyannotators_entityfishing-1.6.103}/pyproject.toml

@@ -8,7 +8,7 @@ dynamic = ["version"]
 description = "Annotator based on entity-fishing"
 readme = "README.md"
 requires-python = ">=3.12"
-license = {text = "MIT"}
+license = {text = "Proprietary"}
 authors = [
     {name = "Olivier Terrier", email = "olivier.terrier@kairntech.com"},
 ]
@@ -23,7 +23,7 @@ classifiers = [
     "Topic :: Software Development :: Libraries :: Python Modules",
     "Topic :: Software Development :: Libraries",
     "Topic :: Software Development",
-    "License :: OSI Approved :: MIT License",
+    "License :: Other/Proprietary License",
     "Development Status :: 4 - Beta",
     "Programming Language :: Python :: 3.12",
 ]

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

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

{pyannotators_entityfishing-1.6.99 → pyannotators_entityfishing-1.6.103}/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.4",
+  "version": "1.3.7",
   "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.99 → pyannotators_entityfishing-1.6.103}/submodules/python-archetype/resources/help/help_examples.py

@@ -26,6 +26,7 @@ Le dépôt du plugin rend la fixture visible depuis 'tests/conftest.py' :
 
 import io
 import json
+import zipfile
 from pathlib import Path
 
 import pytest
@@ -37,29 +38,53 @@ EXAMPLES_DIR = Path("build") / "help-examples"
 MAX_CONTENT = 100_000
 
 
-# Un classeur se montre par sa première feuille : au-delà, la page n'en citerait qu'un extrait.
+# Un classeur se montre par ses feuilles : au-delà, la page n'en citerait qu'un extrait.
+MAX_SHEETS = 5
 MAX_SHEET_ROWS = 50
+# Une archive se montre par la liste de ses fichiers, et le texte des premiers.
+MAX_MEMBERS = 20
 
 
-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
+def _sheets(data: bytes) -> list[dict] | None:
+    """Les feuilles d'un classeur Excel, ou None si ce n'en est pas un (ou sans openpyxl)."""
     try:
         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]}
+    sheets = []
+    for sheet in workbook.worksheets[:MAX_SHEETS]:
+        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)
+        sheets.append({"name": sheet.title, "rows": [row[:width] for row in rows]})
+    return sheets
+
+
+def _archive(data: bytes) -> list[dict] | None:
+    """Les fichiers d'une archive zip : nom, taille, et texte quand c'en est un."""
+    try:
+        archive = zipfile.ZipFile(io.BytesIO(data))
+    except zipfile.BadZipFile:
+        return None
+    # Un document Office (docx, pptx) est une archive, mais ses fichiers XML n'apprennent rien au lecteur.
+    if "[Content_Types].xml" in archive.namelist():
+        return None
+    members = []
+    for info in archive.infolist()[:MAX_MEMBERS]:
+        if info.is_dir():
+            continue
+        member = {"name": info.filename, "size": info.file_size}
+        decoded = _text(archive.read(info))
+        if decoded is not None:
+            member["text"] = decoded[0][:MAX_CONTENT]
+        members.append(member)
+    return members
 
 
 def _text(data: bytes) -> tuple[str, str] | None:
@@ -79,12 +104,17 @@ def _text(data: bytes) -> tuple[str, str] | 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."""
+    """Le contenu d'un fichier ou d'une réponse : son texte, les feuilles d'un classeur, les fichiers d'une archive, ou sa taille."""
     content = {"size": len(data)}
-    sheet = _sheet(data)
-    if sheet is not None:
-        content["sheet"] = sheet
-        return content
+    if data.startswith(b"PK"):
+        sheets = _sheets(data)
+        if sheets is not None:
+            content["sheets"] = sheets
+            return content
+        members = _archive(data)
+        if members is not None:
+            content["archive"] = members
+            return content
     decoded = _text(data)
     if decoded is None:
         return content

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

@@ -163,15 +163,27 @@ TEXTS = {
         "sentences_removed": "Phrases en entrée retirées : toutes ({n}).",
         "metadata_removed": "Métadonnées retirées :",
         "sentences": "Phrases ({n}) :",
+        "sentences_in": "Phrases en entrée ({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": ",",
+        "list_sep": " ; ",
+        "empty_text": "*(texte vide)*",
+        "alt_texts_in": "Textes alternatifs en entrée :",
+        "alt_texts_out": "Textes alternatifs :",
+        "alt_texts_removed": "Textes alternatifs en entrée retirés : tous ({n}).",
+        "name": "Nom",
+        "properties_col": "Propriétés",
+        "display_label": "Libellé",
+        "archive": "Archive de {n} fichier(s) :",
+        "size": "Taille",
+        "bytes": "{n} octets",
+        "archive_member": "Fichier `{name}` de l'archive :",
     },
     "en": {
         "languages": "**Supported languages:**",
@@ -224,15 +236,27 @@ TEXTS = {
         "sentences_removed": "Input sentences removed: all of them ({n}).",
         "metadata_removed": "Metadata removed:",
         "sentences": "Sentences ({n}):",
+        "sentences_in": "Input 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": ".",
+        "list_sep": "; ",
+        "empty_text": "*(empty text)*",
+        "alt_texts_in": "Input alternative texts:",
+        "alt_texts_out": "Alternative texts:",
+        "alt_texts_removed": "Input alternative texts removed: all of them ({n}).",
+        "name": "Name",
+        "properties_col": "Properties",
+        "display_label": "Display label",
+        "archive": "Archive of {n} file(s):",
+        "size": "Size",
+        "bytes": "{n} bytes",
+        "archive_member": "File `{name}` in the archive:",
     },
 }
 
@@ -270,7 +294,7 @@ def languages_block(codes: list[str], lang: str) -> str:
     return f"{texts['languages']} {names}.\n"
 
 
-def format_default(prop: dict, lang: str) -> str | None:
+def format_default(prop: dict, lang: str, max_len: int | None = None) -> str | None:
     """La valeur par défaut affichée, ou None quand le code n'en donne pas d'utile.
 
     None couvre le défaut 'None' du code, qui veut presque toujours dire « valeur calculée »
@@ -286,9 +310,52 @@ def format_default(prop: dict, lang: str) -> str | None:
         return texts["true"] if value else texts["false"]
     if value == "":
         return texts["empty"]
+    text = one_line(value)
+    # Tronquée au-delà de 'max_len' caractères, accents graves compris (la cellule d'un tableau).
+    if max_len is not None and len(text) + 2 > max_len:
+        text = text[: max_len - 2].rstrip() + " …"
+    return inline_code(text)
+
+
+def inline_code(text: str) -> str:
+    """Du code en ligne, délimité par plus d'accents graves que n'en contient le texte (CommonMark)."""
+    runs = [len(run) for run in re.findall(r"`+", text)]
+    fence = "`" * (max(runs, default=0) + 1)
+    pad = " " if text.startswith("`") or text.endswith("`") else ""
+    return f"{fence}{pad}{text}{pad}{fence}"
+
+
+def one_line(value) -> str:
+    """Une valeur sur une ligne : une ligne de tableau ne survit pas à un retour à la ligne.
+
+    Une chaîne qui contient du JSON (une règle, un mapping) est montrée comme du JSON compact,
+    pas échappée ; les autres caractères de contrôle s'écrivent comme dans le code (\\n, \\t).
+    """
+    if isinstance(value, str):
+        stripped = value.strip()
+        if stripped[:1] in "[{":
+            try:
+                return json.dumps(json.loads(stripped), ensure_ascii=False)
+            except ValueError:
+                pass
+        return value.replace("\\", "\\\\").replace("\n", "\\n").replace("\r", "\\r").replace("\t", "\\t")
     if isinstance(value, (list, dict)):
-        return f"`{json.dumps(value, ensure_ascii=False)}`"
-    return f"`{value}`"
+        return json.dumps(decode_json_strings(value), ensure_ascii=False)
+    return str(value)
+
+
+def decode_json_strings(value):
+    # Un dict de chaînes JSON (un mapping par label, par exemple) se lit mieux décodé.
+    if isinstance(value, dict):
+        return {key: decode_json_strings(item) for key, item in value.items()}
+    if isinstance(value, list):
+        return [decode_json_strings(item) for item in value]
+    if isinstance(value, str) and value.strip()[:1] in "[{":
+        try:
+            return json.loads(value)
+        except ValueError:
+            return value
+    return value
 
 
 def escape(cell: str) -> str:
@@ -327,7 +394,9 @@ def parameters_block(schema: dict, old_body: str, lang: str) -> str:
         if "advanced" in extra:
             first += f" *({texts['advanced']})*"
         previous = old.get(name)
-        default = format_default(prop, lang)
+        # Une valeur longue (un jeu de règles JSON) écraserait le tableau : son début suffit,
+        # le reste est dans le code et, au besoin, dans la prose.
+        default = format_default(prop, lang, max_len=MAX_DEFAULT)
         if default is None:
             default = previous[1] if previous else "—"
         else:
@@ -345,7 +414,11 @@ def parameters_line(params: dict, schema: dict, lang: str) -> str:
     properties = schema.get("properties", {})
     used = []
     # Dans l'ordre du schéma, celui de l'interface ; un paramètre inconnu du schéma, à la fin.
-    for name in sorted(params, key=lambda n: list(properties).index(n) if n in properties else len(properties)):
+    # Un paramètre interne (la langue du projet, par exemple) est fixé par Sherpa, pas par l'utilisateur.
+    shown_params = [name for name in params if "internal" not in str(properties.get(name, {}).get("extra", ""))]
+    if not shown_params:
+        return texts["default_parameters"]
+    for name in sorted(shown_params, key=lambda n: list(properties).index(n) if n in properties else len(properties)):
         value = params[name]
         title = properties.get(name, {}).get("title") or name
         shown = format_default({"default": value}, lang) or "`None`"
@@ -357,15 +430,30 @@ def quote(text: str) -> str:
     return "\n".join(f"> {line}".rstrip() for line in text.strip().splitlines())
 
 
-def cell(text: str) -> str:
+# Une balise ou une entité : Sherpa interpréterait le HTML d'une citation ou d'une cellule.
+MARKUP = re.compile(r"<[A-Za-z/!?]|&#?\w+;")
+
+
+def code(text: str) -> str:
+    """Un nom technique, à mettre entre accents graves : rien n'y est interprété, sauf la barre."""
     return escape(" ".join(text.split()))
 
 
+def cell(text: str) -> str:
+    # '<' et '&' échappés : une balise produite par le plugin (<personne>) se lit au lieu de disparaître.
+    return escape(" ".join(text.split()).replace("&", "&amp;").replace("<", "&lt;"))
+
+
 # Une page montre un extrait, pas un document entier.
 MAX_TEXT = 1000
 MAX_LINES = 20
 MAX_LINE = 160
 MAX_ROWS = 20
+MAX_JSON_LINES = 60
+# Un fichier XML ou HTML dit l'essentiel après son en-tête : il en faut plus de MAX_LINES.
+MAX_MARKUP_LINES = 60
+MAX_CELL = 80
+MAX_DEFAULT = 100
 
 
 def as_list(value) -> list:
@@ -395,8 +483,15 @@ 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]:
     """Le texte, cité ; dans un bloc de code quand sa mise en page compte, pour qu'on la voie."""
+    if not text.strip():
+        return [TEXTS[lang]["empty_text"]]
     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)]
+    # Des lignes vides en tête comptent (elles décalent les positions) : le bloc de code les garde.
+    leading = shown.lstrip(" \t").startswith("\n")
+    if leading or MARKUP.search(text) or LAYOUT.search(text.strip("\n")):
+        parts = code_block(shown, "text", lang, max_line=None, keep_leading=leading)
+    else:
+        parts = [quote(shown)]
     if len(text) > MAX_TEXT:
         parts.append(TEXTS[lang]["truncated_text"].format(n=len(text)))
     return parts
@@ -406,14 +501,24 @@ def number(value: float, lang: str) -> str:
     return f"{value:.2f}".replace(".", TEXTS[lang]["decimal"])
 
 
-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."""
+def code_block(text: str, kind: str, lang: str, max_line: int | None = MAX_LINE, keep_leading: bool = False) -> list[str]:
+    """Un extrait de contenu dans un bloc de code ; 'kind' est un type MIME ou un nom de fichier.
+
+    'keep_leading' : garder les lignes vides du début, que le texte montré doit faire voir.
+    """
     fence_lang = next((name for name in ("json", "xml", "html", "csv", "markdown") if name in kind.lower()), "text")
-    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]]
+    if fence_lang == "json":
+        # Un JSON sur une ligne serait coupé à MAX_LINE : réindenté, il se lit, et tient en MAX_JSON_LINES.
+        try:
+            text = json.dumps(json.loads(text), ensure_ascii=False, indent=2)
+        except ValueError:
+            pass
+    max_lines = {"json": MAX_JSON_LINES, "xml": MAX_MARKUP_LINES, "html": MAX_MARKUP_LINES}.get(fence_lang, MAX_LINES)
+    lines = (text.rstrip("\n") if keep_leading else 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:
+    if len(lines) > max_lines:
         parts.append(TEXTS[lang]["truncated_lines"].format(n=len(lines)))
     return parts
 
@@ -433,6 +538,9 @@ def file_lead(source: dict, lang: str) -> list[str]:
     return [lead, *content_view(source, media_type or source.get("filename", ""), lang)]
 
 
+MAX_MEMBERS = 3
+
+
 def column_name(index: int) -> str:
     """A, B, …, Z, AA, AB… : le nom d'une colonne Excel."""
     name = ""
@@ -444,22 +552,32 @@ def column_name(index: int) -> str:
 
 
 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."""
+    """Le contenu d'un fichier ou d'une réponse : son texte, les feuilles d'un classeur, les fichiers d'une archive, ou sa taille."""
     texts = TEXTS[lang]
     if "text" in content:
         return code_block(content["text"], kind, lang)
-    if "sheet" in content:
+    if "sheets" 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)]
+        parts = []
+        for sheet in content["sheets"]:
+            lead = texts["sheet"].format(name=code(sheet.get("name", "")))
+            rows = [[cell(value) or " " for value in row] for row in sheet.get("rows", [])]
+            if not rows:
+                parts += [lead + texts["colon"], texts["empty"]]
+                continue
+            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.
+            parts += [lead + texts["colon"], table([column_name(i) for i in range(width)], rows, lang)]
+        return parts
+    if "archive" in content:
+        members = content["archive"]
+        rows = [[f"`{code(m['name'])}`", texts["bytes"].format(n=m["size"])] for m in members]
+        parts = [texts["archive"].format(n=len(members)), table([texts["name"], texts["size"]], rows, lang)]
+        # Le contenu des premiers fichiers lisibles : c'est lui que le plugin lit.
+        for member in [m for m in members if "text" in m][:MAX_MEMBERS]:
+            parts += [texts["archive_member"].format(name=code(member["name"])), *code_block(member["text"], member["name"], lang)]
+        return parts
     if "size" in content:
         return [texts["binary"].format(n=content["size"])]
     return []
@@ -470,36 +588,72 @@ def annotations_table(annotations: list[dict], lang: str, doc_text: str = "") ->
     # Une annotation sans 'text' (le champ est facultatif) se lit dans le document, par ses offsets.
     annotations = [a if a.get("text") else {**a, "text": doc_text[a["start"] : a["end"]]} for a in annotations]
     annotations = sorted(annotations, key=lambda a: (a["start"], a["end"]))
-    # Un même texte annoté plusieurs fois est numéroté, dans l'ordre du document.
-    counts: dict[str, int] = {}
+    # Un même texte trouvé à plusieurs endroits est numéroté, dans l'ordre du document ; deux
+    # annotations du même passage (deux labels sur « London ») portent le même numéro.
+    spans: dict[str, list[tuple[int, int]]] = {}
     for a in annotations:
-        counts[a.get("text", "")] = counts.get(a.get("text", ""), 0) + 1
+        positions = spans.setdefault(a.get("text", ""), [])
+        if (a["start"], a["end"]) not in positions:
+            positions.append((a["start"], a["end"]))
     with_terms = any(a.get("terms") for a in annotations)
+    with_properties = any(a.get("properties") for a in annotations)
+    # Le lexique d'un terme se montre quand il y en a plusieurs : c'est alors lui qui distingue.
+    lexicons = {t.get("lexicon") for a in annotations for t in a.get("terms") or [] if t.get("lexicon")}
     header = [texts["annotated"], texts["label"]] + ([texts["preferred"]] if with_terms else [])
+    with_score = any(isinstance(a.get("score"), (int, float)) for a in annotations)
+    header += [texts["score"]] if with_score else []
+    header += [texts["properties_col"]] if with_properties else []
     rows = []
-    seen: dict[str, int] = {}
     for a in annotations:
         text = a.get("text", "")
-        seen[text] = seen.get(text, 0) + 1
         shown = cell(text)
-        if counts[text] > 1:
-            shown += f" *({texts['occurrence'].format(n=seen[text])})*"
-        row = [shown, f"`{cell(a.get('labelName') or a.get('label') or '')}`"]
+        if len(spans[text]) > 1:
+            shown += f" *({texts['occurrence'].format(n=spans[text].index((a['start'], a['end'])) + 1)})*"
+        row = [shown, f"`{code(a.get('labelName') or a.get('label') or '')}`"]
         if with_terms:
-            # Trié : l'ordre des termes n'est pas toujours stable d'un passage à l'autre.
-            forms = sorted({t.get("preferredForm") or t.get("identifier", "") for t in a.get("terms", [])})
+            # Dans l'ordre du plugin (celui des candidats a un sens), sans doublon.
+            forms = []
+            for t in a.get("terms") or []:
+                form = t.get("preferredForm") or t.get("identifier", "")
+                if len(lexicons) > 1 and t.get("lexicon"):
+                    form += f" ({t['lexicon']})"
+                if form not in forms:
+                    forms.append(form)
             row.append(cell(" / ".join(forms)) or "—")
+        if with_score:
+            row.append(number(a["score"], lang) if isinstance(a.get("score"), (int, float)) else "—")
+        if with_properties:
+            row.append(properties_cell(a.get("properties") or {}, lang))
         rows.append(row)
     return table(header, rows, lang)
 
 
+def properties_cell(properties: dict, lang: str) -> str:
+    """Des propriétés dans une cellule : `clé` : valeur, triées par clé, chaque valeur sur une ligne."""
+    if not properties:
+        return "—"
+    shown = []
+    for key in sorted(properties):
+        value = properties[key]
+        value = value if isinstance(value, str) else json.dumps(value, ensure_ascii=False, sort_keys=True)
+        # Coupée avant d'être échappée : une entité (&lt;) ne doit pas être tranchée.
+        value = " ".join(value.split())
+        value = cell(value) if len(value) <= MAX_CELL else cell(value[:MAX_CELL]) + " …"
+        shown.append(f"`{code(key)}`{TEXTS[lang]['colon']} {value}")
+    return "<br>".join(shown)
+
+
 def categories_table(categories: list[dict], lang: str) -> str:
     texts = TEXTS[lang]
     with_score = any("score" in c for c in categories)
-    header = [texts["label"]] + ([texts["score"]] if with_score else [])
+    # Le libellé que montre Sherpa, quand il n'est pas le nom technique (un code IPTC, par exemple).
+    with_display = any(c.get("label") and c.get("labelName") and c["label"] != c["labelName"] for c in categories)
+    header = [texts["label"]] + ([texts["display_label"]] if with_display else []) + ([texts["score"]] if with_score else [])
     rows = []
     for c in categories:
-        row = [f"`{cell(c.get('labelName') or c.get('label') or '')}`"]
+        row = [f"`{code(c.get('labelName') or c.get('label') or '')}`"]
+        if with_display:
+            row.append(cell(c.get("label") or "") or "—")
         if with_score:
             row.append(number(c["score"], lang) if isinstance(c.get("score"), (int, float)) else "—")
         rows.append(row)
@@ -508,18 +662,36 @@ def categories_table(categories: list[dict], lang: str) -> str:
 
 def metadata_table(metadata: dict, lang: str) -> str:
     texts = TEXTS[lang]
-    rows = [[f"`{cell(key)}`", cell(value if isinstance(value, str) else json.dumps(value, ensure_ascii=False))] for key, value in metadata.items()]
+    rows = [[f"`{code(key)}`", cell(value if isinstance(value, str) else json.dumps(value, ensure_ascii=False))] for key, value in metadata.items()]
     return table([texts["key"], texts["value"]], rows, lang)
 
 
+def alt_texts_table(alt_texts: list[dict], lang: str) -> str:
+    texts = TEXTS[lang]
+    rows = []
+    for alt in alt_texts:
+        value = " ".join(alt.get("text", "").split())
+        value = cell(value) if len(value) <= 2 * MAX_CELL else cell(value[: 2 * MAX_CELL]) + " …"
+        rows.append([f"`{code(alt.get('name', ''))}`", value or texts["empty_text"]])
+    return table([texts["name"], texts["text"]], rows, lang)
+
+
 def input_view(doc: dict, lang: str) -> list[str]:
     """Un document en entrée : son texte, et ce qu'il porte déjà, que le plugin va lire."""
     texts = TEXTS[lang]
     parts = text_lead(doc, lang)
+    # Le découpage en entrée, sauf la phrase unique qui couvre tout le texte : elle n'apprend rien.
+    sentences = doc.get("sentences") or []
+    whole = len(sentences) == 1 and not sentences[0].get("metadata") and not sentences[0].get("categories")
+    whole = whole and doc.get("text", "")[: sentences[0]["start"]].strip() == "" and doc.get("text", "")[sentences[0]["end"] :].strip() == ""
+    if sentences and not whole:
+        parts += [texts["sentences_in"].format(n=len(sentences)), *sentences_list(doc, lang)]
     if doc.get("annotations"):
         parts += [texts["annotations_in"], annotations_table(doc["annotations"], lang, doc.get("text", ""))]
     if doc.get("categories"):
         parts += [texts["categories_in"], categories_table(doc["categories"], lang)]
+    if doc.get("altTexts"):
+        parts += [texts["alt_texts_in"], alt_texts_table(doc["altTexts"], lang)]
     return parts
 
 
@@ -528,9 +700,19 @@ MARKDOWN_LEAD = re.compile(r"^([-+#>])")
 MARKDOWN_NUMBER = re.compile(r"^(\d+)([.)])")
 
 
+# Un retour à la ligne dans une phrase : sur une ligne de liste, il serait un simple espace.
+# « ↵ » pour un retour à la ligne, « ↵↵ » pour une ligne vide ou plus.
+NEWLINES = re.compile(r"[ \t]*(?:\r?\n[ \t]*)+")
+
+
+def mark_newlines(text: str) -> str:
+    return NEWLINES.sub(lambda m: " ↵ " if m.group().count("\n") == 1 else " ↵↵ ", text.strip())
+
+
 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 = mark_newlines(text[sent["start"] : sent["end"]])
+    phrase = MARKDOWN_INLINE.sub(r"\\\1", cell(phrase))
     phrase = MARKDOWN_NUMBER.sub(r"\1\\\2", MARKDOWN_LEAD.sub(r"\\\1", phrase))
     if not phrase:
         return TEXTS[lang]["empty_sentence"]
@@ -544,7 +726,14 @@ def sentences_list(doc: dict, lang: str) -> list[str]:
     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))]
+    items = []
+    for n, s in enumerate(sentences[:MAX_ROWS], start=1):
+        item = f"{n}. {sentence_text(text, s, lang)}"
+        # Les métadonnées d'une phrase (sa section, sa page…) sont souvent tout ce qu'en fait le plugin.
+        if s.get("metadata"):
+            item += " — " + properties_cell(s["metadata"], lang).replace("<br>", TEXTS[lang]["list_sep"])
+        items.append(item)
+    parts = ["\n".join(items)]
     if len(sentences) > MAX_ROWS:
         parts.append(texts["truncated_rows"].format(n=len(sentences)))
     return parts
@@ -560,18 +749,21 @@ def sentence_categories(doc: dict, lang: str) -> list[str]:
             continue
         labels = []
         for c in sent["categories"]:
-            label = f"`{cell(c.get('labelName') or c.get('label') or '')}`"
+            label = f"`{code(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."""
+def document_lead(doc: dict, lang: str, numbered: bool = False) -> list[str]:
+    """Un document produit sans document en entrée (un convertisseur) : identifiant, titre, propriétés.
+
+    'numbered' : l'en-tête « Document n°N (`id`) » a déjà donné l'identifiant.
+    """
     texts = TEXTS[lang]
     lead = texts["produced_document"]
-    if doc.get("identifier"):
-        lead += f", {texts['identifier_named']} `{cell(doc['identifier'])}`"
+    if doc.get("identifier") and not numbered:
+        lead += f", {texts['identifier_named']} `{code(doc['identifier'])}`"
     parts = [lead + "."]
     if doc.get("title"):
         parts.append(f"{texts['title']}{texts['colon']} {cell(doc['title'])}")
@@ -580,10 +772,10 @@ def document_lead(doc: dict, lang: str) -> list[str]:
     return parts
 
 
-def output_view(doc: dict, before: dict | None, lang: str) -> list[str]:
+def output_view(doc: dict, before: dict | None, lang: str, numbered: bool = False) -> list[str]:
     """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 []
+    parts = document_lead(doc, lang, numbered) if before is None else []
     before = before or {}
     if doc.get("text", "") != before.get("text", ""):
         parts += [texts["produced_text"], *excerpt(doc.get("text", ""), lang)]
@@ -599,16 +791,17 @@ def output_view(doc: dict, before: dict | None, lang: str) -> list[str]:
             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),
+        "annotations": ("annotations", lambda: annotations_table(doc["annotations"], lang, doc.get("text", ""))),
+        "categories": ("categories", lambda: categories_table(doc["categories"], lang)),
+        "altTexts": ("alt_texts", lambda: alt_texts_table(doc["altTexts"], lang)),
     }
-    for key, table_of in tables.items():
+    for key, (name, 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()]
+            parts += [texts[f"{name}_out"], table_of()]
         else:
-            parts.append(texts[f"{key}_removed"].format(n=len(before[key])))
+            parts.append(texts[f"{name}_removed"].format(n=len(before[key])))
     old_metadata = before.get("metadata") or {}
     metadata = doc.get("metadata") or {}
     changed = {key: value for key, value in metadata.items() if old_metadata.get(key) != value}
@@ -616,7 +809,7 @@ def output_view(doc: dict, before: dict | None, lang: str) -> list[str]:
         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) + ".")
+        parts.append(f"{texts['metadata_removed']} " + ", ".join(f"`{code(key)}`" for key in removed) + ".")
     return parts or [texts["unchanged"]]
 
 
@@ -631,7 +824,7 @@ def documents_view(outputs: list[dict], inputs: list[dict] | None, lang: str) ->
     parts = []
     for n, (doc, before) in enumerate(zip(outputs, paired, strict=True), start=1):
         identifier = f" (`{doc['identifier']}`)" if doc.get("identifier") else ""
-        parts += [f"**{texts['document'].format(n=n)}**{identifier}", *output_view(doc, before, lang)]
+        parts += [f"**{texts['document'].format(n=n)}**{identifier}", *output_view(doc, before, lang, numbered=True)]
     return parts
 
 
@@ -700,13 +893,18 @@ def importer_example(example: dict, schema: dict, lang: str) -> str:
         parts.append(texts["no_concepts"])
         return "\n\n".join(parts) + "\n"
     with_alt = any((c.get("properties") or {}).get("altForms") for c in concepts)
+    others = [{k: v for k, v in (c.get("properties") or {}).items() if k != "altForms"} for c in concepts]
+    with_others = any(others)
     header = [texts["identifier"], texts["preferred"]] + ([texts["alt_forms"]] if with_alt else [])
+    header += [texts["properties_col"]] if with_others else []
     rows = []
-    for c in concepts:
-        row = [f"`{cell(c.get('identifier', ''))}`", cell(c.get("preferredForm") or "") or "—"]
+    for c, other in zip(concepts, others, strict=True):
+        row = [f"`{code(c.get('identifier', ''))}`", cell(c.get("preferredForm") or "") or "—"]
         if with_alt:
             alt = (c.get("properties") or {}).get("altForms") or []
             row.append(cell(", ".join(as_list(alt))) or "—")
+        if with_others:
+            row.append(properties_cell(other, lang))
         rows.append(row)
     parts += [texts["concepts_count"].format(n=len(concepts)), table(header, rows, lang)]
     return "\n\n".join(parts) + "\n"

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

@@ -114,12 +114,12 @@ 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, 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 |
+| annotateur | les documents | les documents | le texte, puis les annotations : label, termes (dans l'ordre du plugin, avec leur lexique s'il y en a plusieurs), score et propriétés |
+| processeur | les documents | les documents | le texte et ce qu'il porte déjà (phrases, s'il y en a plus d'une), puis **ce qui a changé** : texte, phrases, annotations, catégories (du document ou par phrase, avec leur score et leur libellé), métadonnées, textes alternatifs — **et ce qui a été retiré** |
+| segmenteur | les documents | les documents | le texte, puis les phrases numérotées, avec leurs métadonnées |
 | 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 |
+| formateur | le document | la `Response` | le document (annotations, catégories, textes alternatifs), puis le type, le nom de fichier et un extrait de la réponse — JSON réindenté, toutes les feuilles d'un classeur Excel, la taille pour un autre contenu binaire |
+| importeur | le chemin du fichier | **la liste** des concepts | le fichier (extrait, feuilles d'un classeur Excel, fichiers d'une archive zip), puis les termes : identifiant, forme préférée, formes alternatives, autres propriétés |
 
 Trois pièges, que la fixture signale ou ne peut pas rattraper :
 
@@ -137,12 +137,28 @@ Les textes, fichiers et réponses longs sont tronqués au rendu (1 000 caractèr
 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
+ligne, des espaces alignés, des lignes vides en tête) ou qui contient des balises
+(`<personne>`, `&amp;`) est montré dans un bloc de code plutôt qu'en citation, qui
+l'écraserait ou que Sherpa interpréterait comme du HTML ; dans un tableau, `<` est
+échappé. Dans une liste de phrases, « ↵ » marque un retour à la ligne intérieur à la
+phrase, « ↵↵ » une ligne vide. Un même texte trouvé à plusieurs endroits est numéroté
+(« Paris *(n°2)* ») ; deux annotations du même passage ne le sont pas. Un fichier XML
+ou HTML est montré sur 60 lignes, un autre texte sur 20. 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 ses feuilles, 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.
+cas d'un plugin qui lit ou écrit de l'Excel. Une archive zip est montrée par la liste
+de ses fichiers et le texte des premiers ; un document Office (docx, pptx), qui est
+aussi une archive, n'est montré que par sa taille.
+
+Un paramètre interne (la langue du projet, fixée par Sherpa) n'apparaît pas dans la
+ligne des paramètres d'un exemple. Dans le tableau des paramètres, une valeur par défaut
+est écrite sur une ligne (une chaîne JSON en JSON compact) et tronquée au-delà de
+100 caractères : la prose en dit le reste si besoin.
+
+**Jenkins vérifie les pages avec la tête de python-archetype** (le submodule est
+récupéré avec `--remote`), pas avec le commit pointé : après un changement du rendu,
+régénérer les pages des dépôts qu'il touche, sinon leur `py:help-check` passe au rouge.
 
 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