fix: coerce affiliations to arrays and dedupe duplicates (0.9.7)

creators[].affiliation and contributors[].affiliation are now always
emitted in the schema's array form. The model sometimes returned a bare
string or a single object, which violated the schema (affiliation must
be an array) and skipped ROR enrichment. A coercion step runs before
enrichment: string -> [string], object -> [object], blank/null/junk
drops the optional key, and blank list items are filtered out.

Duplicate affiliations are also collapsed (e.g. the same ROR object
listed twice). Entries are keyed on ROR identifier when present, else on
normalized name; the identifier-bearing entry wins on collision. Dedupe
runs unconditionally after enrichment, so already-resolved posters are
cleaned too.

Author: jimnoneill

CHANGELOG.md

@@ -5,6 +5,13 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.9.7] - 2026-06-08
+
+### Fixed
+
+- **`creators[].affiliation` / `contributors[].affiliation` always emitted as the schema's array form.** The model occasionally returned a bare string (e.g. `"affiliation": "Oregon Health & Science University, ..."`) or a single object, which violated the schema (`affiliation` must be an array) and skipped ROR enrichment entirely. A new coercion step now runs before enrichment: a bare string becomes `[string]`, a single object becomes `[object]`, blank/`null`/junk values drop the (optional) key, and blank items inside a list are filtered out. Because the value is now a proper list, string affiliations also become eligible for ROR resolution again.
+- **Duplicate affiliations are collapsed.** The same organization listed twice on a creator (a recurring model artifact, e.g. the identical ROR object repeated) is now deduplicated. Entries are keyed on their ROR identifier when present, else on their normalized name; when duplicates collide the entry carrying an identifier is kept, and a bare-name entry is dropped when an identified entry already covers the same organization. Runs unconditionally, after enrichment, so it also cleans posters whose affiliations were already fully resolved.
+
 ## [0.9.6] - 2026-06-08
 
 ### Changed

poster2json/extract.py

@@ -2252,6 +2252,15 @@ def _postprocess_json(
             # honest than guessing.
             result["language"] = None
 
+    # Affiliation normalization: coerce to the schema's array form (the model
+    # sometimes emits a bare string or single object), then ROR-enrich, then
+    # collapse duplicates. Coerce and dedupe run unconditionally; only the
+    # network enrichment is gated on something actually being unresolved.
+    from .ror import coerce_person_affiliations, dedupe_person_affiliations
+    for _persons_key in ("creators", "contributors"):
+        if _persons_key in result:
+            result[_persons_key] = coerce_person_affiliations(result[_persons_key])
+
     # ROR enrichment -- skip if all affiliations already resolved
     if (_needs_ror_enrichment(result.get("creators"))
             or _needs_ror_enrichment(result.get("contributors"))):
@@ -2262,6 +2271,10 @@ def _postprocess_json(
         if "contributors" in result:
             result["contributors"] = enrich_persons(result["contributors"], ror)
 
+    for _persons_key in ("creators", "contributors"):
+        if _persons_key in result:
+            result[_persons_key] = dedupe_person_affiliations(result[_persons_key])
+
     # Funder + award normalization, then ROR funder lookup
     if "fundingReferences" in result:
         from .normalize import normalize_funding_references

poster2json/ror.py

@@ -222,6 +222,125 @@ def enrich_persons(persons: list, client: RorClient) -> list:
     return persons
 
 
+def _coerce_affiliation_value(aff):
+    """Coerce one person's ``affiliation`` into the schema's array form.
+
+    The schema requires ``affiliation`` to be an array of strings/objects, but
+    the model sometimes emits a bare string or a single object. Returns a
+    non-empty list, or ``None`` to signal the key should be dropped (it was
+    null, empty, or contained only junk — ``affiliation`` is optional).
+    """
+    if isinstance(aff, str):
+        s = aff.strip()
+        return [s] if s else None
+    if isinstance(aff, dict):
+        return [aff] if (aff.get("name") or aff.get("affiliationIdentifier")) else None
+    if isinstance(aff, list):
+        out = []
+        for item in aff:
+            if isinstance(item, str):
+                s = item.strip()
+                if s:
+                    out.append(s)
+            elif isinstance(item, dict):
+                if item.get("name") or item.get("affiliationIdentifier"):
+                    out.append(item)
+            # drop anything else (numbers, None, nested lists)
+        return out or None
+    return None
+
+
+def coerce_person_affiliations(persons: list) -> list:
+    """Normalize ``affiliation`` on every person to a list (in place).
+
+    A bare string becomes ``[string]``, a single object becomes ``[object]``,
+    and null/empty values drop the key. Runs before ROR enrichment so the
+    enrichment and the schema both see a proper array.
+    """
+    if not isinstance(persons, list):
+        return persons
+    for p in persons:
+        if not isinstance(p, dict) or "affiliation" not in p:
+            continue
+        coerced = _coerce_affiliation_value(p["affiliation"])
+        if coerced is None:
+            p.pop("affiliation", None)
+        else:
+            p["affiliation"] = coerced
+    return persons
+
+
+def _affiliation_name(item) -> Optional[str]:
+    if isinstance(item, str):
+        name = item
+    elif isinstance(item, dict) and isinstance(item.get("name"), str):
+        name = item["name"]
+    else:
+        return None
+    name = unicodedata.normalize("NFKC", name).strip().casefold()
+    return name or None
+
+
+def _affiliation_dedupe_key(item):
+    if isinstance(item, dict):
+        ident = item.get("affiliationIdentifier")
+        if ident:
+            return ("id", str(ident).strip().lower())
+    name = _affiliation_name(item)
+    if name is not None:
+        return ("name", name)
+    return ("obj", json.dumps(item, sort_keys=True, ensure_ascii=False))
+
+
+def _affiliation_richness(item) -> int:
+    if isinstance(item, dict):
+        return 2 if item.get("affiliationIdentifier") else 1
+    return 0
+
+
+def dedupe_person_affiliations(persons: list) -> list:
+    """Collapse duplicate affiliation entries on every person (in place).
+
+    Entries are keyed on their ROR identifier when present, else on their
+    normalized name, so the same organization listed twice (a recurring model
+    artifact) collapses to one. When duplicates collide the richer entry (one
+    carrying an identifier) is kept, and a bare-name entry is dropped when an
+    identified entry already covers the same organization name.
+    """
+    if not isinstance(persons, list):
+        return persons
+    for p in persons:
+        if not isinstance(p, dict):
+            continue
+        affs = p.get("affiliation")
+        if not isinstance(affs, list) or len(affs) < 2:
+            continue
+        order = []
+        chosen = {}
+        for item in affs:
+            key = _affiliation_dedupe_key(item)
+            if key not in chosen:
+                chosen[key] = item
+                order.append(key)
+            elif _affiliation_richness(item) > _affiliation_richness(chosen[key]):
+                chosen[key] = item
+        # Drop bare-name entries already covered by an identified entry.
+        identified_names = {
+            _affiliation_name(it)
+            for it in chosen.values()
+            if isinstance(it, dict) and it.get("affiliationIdentifier")
+        }
+        identified_names.discard(None)
+        result = []
+        for key in order:
+            it = chosen[key]
+            if key[0] == "name" and key[1] in identified_names and _affiliation_richness(it) < 2:
+                continue
+            result.append(it)
+        p["affiliation"] = result
+    return persons
+
+
 _default_client: Optional[RorClient] = None
 
 

pyproject.toml

@@ -1,7 +1,7 @@
 [tool.poetry]
 
 name = "poster2json"
-version = "0.9.6"
+version = "0.9.7"
 description = "Convert scientific posters (PDF/images) to structured JSON metadata using Large Language Models"
 
 packages = [{ include = "poster2json" }]

tests/test_ror.py

@@ -8,6 +8,8 @@
 from poster2json.ror import (
     RorClient,
     _enrich_affiliation_item,
+    coerce_person_affiliations,
+    dedupe_person_affiliations,
     enrich_persons,
 )
 
@@ -94,6 +96,82 @@ def test_cache_records_negative_lookups(tmp_path, monkeypatch):
     assert client.lookup("Unknown Inst") is None
 
 
+def test_coerce_bare_string_affiliation_to_list():
+    # The schema-violating shape reported in the field: affiliation is a string.
+    persons = [{
+        "name": "Tedla, Saron",
+        "affiliation": "Oregon Health & Science University, School of Medicine, Portland, OR, USA",
+    }]
+    out = coerce_person_affiliations(persons)
+    assert out[0]["affiliation"] == [
+        "Oregon Health & Science University, School of Medicine, Portland, OR, USA"
+    ]
+
+
+def test_coerce_single_object_to_list():
+    persons = [{"name": "A", "affiliation": {"name": "MIT"}}]
+    out = coerce_person_affiliations(persons)
+    assert out[0]["affiliation"] == [{"name": "MIT"}]
+
+
+def test_coerce_drops_null_empty_and_junk():
+    persons = [
+        {"name": "A", "affiliation": None},
+        {"name": "B", "affiliation": ""},
+        {"name": "C", "affiliation": []},
+        {"name": "D", "affiliation": ["  ", None, 5, {"foo": "bar"}]},
+        {"name": "E"},
+    ]
+    out = coerce_person_affiliations(persons)
+    assert "affiliation" not in out[0]
+    assert "affiliation" not in out[1]
+    assert "affiliation" not in out[2]
+    assert "affiliation" not in out[3]  # all items were junk
+    assert "affiliation" not in out[4]
+
+
+def test_coerce_filters_blank_list_items_but_keeps_valid():
+    persons = [{"name": "A", "affiliation": ["Stanford", "  ", {"name": "MIT"}, {}]}]
+    out = coerce_person_affiliations(persons)
+    assert out[0]["affiliation"] == ["Stanford", {"name": "MIT"}]
+
+
+def test_dedupe_identical_objects():
+    # The other reported shape: same ROR object listed twice (Jalili / UCSD).
+    ucsd = {
+        "name": "University of California San Diego",
+        "schemeUri": "https://ror.org/",
+        "affiliationIdentifier": "https://ror.org/0168r3w48",
+        "affiliationIdentifierScheme": "ROR",
+    }
+    persons = [{"name": "Jalili, Jalil", "affiliation": [dict(ucsd), dict(ucsd)]}]
+    out = dedupe_person_affiliations(persons)
+    assert out[0]["affiliation"] == [ucsd]
+
+
+def test_dedupe_identical_strings():
+    persons = [{"name": "A", "affiliation": ["MIT", "mit", "MIT "]}]
+    out = dedupe_person_affiliations(persons)
+    assert out[0]["affiliation"] == ["MIT"]
+
+
+def test_dedupe_prefers_identified_entry_over_bare_name():
+    persons = [{"name": "A", "affiliation": [
+        "Stanford University",
+        {"name": "Stanford University", "affiliationIdentifier": "https://ror.org/00f54p054"},
+    ]}]
+    out = dedupe_person_affiliations(persons)
+    assert out[0]["affiliation"] == [
+        {"name": "Stanford University", "affiliationIdentifier": "https://ror.org/00f54p054"}
+    ]
+
+
+def test_dedupe_keeps_distinct_affiliations_and_order():
+    persons = [{"name": "A", "affiliation": ["MIT", "Stanford", "MIT"]}]
+    out = dedupe_person_affiliations(persons)
+    assert out[0]["affiliation"] == ["MIT", "Stanford"]
+
+
 def test_strip_trailing_country():
     from poster2json.ror import _strip_trailing_country