pyprocessors-coreference 1.6.1__tar.gz

pyprocessors_coreference-1.6.1/.claude/settings.json

@@ -0,0 +1,13 @@
+{
+  "extraKnownMarketplaces": {
+    "kairntech-python": {
+      "source": {
+        "source": "git",
+        "url": "git@bitbucket.org:kairntech/python-archetype.git"
+      }
+    }
+  },
+  "enabledPlugins": {
+    "python-archetype@kairntech-python": true
+  }
+}

pyprocessors_coreference-1.6.1/.gitignore

@@ -0,0 +1,31 @@
+/.idea/
+/.vscode/
+/dist/
+dist
+.git
+.cache
+**/.pytest_cache
+models
+log
+**/__pycache__/
+*.pyc
+**/test-reports
+**/.passwd-pypi
+**/.env
+**/results.xml
+
+# Specific
+.idea/
+.groovylintrc.json
+.emailNotif
+uv.lock
+
+# SBOMs
+**/sbom*.json
+**/trivy*.html
+**/audit*.json
+# Le rapport lisible que py:vuln-report ecrit (AUDIT_REPORT). Ajoute apres les
+# regles ci-dessus, il n'etait couvert par aucune : les huit depots ont donc un
+# audit-report.md non suivi qui traine apres chaque 'task'. Meme correctif a y
+# porter -- c'est du ressort de check-plugin-drift.
+**/audit*.md

pyprocessors_coreference-1.6.1/.gitmodules

@@ -0,0 +1,4 @@
+[submodule "submodules/python-archetype"]
+	path = submodules/python-archetype
+	url = git@bitbucket.org:kairntech/python-archetype.git
+	branch = master

pyprocessors_coreference-1.6.1/.python-version

@@ -0,0 +1 @@
+3.12

pyprocessors_coreference-1.6.1/PKG-INFO

@@ -0,0 +1,131 @@
+Metadata-Version: 2.5
+Name: pyprocessors-coreference
+Version: 1.6.1
+Summary: Processor grouping the mentions of the same entity
+Project-URL: Homepage, https://bitbucket.org/kairntech/pyprocessors_coreference
+Author-email: Olivier Terrier <olivier.terrier@kairntech.com>
+License: MIT
+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: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Topic :: Software Development :: Libraries :: Application Frameworks
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.12
+Requires-Dist: pymultirole-plugins<1.7.0,>=1.6.0
+Provides-Extra: sbom
+Requires-Dist: cyclonedx-bom; extra == 'sbom'
+Requires-Dist: pip-audit; extra == 'sbom'
+Provides-Extra: test
+Requires-Dist: pip; extra == 'test'
+Requires-Dist: pytest; extra == 'test'
+Requires-Dist: ruff; extra == 'test'
+Description-Content-Type: text/markdown
+
+# pyprocessors-coreference
+
+Processor grouping the mentions of the same entity.
+
+Ce dépôt enregistre un processeur dans le groupe d'entry-points `pyprocessors.plugins` :
+
+| Plugin | Classe |
+|--------|--------|
+| `coreference` | `pyprocessors_coreference.coreference:CoreferenceProcessor` |
+
+Il regroupe les mentions d'une même entité **avant** le linking, pour qu'elles soient
+liées une seule fois, à partir de leur forme la plus longue. C'est l'étape de
+regroupement des mentions de l'ADR-0001 de `pyannotators_entityfishing`
+([`docs/adr/`](docs/adr/0001-linking-candidats-entityfishing-decision-jev.md)), palier 1 :
+les noms seulement.
+
+## Ce qu'il fait
+
+Pour chaque document, entre mentions de même label :
+
+- **même surface normalisée → même groupe.** La normalisation ignore la casse, les
+  espaces, le style des apostrophes, et les civilités en tête d'un nom de personne
+  (« M. », « Mme », « Dr »…) ;
+- **tous les labels de personne forment une seule famille** : le `person` du NER et
+  l'`afpperson` des lexiques AFP annotent le même span, et vont dans le même groupe ;
+- **un nom partiel de personne rejoint le nom complet dont il est la fin**, que le
+  nom complet soit avant ou après lui dans le document : « Macron » et « M. Macron »
+  rejoignent « Emmanuel Macron » ;
+- **un prénom seul ne rejoint jamais un nom complet** : « Emmanuel » reste à part ;
+- **un nom partiel ambigu n'est pas fusionné** : avec « Emmanuel Macron » et
+  « Brigitte Macron » dans le texte, « Macron » garde son propre groupe, et liste les
+  groupes possibles pour que l'étape de linking tranche ;
+- **la règle du nom partiel ne vaut que pour les personnes** : « Airbus » ne rejoint pas
+  « Airbus Defence and Space ».
+
+Sur chaque annotation d'un label regroupé, il écrit dans `properties` :
+
+| Propriété | Valeur |
+|-----------|--------|
+| `entity_group` | l'identifiant du groupe dans le document : `g1`, `g2`… dans l'ordre de première apparition |
+| `canonical_form` | la forme la plus longue du groupe, sans civilité : c'est elle qu'on cherche dans la base de connaissances |
+| `mention_type` | `name` (les périphrases et les pronoms, `nominal` et `pronoun`, viendront avec les paliers 2 et 3) |
+| `entity_group_candidates` | seulement sur un nom partiel ambigu : les groupes auxquels il peut appartenir |
+
+Les autres propriétés de l'annotation sont gardées, et traiter deux fois un document
+donne le même résultat. La portée est le document entier, ce qui convient à une
+dépêche ; les documents longs sont une question ouverte (SHERPA-3048).
+
+## Requirements
+
+- Python 3.12+
+- `pymultirole_plugins` (>=1.6.0,<1.7.0)
+
+## Installation
+
+```
+pip install pyprocessors-coreference
+```
+
+## Usage
+
+```python
+from pymultirole_plugins.v1.schema import Annotation, Document
+
+from pyprocessors_coreference.coreference import CoreferenceParameters, CoreferenceProcessor
+
+text = "Emmanuel Macron est arrivé. M. Macron a parlé."
+document = Document(
+    text=text,
+    annotations=[
+        Annotation(start=0, end=15, labelName="person", text="Emmanuel Macron"),
+        Annotation(start=28, end=37, labelName="person", text="M. Macron"),
+    ],
+)
+[document] = CoreferenceProcessor().process([document], CoreferenceParameters())
+# Both annotations: entity_group "g1", canonical_form "Emmanuel Macron".
+```
+
+### Parameters
+
+| Paramètre | Défaut | Description |
+|-----------|--------|-------------|
+| `labels` | vide | Labels des mentions à regrouper. Vide : tous les labels. |
+| `person_labels` | vide | Labels de personne : ils forment une seule famille, et la règle du nom partiel s'y applique. Vide : tout label dont le nom contient « person » (`person`, `afpperson`…). |
+| `honorifics` | `M.`, `Mme`, `Dr`, `Mr`… | Civilités ignorées en tête d'un nom de personne. Paramètre avancé. |
+
+## Development
+
+Le build est piloté par [Task](https://taskfile.dev) et [uv](https://docs.astral.sh/uv/),
+les stages venant du submodule `python-archetype` :
+
+```
+git submodule update --init
+task stages          # les stages du pipeline, dans l'ordre
+task                 # tout sauf le dernier stage — donc tout sauf la publication
+task -- --skip-tests # idem, sans le stage de test
+task up-to -- py:lint
+task jenkins         # tout, exactement ce que joue Jenkins
+task --list
+```
+
+`uv.lock` n'est pas versionné ici, donc `py:sync` résout les dépendances à neuf.

pyprocessors_coreference-1.6.1/README.md

@@ -0,0 +1,102 @@
+# pyprocessors-coreference
+
+Processor grouping the mentions of the same entity.
+
+Ce dépôt enregistre un processeur dans le groupe d'entry-points `pyprocessors.plugins` :
+
+| Plugin | Classe |
+|--------|--------|
+| `coreference` | `pyprocessors_coreference.coreference:CoreferenceProcessor` |
+
+Il regroupe les mentions d'une même entité **avant** le linking, pour qu'elles soient
+liées une seule fois, à partir de leur forme la plus longue. C'est l'étape de
+regroupement des mentions de l'ADR-0001 de `pyannotators_entityfishing`
+([`docs/adr/`](docs/adr/0001-linking-candidats-entityfishing-decision-jev.md)), palier 1 :
+les noms seulement.
+
+## Ce qu'il fait
+
+Pour chaque document, entre mentions de même label :
+
+- **même surface normalisée → même groupe.** La normalisation ignore la casse, les
+  espaces, le style des apostrophes, et les civilités en tête d'un nom de personne
+  (« M. », « Mme », « Dr »…) ;
+- **tous les labels de personne forment une seule famille** : le `person` du NER et
+  l'`afpperson` des lexiques AFP annotent le même span, et vont dans le même groupe ;
+- **un nom partiel de personne rejoint le nom complet dont il est la fin**, que le
+  nom complet soit avant ou après lui dans le document : « Macron » et « M. Macron »
+  rejoignent « Emmanuel Macron » ;
+- **un prénom seul ne rejoint jamais un nom complet** : « Emmanuel » reste à part ;
+- **un nom partiel ambigu n'est pas fusionné** : avec « Emmanuel Macron » et
+  « Brigitte Macron » dans le texte, « Macron » garde son propre groupe, et liste les
+  groupes possibles pour que l'étape de linking tranche ;
+- **la règle du nom partiel ne vaut que pour les personnes** : « Airbus » ne rejoint pas
+  « Airbus Defence and Space ».
+
+Sur chaque annotation d'un label regroupé, il écrit dans `properties` :
+
+| Propriété | Valeur |
+|-----------|--------|
+| `entity_group` | l'identifiant du groupe dans le document : `g1`, `g2`… dans l'ordre de première apparition |
+| `canonical_form` | la forme la plus longue du groupe, sans civilité : c'est elle qu'on cherche dans la base de connaissances |
+| `mention_type` | `name` (les périphrases et les pronoms, `nominal` et `pronoun`, viendront avec les paliers 2 et 3) |
+| `entity_group_candidates` | seulement sur un nom partiel ambigu : les groupes auxquels il peut appartenir |
+
+Les autres propriétés de l'annotation sont gardées, et traiter deux fois un document
+donne le même résultat. La portée est le document entier, ce qui convient à une
+dépêche ; les documents longs sont une question ouverte (SHERPA-3048).
+
+## Requirements
+
+- Python 3.12+
+- `pymultirole_plugins` (>=1.6.0,<1.7.0)
+
+## Installation
+
+```
+pip install pyprocessors-coreference
+```
+
+## Usage
+
+```python
+from pymultirole_plugins.v1.schema import Annotation, Document
+
+from pyprocessors_coreference.coreference import CoreferenceParameters, CoreferenceProcessor
+
+text = "Emmanuel Macron est arrivé. M. Macron a parlé."
+document = Document(
+    text=text,
+    annotations=[
+        Annotation(start=0, end=15, labelName="person", text="Emmanuel Macron"),
+        Annotation(start=28, end=37, labelName="person", text="M. Macron"),
+    ],
+)
+[document] = CoreferenceProcessor().process([document], CoreferenceParameters())
+# Both annotations: entity_group "g1", canonical_form "Emmanuel Macron".
+```
+
+### Parameters
+
+| Paramètre | Défaut | Description |
+|-----------|--------|-------------|
+| `labels` | vide | Labels des mentions à regrouper. Vide : tous les labels. |
+| `person_labels` | vide | Labels de personne : ils forment une seule famille, et la règle du nom partiel s'y applique. Vide : tout label dont le nom contient « person » (`person`, `afpperson`…). |
+| `honorifics` | `M.`, `Mme`, `Dr`, `Mr`… | Civilités ignorées en tête d'un nom de personne. Paramètre avancé. |
+
+## Development
+
+Le build est piloté par [Task](https://taskfile.dev) et [uv](https://docs.astral.sh/uv/),
+les stages venant du submodule `python-archetype` :
+
+```
+git submodule update --init
+task stages          # les stages du pipeline, dans l'ordre
+task                 # tout sauf le dernier stage — donc tout sauf la publication
+task -- --skip-tests # idem, sans le stage de test
+task up-to -- py:lint
+task jenkins         # tout, exactement ce que joue Jenkins
+task --list
+```
+
+`uv.lock` n'est pas versionné ici, donc `py:sync` résout les dépendances à neuf.

pyprocessors_coreference-1.6.1/docs/adr/0001-linking-candidats-entityfishing-decision-jev.md

@@ -0,0 +1,78 @@
+---
+status: proposed
+date: 2026-09-24
+---
+
+# ADR (relais) — Le linking d'entités sépare les candidats (entity-fishing) de la décision (Jev)
+
+- **Décision** — C'est une ADR relais : la décision est prise, et argumentée, dans l'[ADR-0001 de `pyannotators_entityfishing`](https://bitbucket.org/kairntech/pyannotators_entityfishing/src/master/docs/adr/0001-linking-candidats-entityfishing-decision-jev.md). On ne la recopie pas ici, pour que les deux textes ne divergent pas.
+- **Pourquoi ce dépôt existe** — Il porte l'étape de **regroupement des mentions** du pipeline de linking. Elle se place entre le NER et la génération des candidats : les mentions d'une même entité sont regroupées **avant** le linking, pour être liées une seule fois, à partir de leur forme la plus longue.
+- **Statut** — `proposed`. C'est le statut de l'ADR source qui fait foi.
+
+---
+
+- **Source** : [ADR-0001, `pyannotators_entityfishing`](https://bitbucket.org/kairntech/pyannotators_entityfishing/src/master/docs/adr/0001-linking-candidats-entityfishing-decision-jev.md), en particulier §3 (le pipeline et le regroupement), §4 (ce qui change par dépôt) et §5 (le contrat entre les étapes).
+- **Suivi** (essai) : Epic [SHERPA-3035](https://kairntech.atlassian.net/browse/SHERPA-3035). Tickets de ce dépôt :
+  - [SHERPA-3038](https://kairntech.atlassian.net/browse/SHERPA-3038) : le processeur, palier 1 (les noms) ;
+  - [SHERPA-3046](https://kairntech.atlassian.net/browse/SHERPA-3046) : le nom et la graine du dépôt, tranchés par sa création même ;
+  - [SHERPA-3047](https://kairntech.atlassian.net/browse/SHERPA-3047) : les paliers 2 et 3 (périphrases, pronoms) ;
+  - [SHERPA-3048](https://kairntech.atlassian.net/browse/SHERPA-3048) : la portée du regroupement pour les documents longs.
+
+## Le nom et l'enveloppe
+
+- **Le nom : `pyprocessors_coreference`, plutôt que `pyprocessors_name_propagator`.** Un « propagateur de noms » décrit ce que fait l'AFP aujourd'hui : recopier des liens **après** le linking. Ici, on regroupe **avant**, et les paliers 2 et 3 relèvent de la coréférence.
+- **L'enveloppe vient de `pyprocessors_seed`** (`task init`), la graine des processeurs créée pour l'occasion. La mesure de dérive se fait par `git fetch seed && git diff seed/master -- . ':!src' ':!tests'`.
+
+## Ce que ce dépôt doit faire
+
+**Palier 1 (SHERPA-3038).** Le processeur ajoute à chaque annotation du NER :
+- `properties.entity_group` : l'identifiant du groupe dans le document ;
+- `properties.canonical_form` : la forme la plus longue du groupe, qui sert au term lookup.
+
+Les règles s'appliquent toujours entre mentions de même label NER :
+- **même surface normalisée → même groupe** ;
+- **PERSON seulement : un nom partiel rejoint un nom complet vu dans le document** (« Macron » rejoint « Emmanuel Macron ») ;
+- **un nom partiel ambigu n'est pas fusionné de force** : avec Emmanuel et Brigitte Macron dans le même texte, « Macron » garde ses deux groupes possibles.
+
+**Le code part de `person_varnames`**, aujourd'hui en double dans `pyprocessors_afp_entities` et `pyprocessors_escrim_reconciliation`, qui a trois défauts :
+- la portée ne va que vers l'avant ;
+- un prénom seul est enregistré comme variante ;
+- les civilités (« M. », « Mme ») ne sont pas retirées.
+
+Il était prévu de l'extraire. **Le palier 1 a finalement réécrit la règle**, parce que deux des trois défauts sont dans sa logique même : les variantes par préfixe, qui produisent le prénom seul, et le parcours vers l'avant seulement. Seul le rattachement d'une fin de nom au nom complet est conservé.
+
+## Ce que le palier 1 fait, et ses limites connues
+
+**Une décision prise en l'écrivant : les labels de personne forment une seule famille.** Dans le pipeline AFP, le NER (`person`) et le lexique AFP (`afpperson`) annotent le **même span**. Grouper strictement par label mettait chaque personne dans deux groupes. Le paramètre `person_labels` désigne ces labels ; s'il est vide, ce sont ceux dont le nom contient « person ». Les autres labels restent groupés par label exact : `location`/`afplocation` et `organization`/`afporganization` ont sans doute le même doublon, et la question reste ouverte.
+
+**Ce qu'est une « fin de nom ».** Le nom partiel rejoint le nom complet si ses mots sont **exactement les derniers mots** du nom complet. La comparaison se fait mot à mot, après normalisation (casse, espaces, apostrophes, civilités), jamais sur une partie de mot :
+
+| Nom partiel | Nom complet | Résultat |
+|---|---|---|
+| Lucas | Franck DeLucas | reste à part : `delucas` est un seul mot |
+| Luc | Jean-Luc Mélenchon | reste à part : « Jean-Luc » est un seul mot |
+| Smith | Emile Smith Rowe | reste à part : ce n'est pas la fin du nom |
+| Mélenchon, Villepin | Jean-Luc Mélenchon, Dominique de Villepin | rejoint |
+| de Gaulle, Le Pen, Smith Rowe | Charles de Gaulle, Marine Le Pen, Emile Smith Rowe | rejoint |
+
+**Limite connue, acceptée : un nom de famille à particule ou composé peut être amputé.** Ces rattachements se font, alors qu'ils ne correspondent pas au nom de famille entier :
+
+| Nom partiel | Nom complet |
+|---|---|
+| Gaulle | Charles de Gaulle |
+| Pen | Marine Le Pen |
+| Lucas | Franck De Lucas |
+| Rowe | Emile Smith Rowe |
+
+**On n'ajoute pas de règle sur les particules (décision du 2026-09-24).** Une telle règle aurait interdit à une fin de nom de commencer juste après une particule (de, le, van, von, da, del…). Elle n'est pas retenue, pour trois raisons :
+- **un NER isole rarement** « Gaulle » ou « Pen » ;
+- **les noms composés sans particule** (« Smith Rowe ») resteraient de toute façon hors de portée sans dictionnaire ;
+- **l'erreur ne pèse qu'en cas d'homonyme.** Elle ne compte que si un autre porteur du nom amputé figure dans le même document, par exemple un autre Lucas à côté de « Franck De Lucas ». Or un nom partiel qui correspond à plusieurs noms complets n'est de toute façon pas fusionné.
+
+C'est à revoir si l'évaluation sur le corpus annoté ([SHERPA-3037](https://kairntech.atlassian.net/browse/SHERPA-3037)) montre de tels faux rattachements.
+
+## Ce qu'il ne faut pas faire en attendant
+
+- **Ne pas publier le squelette.** Tant que le palier 1 n'est pas écrit, le code est celui de la graine : il ajoute une catégorie à chaque document. Le premier build de `master` publierait ce squelette sur l'index sous le nom `pyprocessors-coreference`, et l'index est immuable. On travaille donc sur une branche de feature, que `publishBranches: '^master$'` empêche de publier, et `master` ne reçoit que le palier 1 terminé.
+- **Ne pas commencer les paliers 2 et 3** avant l'évaluation de SHERPA-3047.
+- **Ne pas câbler le processeur dans un paquet de flavor de `pymultirole_server`** avant qu'il ait été validé dans le pipeline de bout en bout ([SHERPA-3041](https://kairntech.atlassian.net/browse/SHERPA-3041)).

pyprocessors_coreference-1.6.1/pyproject.toml

@@ -0,0 +1,74 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "pyprocessors-coreference"
+dynamic = ["version"]
+description = "Processor grouping the mentions of the same entity"
+readme = "README.md"
+requires-python = ">=3.12"
+license = {text = "MIT"}
+authors = [
+    {name = "Olivier Terrier", email = "olivier.terrier@kairntech.com"},
+]
+classifiers = [
+    "Intended Audience :: Information Technology",
+    "Intended Audience :: Developers",
+    "Intended Audience :: System Administrators",
+    "Operating System :: OS Independent",
+    "Topic :: Software Development :: Libraries :: Application Frameworks",
+    "Topic :: Software Development :: Libraries :: Python Modules",
+    "Topic :: Software Development :: Libraries",
+    "Topic :: Software Development",
+    "License :: OSI Approved :: MIT License",
+    "Development Status :: 4 - Beta",
+    "Programming Language :: Python :: 3.12",
+]
+dependencies = [
+    "pymultirole-plugins>=1.6.0,<1.7.0",
+]
+
+[project.urls]
+Homepage = "https://bitbucket.org/kairntech/pyprocessors_coreference"
+
+[project.entry-points."pyprocessors.plugins"]
+coreference = "pyprocessors_coreference.coreference:CoreferenceProcessor"
+
+[project.optional-dependencies]
+test = [
+    "pytest",
+    "ruff",
+    "pip",
+]
+sbom = ["cyclonedx-bom", "pip-audit"]
+
+[tool.hatch.version]
+path = "src/pyprocessors_coreference/__init__.py"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/pyprocessors_coreference"]
+
+[tool.hatch.build]
+exclude = [
+  "/tests",
+  "Jenkinsfile",
+  "Taskfile.yml",
+  "CLAUDE.md",
+  ".gitignore"
+]
+
+[tool.pytest.ini_options]
+addopts = "--durations=5"
+norecursedirs = ["docs"]
+
+[tool.ruff]
+line-length = 256
+target-version = "py312"
+
+[tool.ruff.lint]
+select = ["E", "W", "F", "I", "B", "C4", "UP", "ARG", "SIM"]
+
+[tool.ruff.format]
+quote-style = "double"
+indent-style = "space"

pyprocessors_coreference-1.6.1/src/pyprocessors_coreference/__init__.py

@@ -0,0 +1,3 @@
+"""Processor grouping the mentions of the same entity"""
+
+__version__ = "1.6.1"

pyprocessors_coreference-1.6.1/src/pyprocessors_coreference/coreference.py

@@ -0,0 +1,174 @@
+import re
+import unicodedata
+from collections import defaultdict
+from typing import cast
+
+from pydantic import BaseModel, Field
+from pymultirole_plugins.v1.processor import ProcessorBase, ProcessorParameters
+from pymultirole_plugins.v1.schema import Annotation, Document
+
+# Honorifics in front of a person name, stripped before comparing names: in AFP
+# dispatches "M. Macron" follows "Emmanuel Macron". Compared case-insensitively.
+DEFAULT_HONORIFICS = ["M.", "MM.", "Mme", "Mmes", "Mlle", "Mlles", "Me", "Dr", "Dr.", "Pr", "Pr.", "Mr", "Mr.", "Mrs", "Mrs.", "Ms", "Ms.", "Miss", "Sir", "Dame", "Lord", "Lady"]
+
+# Properties written on every grouped annotation (ADR-0001, §5).
+ENTITY_GROUP = "entity_group"
+CANONICAL_FORM = "canonical_form"
+MENTION_TYPE = "mention_type"
+# Only on an ambiguous partial name: the groups it may belong to.
+ENTITY_GROUP_CANDIDATES = "entity_group_candidates"
+
+# The family of every person label: the NER's "person" and the AFP lexicon's
+# "afpperson" annotate the same span, and must land in the same group.
+PERSON_FAMILY = "\x00person"
+
+APOSTROPHES = str.maketrans({"’": "'", "‘": "'", "ʼ": "'"})
+
+
+class CoreferenceParameters(ProcessorParameters):
+    """Parameters of the coreference processor"""
+
+    labels: list[str] | None = Field(
+        None,
+        description="""Labels of the mentions to group. If empty, the mentions of every label are grouped.<br/>
+        Mentions are only grouped with mentions of the same label, except person labels, which all form one family.""",
+        json_schema_extra={"extra": "label"},
+    )
+    person_labels: list[str] | None = Field(
+        None,
+        description="""Labels of person names. They form one family (person and afpperson mentions are grouped together),
+        and a partial name ("Macron") joins the full name it ends ("Emmanuel Macron").<br/>
+        If empty, every label whose name contains "person" (person, afpperson...).""",
+        json_schema_extra={"extra": "label"},
+    )
+    honorifics: list[str] = Field(
+        DEFAULT_HONORIFICS,
+        description="Honorifics ignored in front of a person name when comparing names (M., Mme, Dr...)",
+        json_schema_extra={"extra": "advanced"},
+    )
+
+
+class CoreferenceProcessor(ProcessorBase):
+    """Group the mentions of the same entity, before entity linking.
+
+    Tier 1 of the mention grouping of ADR-0001 (pyannotators_entityfishing): names
+    only. Every annotation of a grouped label gets an `entity_group` (the same id for
+    every mention of the entity in the document) and a `canonical_form` (the longest
+    form of the group, which the candidate generation looks up):
+
+    - same normalized surface and same label → same group; all person labels count
+      as one (the NER's "person" and the AFP lexicon's "afpperson" annotate the same
+      span);
+    - person labels only: a partial name joins the full name it ends, wherever the
+      full name is in the document ("Macron" joins "Emmanuel Macron");
+    - a first name alone never joins ("Emmanuel" stays on its own);
+    - an ambiguous partial name ("Macron" with both Emmanuel and Brigitte Macron)
+      keeps a group of its own, and lists the possible groups in
+      `entity_group_candidates` for the linking step to decide.
+    """
+
+    def process(self, documents: list[Document], parameters: ProcessorParameters) -> list[Document]:
+        params = cast(CoreferenceParameters, parameters)
+        honorifics = {h.casefold() for h in params.honorifics}
+        for document in documents:
+            group_document(document, params, honorifics)
+        return documents
+
+    @classmethod
+    def get_model(cls) -> type[BaseModel]:
+        return CoreferenceParameters
+
+
+def group_document(document: Document, params: CoreferenceParameters, honorifics: set[str]) -> None:
+    text = document.text or ""
+    mentions = [a for a in (document.annotations or []) if a.labelName and (not params.labels or a.labelName in params.labels)]
+    if not mentions:
+        return
+
+    # 1. Same label, same normalized surface: one surface group.
+    surfaces: dict[tuple[str, tuple[str, ...]], list[Annotation]] = defaultdict(list)
+    for a in sorted(mentions, key=lambda a: (a.start, a.end)):
+        person = is_person_label(a.labelName, params)
+        tokens = name_tokens(surface_of(a, text), honorifics if person else set())
+        if tokens:
+            surfaces[(PERSON_FAMILY if person else a.labelName, tokens)].append(a)
+
+    # 2. Person labels: a surface that is a proper suffix of longer surfaces joins
+    # them when they are all one entity. Longest first, so that "Emmanuel Macron" has
+    # already joined "Président Emmanuel Macron" when "Macron" is considered.
+    parent = {key: key for key in surfaces}
+
+    def root(key):
+        while parent[key] != key:
+            parent[key] = parent[parent[key]]
+            key = parent[key]
+        return key
+
+    ambiguous: dict[tuple, set] = {}
+    for key in sorted(surfaces, key=lambda k: -len(k[1])):
+        family, tokens = key
+        if family != PERSON_FAMILY:
+            continue
+        longer = {root(other) for other in surfaces if other[0] == PERSON_FAMILY and is_proper_suffix(tokens, other[1])}
+        longer.discard(root(key))
+        if len(longer) == 1:
+            parent[root(key)] = longer.pop()
+        elif longer:
+            ambiguous[key] = longer
+
+    # 3. Ids in order of first appearance, canonical form = longest mention of the group.
+    members: dict[tuple, list[Annotation]] = defaultdict(list)
+    for key, annotations in surfaces.items():
+        members[root(key)].extend(annotations)
+    ordered = sorted(members, key=lambda r: min(a.start for a in members[r]))
+    group_id = {r: f"g{i}" for i, r in enumerate(ordered, start=1)}
+    canonical = {r: canonical_form(members[r], text, honorifics if r[0] == PERSON_FAMILY else set()) for r in ordered}
+
+    for key, annotations in surfaces.items():
+        r = root(key)
+        for a in annotations:
+            properties = dict(a.properties or {})
+            properties[ENTITY_GROUP] = group_id[r]
+            properties[CANONICAL_FORM] = canonical[r]
+            properties[MENTION_TYPE] = "name"
+            if key in ambiguous:
+                properties[ENTITY_GROUP_CANDIDATES] = sorted((group_id[c] for c in ambiguous[key]), key=lambda g: int(g[1:]))
+            else:
+                properties.pop(ENTITY_GROUP_CANDIDATES, None)
+            a.properties = properties
+
+
+def is_person_label(label: str, params: CoreferenceParameters) -> bool:
+    if params.person_labels:
+        return label in params.person_labels
+    return "person" in label.casefold()
+
+
+def surface_of(a: Annotation, text: str) -> str:
+    return a.text if a.text is not None else text[a.start : a.end]
+
+
+def name_tokens(surface: str, honorifics: set[str]) -> tuple[str, ...]:
+    """Normalized tokens of a surface: NFKC, one apostrophe, case-folded, and the
+    leading honorifics dropped (only for person names, where the set is not empty)."""
+    tokens = unicodedata.normalize("NFKC", surface).translate(APOSTROPHES).casefold().split()
+    while len(tokens) > 1 and tokens[0] in honorifics:
+        tokens = tokens[1:]
+    return tuple(tokens)
+
+
+def strip_honorifics(surface: str, honorifics: set[str]) -> str:
+    words = re.sub(r"\s+", " ", surface).strip().split(" ")
+    while len(words) > 1 and words[0].casefold() in honorifics:
+        words = words[1:]
+    return " ".join(words)
+
+
+def is_proper_suffix(tokens: tuple[str, ...], other: tuple[str, ...]) -> bool:
+    return len(tokens) < len(other) and other[len(other) - len(tokens) :] == tokens
+
+
+def canonical_form(annotations: list[Annotation], text: str, honorifics: set[str]) -> str:
+    """The longest form of the group: most words, then most characters, then the first."""
+    forms = [strip_honorifics(surface_of(a, text), honorifics) for a in sorted(annotations, key=lambda a: a.start)]
+    return max(forms, key=lambda f: (len(f.split()), len(f)))

pyprocessors_coreference-1.6.1/submodules/python-archetype/.claude-plugin/marketplace.json

@@ -0,0 +1,18 @@
+{
+  "$schema": "https://anthropic.com/claude-code/marketplace.schema.json",
+  "name": "kairntech-python",
+  "description": "Les outils Claude Code de Kairntech, distribues avec l'archetype qu'ils decrivent.",
+  "owner": {
+    "name": "Kairntech",
+    "email": "olivier.terrier@kairntech.com"
+  },
+  "plugins": [
+    {
+      "name": "python-archetype",
+      "description": "Cree et entretient les depots Python qui consomment python-archetype : creation d'un plugin a partir de sa graine, et mesure de la derive.",
+      "author": { "name": "Kairntech" },
+      "category": "development",
+      "source": "."
+    }
+  ]
+}

pyprocessors_coreference-1.6.1/submodules/python-archetype/.claude-plugin/plugin.json

@@ -0,0 +1,15 @@
+{
+  "$schema": "https://json.schemastore.org/claude-code-plugin-manifest.json",
+  "name": "python-archetype",
+  "displayName": "Kairntech python-archetype",
+  "version": "1.1.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",
+    "email": "olivier.terrier@kairntech.com"
+  },
+  "repository": "https://bitbucket.org/kairntech/python-archetype",
+  "license": "Proprietary",
+  "keywords": ["kairntech", "taskfile", "uv", "pyimporters", "pymultirole"],
+  "skills": "./skills/"
+}