reckoner-er 0.3.0__tar.gz

reckoner_er-0.3.0/CHANGELOG.md

@@ -0,0 +1,37 @@
+# Changelog
+
+## [0.3.0] - 2026-11-14
+
+- On PyPI as `reckoner-er` (`pip install reckoner-er`). The name `reckoner` there belongs to an unrelated Helm tool; the import name and the command stay `reckoner`.
+- New two-function API: `resolve(names)` returns typed `Cluster` objects (members, names, canonical name, identifiers, confidence, and an `explanations` sentence for every merge and refusal); `match(a, b)` returns a `MatchResult` with `matched`, `score`, `method` and `reasons`. Both take plain strings or records with identifiers. `Cluster` and `MatchResult` are frozen and hashable. See `docs/python-api.md`.
+- New `reckoner match "A" "B"` command, with `--a-cik`/`--b-cik` (and UEI, EIN, CAGE, ticker, domain), `--agency`, `--color` and `--json`. Exits 0 on a match and 1 otherwise. `match` is recognised as the first argument that is not an option, so `reckoner --color never match A B` works too. Because of this, a file literally named `match` is now read with `reckoner ./match` or `reckoner -- match`.
+- `pairwise_scores(clusters, labels)` scores a resolution against labelled data (pairwise precision, recall, F1).
+- Benchmark on real GLEIF names (1312 entities, 2922 names, CC0 snapshot committed): precision 0.966 and recall 0.969 on formatting variants; renames and trade names are not linked, by design. `python benchmarks/run_benchmark.py`; details in `docs/benchmark.md`. CI fails if precision or recall drops below 0.95.
+- Fix: dotted legal suffixes at the end of a name are now stripped like the plain ones. "Oracle Partners, L.P." and "ORACLE PARTNERS LP" both normalize to `oracle partners` (they did not match before), as do "L.L.C.", "P.A." and similar. Each dotted abbreviation is read on its own from the right, so "Acme U.S. L.P." matches "Acme U.S. LP" and "Foo L.P. L.L.C." matches "Foo LP LLC". Only letters that spell a legal suffix are joined, so initials such as "A.G. Edwards" and "U.S." normalize exactly as before. On the benchmark this raised formatting recall from 0.910 to 0.969 with precision unchanged.
+- Type hints throughout; ships `py.typed` and passes `mypy --strict`.
+- `publish.yml` builds, checks and smoke-tests the sdist and wheel, then uploads them to PyPI with trusted publishing when a `v*` tag is pushed.
+- The PyPI page comes from `docs/pypi.md` (absolute image URLs, `pip install reckoner-er`). The sdist includes `benchmarks/`, `docs/` and `examples/`, so the full test suite runs from an unpacked sdist; the benchmark test skips itself when `benchmarks/` is absent.
+
+## [0.2.2] - 2026-09-25
+
+- Fix: `link_confidence` no longer claims an identifier's confidence when only one record in the cluster carries that identifier. Such clusters were joined by name, so they now report 0.60 (for example GE with a CIK on one record only: was 0.99, now 0.60).
+- The summary now shows every record in each group and why it joined (`= CIK 907471`, `= name 'general electric'`), aligned, with a count of merges and refusals.
+- Color in the terminal (off when piped, with `NO_COLOR`, or `--color never`).
+- Running `reckoner` with no file prints what to try next; a file with none of the recognised columns stops with a message naming the columns found and what to rename; a missing file suggests `--demo`.
+- `--help` ends with copy-paste examples.
+- `install.sh` and `install.ps1` one-line installers; `examples/vendors.csv`.
+
+## [0.2.1] - 2026-09-25
+
+- The CLI now stops with a clear message when a CSV row has more fields than the header (usually an unquoted comma in a company name) instead of writing a garbled extra column.
+
+## [0.2.0] - 2026-09-25
+
+- New `reckoner` command line tool: resolve a CSV, JSON or JSON Lines file (or stdin) and get a readable summary, the full JSON result with every receipt, or a CSV of your rows with `entity_id`, `canonical_name` and `link_confidence` appended. `--agency` for agency names, `--demo` for a built-in example.
+- Prebuilt single-file executables for Windows, macOS (Apple Silicon and Intel) and Linux on every GitHub Release. No Python needed.
+- `python -m reckoner` works too.
+- CI runs the tests and the CLI on Linux and Windows.
+
+## [0.1.0]
+
+- Initial release: `EntityResolver`, identifier-first merges, exact-normalized name links, refusal receipts, agency mode.

reckoner_er-0.3.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Matthew Busel
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+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 THE
+AUTHORS OR COPYRIGHT HOLDERS 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.

reckoner_er-0.3.0/MANIFEST.in

@@ -0,0 +1,8 @@
+# The sdist carries what the test suite needs: tests/test_api.py runs the
+# benchmark on the committed GLEIF snapshot.
+recursive-include tests *.py
+recursive-include benchmarks *.py *.csv *.json
+recursive-include docs *.md
+recursive-include examples *.py *.csv
+include CHANGELOG.md
+global-exclude __pycache__ *.py[cod]

reckoner_er-0.3.0/PKG-INFO

@@ -0,0 +1,100 @@
+Metadata-Version: 2.4
+Name: reckoner-er
+Version: 0.3.0
+Summary: Deterministic, explainable entity resolution for organization names. No fuzzy matching. Every merge comes with a receipt.
+Author-email: Matthew Busel <mattbusel@gmail.com>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/Mattbusel/reckoner
+Project-URL: Issues, https://github.com/Mattbusel/reckoner/issues
+Project-URL: Changelog, https://github.com/Mattbusel/reckoner/blob/main/CHANGELOG.md
+Project-URL: Documentation, https://github.com/Mattbusel/reckoner/blob/main/docs/python-api.md
+Keywords: entity-resolution,record-linkage,deduplication,company-names,data-cleaning,data-engineering,master-data-management,name-matching,lei
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Environment :: Console
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Typing :: Typed
+Classifier: Topic :: Scientific/Engineering :: Information Analysis
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+<p align="center"><img src="https://raw.githubusercontent.com/Mattbusel/reckoner/v0.3.0/assets/banner.png" alt="reckoner: input records on the left, joined to the companies they name on the right, each line labeled with the reason; one pair stamped REFUSED" width="100%"></p>
+
+# reckoner
+
+**Give it a list of company names from different sources, and it tells you which ones are the same company, and why.** It only merges on proof (a shared ID, or the exact same name once spelling noise is removed), never on a guess, and it writes down a receipt for every merge and every refusal.
+
+```
+pip install reckoner-er
+```
+
+The package is called `reckoner-er` on PyPI because `reckoner` there is an unrelated Helm tool, so `pip install reckoner` installs the wrong thing. The import name and the command are both `reckoner`. Do not install both packages in one environment. Python 3.9 or newer, no dependencies, ships `py.typed`.
+
+<p align="center"><img src="https://raw.githubusercontent.com/Mattbusel/reckoner/v0.3.0/assets/demo.gif" alt="Terminal recording: reckoner --demo, then reckoner vendors.csv grouping 9 rows into 5 companies, then writing resolved.csv with an entity_id column" width="900"></p>
+
+## From Python
+
+```python
+from reckoner import resolve, match
+
+clusters = resolve([
+    "GENERAL ELECTRIC CO",
+    "General Electric Company",
+    {"name": "GE", "cik": "0000040545"},
+    {"name": "General Electric", "cik": "40545"},
+    "Boeing",
+])
+for c in clusters:
+    print(c.canonical_name, c.members, c.link_confidence)
+# General Electric Company (0, 1, 2, 3) 0.99
+# Boeing (4,) 1.0
+
+m = match("THE SHERWIN-WILLIAMS COMPANY", "Sherwin Williams Co")
+m.matched, m.score, m.method   # (True, 0.6, 'name_exact_normalized')
+
+match({"name": "Meta Platforms, Inc.", "cik": "1326801"},
+      {"name": "META PLATFORMS INC", "cik": "907471"}).reasons
+# ('identical normalized names but conflicting CIK - refusing to merge',)
+```
+
+Every `Cluster` carries its members, identifiers, confidence and an `explanations` sentence for every merge and refusal. Full reference: [docs/python-api.md](https://github.com/Mattbusel/reckoner/blob/v0.3.0/docs/python-api.md).
+
+## From the command line
+
+```bash
+reckoner --demo                                  # see it work on a built-in example
+reckoner vendors.csv                             # CSV, JSON or JSON Lines with a name column
+reckoner vendors.csv -f csv -o resolved.csv      # your rows + entity_id, canonical_name, link_confidence
+reckoner match "GENERAL ELECTRIC CO" "General Electric Company"   # exit 0 on a match, 1 otherwise
+```
+
+Recognised columns (case-insensitive): `name`, `agency`, `cik`, `uei`, `ein`, `cage`, `ticker`, `domain`, `source`, `state`. `--agency` handles government agency names (`DoD`, `EPA`, `U.S.` prefixes). `reckoner --help` lists every option.
+
+## How it decides
+
+<p align="center"><img src="https://raw.githubusercontent.com/Mattbusel/reckoner/v0.3.0/assets/how-it-decides.svg" alt="How reckoner decides: pass 1 merges on a shared ID; pass 2 links exact normalized names at 0.60 unless the records carry conflicting IDs, in which case it refuses with a reason" width="880"></p>
+
+- **Identifiers merge first.** A shared CIK, UEI, EIN, CAGE, ticker or domain merges two records outright. Registry IDs (CIK, UEI, EIN, CAGE) link at 0.97 to 0.99; reassignable ones (ticker 0.90, domain 0.85) lower.
+- **Names link only on an exact match after conservative cleanup.** Case, punctuation, `&`, a leading `The`, and trailing legal suffixes (`Inc`, `Corp`, `LLC`, `L.P.`, `GmbH`, `plc`, ...) are removed. Distinguishing words are never dropped. Such links score 0.60.
+- **No fuzzy scoring anywhere.** A typo does not match. There is no similarity knob to tune.
+- **Conflicting registry IDs block a merge.** Same normalized name but different CIKs: refused, with the reason recorded.
+
+On a committed snapshot of real GLEIF legal names (1312 entities, 2922 names), formatting variants resolve at precision 0.966 and recall 0.969. Renames and trade names are not linked, by design. Method and numbers: [docs/benchmark.md](https://github.com/Mattbusel/reckoner/blob/v0.3.0/docs/benchmark.md).
+
+## Links
+
+- Source, install scripts and prebuilt binaries (no Python needed): https://github.com/Mattbusel/reckoner
+- Changelog: https://github.com/Mattbusel/reckoner/blob/main/CHANGELOG.md
+- Issues: https://github.com/Mattbusel/reckoner/issues
+
+MIT licensed.

reckoner_er-0.3.0/README.md

@@ -0,0 +1,268 @@
+<p align="center"><img src="assets/banner.png" alt="reckoner: input records on the left, joined to the companies they name on the right, each line labeled with the reason; one pair stamped REFUSED" width="100%"></p>
+
+# reckoner
+
+**Give it a spreadsheet of company names from different sources, and it tells you which rows are the same company, and why.** It only merges on proof (a shared ID, or the exact same name once spelling noise is removed), never on a guess, and it writes down a receipt for every merge and every refusal.
+
+<p align="center"><img src="assets/demo.gif" alt="Terminal recording: reckoner --demo, then reckoner vendors.csv grouping 9 rows into 5 companies, then writing resolved.csv with an entity_id column" width="900"></p>
+
+## Install
+
+| Your system | One line |
+| --- | --- |
+| Windows (PowerShell) | `irm https://raw.githubusercontent.com/Mattbusel/reckoner/main/install.ps1 \| iex` |
+| macOS or Linux | `curl -fsSL https://raw.githubusercontent.com/Mattbusel/reckoner/main/install.sh \| sh` |
+| Homebrew (macOS, Linux) | `brew install mattbusel/tap/reckoner` |
+| Scoop (Windows) | `scoop bucket add mattbusel https://github.com/Mattbusel/scoop-bucket; scoop install mattbusel/reckoner` |
+| Python (pipx) | `pipx install git+https://github.com/Mattbusel/reckoner` |
+| Just the file | [Download for Windows, macOS or Linux](https://github.com/Mattbusel/reckoner/releases/latest), unzip, run |
+
+No Python is needed for anything except the pipx line. The install scripts check the download against the release's `SHA256SUMS.txt` before installing: `install.sh` puts `reckoner` in `~/.local/bin`, `install.ps1` puts `reckoner.exe` in `%LOCALAPPDATA%\Programs\reckoner` and adds it to your PATH.
+
+<details>
+<summary>Unsigned binary warnings, and why not <code>pip install reckoner</code></summary>
+
+The binaries are unsigned. Windows SmartScreen may say "unknown publisher": click **More info**, then **Run anyway**. On macOS, if a downloaded binary is blocked, run `xattr -d com.apple.quarantine reckoner` (the install script does this for you).
+
+The name `reckoner` on PyPI belongs to an unrelated Helm tool, so `pip install reckoner` installs the wrong thing. Use the pipx line above, or `pip install git+https://github.com/Mattbusel/reckoner` for the Python library.
+</details>
+
+## Use it in 3 steps
+
+**1. See it work on built-in data.**
+
+```bash
+reckoner --demo
+```
+
+You get 7 records grouped into 4 companies, and one refused merge: two records that are both called "Meta Platforms" but carry different SEC CIK numbers, so reckoner will not join them.
+
+**2. Point it at your own file.** A CSV, JSON or JSON Lines file with a `name` column (and, if you have them, ID columns like `cik`, `ein`, `uei`, `ticker`, `domain`):
+
+```bash
+reckoner vendors.csv
+```
+
+Every group is listed with the rows in it and the reason each row joined.
+
+**3. Save the answer as a spreadsheet.**
+
+```bash
+reckoner vendors.csv -f csv -o resolved.csv
+```
+
+`resolved.csv` is your file, same rows, same order, with three columns added: `entity_id` (rows with the same ID are the same company), `canonical_name` and `link_confidence`.
+
+## Results
+
+This is the real output for [`examples/vendors.csv`](examples/vendors.csv), nine rows from three made-up feeds:
+
+```
+$ reckoner examples/vendors.csv
+9 records -> 5 entities   4 merges, 0 refused
+
+ent-0  General Electric Company     0.60  TICKER GE
+       #0  GENERAL ELECTRIC CO          sec
+       #1  General Electric Company     usaspending  = name 'general electric'
+ent-2  The Boeing Company           0.60  TICKER BA
+       #2  The Boeing Company           sec
+       #3  BOEING CO                    usaspending  = name 'boeing'
+ent-4  Lockheed Martin Corporation  0.90  TICKER LMT
+       #4  Lockheed Martin Corporation  sec
+       #5  LOCKHEED MARTIN CORP         usaspending  = name 'lockheed martin'
+       #6  Lockheed Martin Corp.        sam          = TICKER LMT
+ent-7  Microsoft Corporation        1.00  TICKER MSFT
+ent-8  Micrsoft Corp                1.00
+
+#n is the input record.  '= CIK 123', '= TICKER X': joined on a shared ID.
+'= name ...' joined on the exact normalized name (0.60, never fuzzy).
+```
+
+Read it like this:
+
+- **Lockheed Martin**: row 6 joined because it has the same ticker as row 4 (0.90). Row 5 has no ticker, but its name is the same once case and "CORP" are removed, so it links at 0.60.
+- **Boeing**: "The Boeing Company" and "BOEING CO" both become `boeing`.
+- **Micrsoft Corp stays on its own.** It is a typo, and reckoner does not guess. A wrong merge is worse than a missed one.
+
+And when two rows look like the same name but carry different registry IDs, the merge is refused and the reason is kept (from `reckoner --demo`):
+
+```
+Refused merges (1):
+  #4 + #6  'Meta Platforms, Inc.' vs 'META PLATFORMS INC'
+           identical normalized names but conflicting CIK - refusing to merge
+```
+
+<p align="center"><img src="assets/how-it-decides.svg" alt="How reckoner decides: pass 1 merges on a shared ID; pass 2 links exact normalized names at 0.60 unless the records carry conflicting IDs, in which case it refuses with a reason" width="880"></p>
+
+## Why it works this way
+
+The same company is spelled differently in every system it appears in:
+
+| One source says | Another says |
+| --- | --- |
+| `GENERAL ELECTRIC CO` | `GENERAL ELECTRIC COMPANY` |
+| `BECTON DICKINSON & CO` | `BECTON, DICKINSON AND COMPANY` |
+| `THE SHERWIN-WILLIAMS COMPANY` | `Sherwin Williams Co` |
+| `Medtronic plc` | `MEDTRONIC INC` |
+
+Join two datasets on the raw name and you silently drop many true matches. Turn on a fuzzy matcher instead and you start quietly merging companies that are not the same, with no way to explain any single decision. reckoner takes the opposite stance:
+
+- **Identifiers merge first.** A shared CIK, UEI, EIN, CAGE, ticker or domain is the only thing that merges two records outright. Registry IDs (CIK, UEI, EIN, CAGE) link at 0.97 to 0.99; reassignable ones (ticker 0.90, domain 0.85) lower.
+- **Names link only on an exact match after conservative cleanup.** Case, punctuation, `&`, a leading `The`, and trailing legal suffixes (`Inc`, `Corp`, `Company`, `LLC`, `GmbH`, `plc`, ...) are removed. Distinguishing words are never dropped. Such links score 0.60.
+- **No fuzzy scoring anywhere.** A typo does not match. There is no similarity knob to tune.
+- **Conflicting registry IDs block a merge.** Same normalized name but different CIKs: refused, with the reason recorded.
+- **Everything is a receipt.** Every link and refusal is a `MatchRecord` with the original values, the normalized value, the method, the confidence and the evidence.
+
+It does not do fuzzy, edit-distance or embedding matching, machine learning, or network calls. If you need probabilistic linkage across millions of noisy consumer records, use a heavier library. reckoner is for when a wrong merge is worse than a missed one and every decision has to be explainable to an analyst, an auditor or a regulator.
+
+Pure Python standard library, zero dependencies, one file of logic ([`reckoner/resolver.py`](reckoner/resolver.py)) you can read in ten minutes.
+
+<details>
+<summary><b>Command line reference</b></summary>
+
+```
+reckoner [-h] [-f {summary,json,csv}] [-o OUTPUT] [--agency] [--demo]
+         [--color {auto,always,never}] [--version] [input]
+```
+
+| Option | What it does |
+| --- | --- |
+| `input` | CSV, JSON array or JSON Lines file, or `-` for stdin |
+| `-f summary` | readable report (default) |
+| `-f json` | the full result with every match receipt |
+| `-f csv` | each input row plus `entity_id`, `canonical_name`, `link_confidence` |
+| `-o FILE` | write to a file instead of the terminal |
+| `--agency` | government agency names: strips `U.S.` prefixes and expands `DoD`, `EPA`, ... |
+| `--color` | `auto` (default: color in a terminal, off when piped or when `NO_COLOR` is set), `always`, `never` |
+
+Recognised columns (case-insensitive): `name`, `agency`, `cik`, `uei`, `ein`, `cage`, `ticker`, `domain`, `source`, `state`. Other columns are kept in CSV output. If none of your columns are recognised, reckoner stops and tells you which columns it found and what to rename.
+
+```bash
+reckoner records.jsonl --format json      # full result with every receipt
+reckoner agencies.csv --agency            # DoD, EPA, U.S. prefixes
+cat companies.csv | reckoner -            # read stdin
+```
+</details>
+
+<details>
+<summary><b>Use it from Python</b></summary>
+
+```python
+from reckoner import EntityResolver
+
+records = [
+    {"name": "GENERAL ELECTRIC CO", "cik": "0000040545", "source": "sec"},
+    {"name": "General Electric Company", "source": "usaspending"},
+    {"name": "THE SHERWIN-WILLIAMS COMPANY", "source": "usaspending"},
+    {"name": "Sherwin Williams Co", "source": "sec"},
+    {"name": "Meta Platforms, Inc.", "cik": "1326801", "source": "sec"},
+    {"name": "Meta Financial Group, Inc.", "cik": "907471", "source": "sec"},
+]
+
+result = EntityResolver().resolve(records)
+
+for e in result["entities"]:
+    print(e["canonical_name"], "<-", e["aliases"], f"(conf {e['link_confidence']})")
+```
+
+```
+General Electric Company <- ['GENERAL ELECTRIC CO', 'General Electric Company'] (conf 0.6)
+THE SHERWIN-WILLIAMS COMPANY <- ['THE SHERWIN-WILLIAMS COMPANY', 'Sherwin Williams Co'] (conf 0.6)
+Meta Platforms, Inc. <- ['Meta Platforms, Inc.'] (conf 1.0)
+Meta Financial Group, Inc. <- ['Meta Financial Group, Inc.'] (conf 1.0)
+```
+
+Both GE and Sherwin-Williams link on the normalized name (only one GE record carries the CIK, so the CIK cannot prove the link). The two Metas normalize to different names and carry different CIKs, so they never link.
+
+When two records normalize to the same name but carry conflicting identifiers, the merge is refused and the refusal is kept:
+
+```python
+result = EntityResolver().resolve([
+    {"name": "Meta Platforms, Inc.", "cik": "1326801"},
+    {"name": "META PLATFORMS INC", "cik": "907471"},
+])
+result["entities_out"]  # 2, with a refusal receipt in result["matches"]
+```
+
+Agency names: `EntityResolver(agency_mode=True)` adds US-prefix stripping and a small alias table (`DoD` to `department of defense`, `EPA` to `environmental protection agency`, ...):
+
+```python
+EntityResolver(agency_mode=True).resolve([
+    {"agency": "DoD"},
+    {"agency": "U.S. Department of Defense"},
+])  # -> 1 entity
+```
+
+Run the full example with `PYTHONPATH=. python examples/quickstart.py` from the repo root.
+</details>
+
+<details>
+<summary><b>The output shape</b></summary>
+
+`resolve(records)` returns a dict:
+
+```python
+{
+  "entities": [ ... ],   # one canonical entity per cluster
+  "clusters": [[0, 1], [2, 3], ...],   # input indices grouped
+  "matches":  [ ... ],   # every MatchRecord, merged and refused
+  "records_in": 6,
+  "entities_out": 4,
+}
+```
+
+Each entity:
+
+```python
+{
+  "entity_id": "ent-0",
+  "canonical_name": "General Electric Company",
+  "normalized_name": "general electric",
+  "identifiers": {"cik": "40545"},
+  "aliases": ["GENERAL ELECTRIC CO", "General Electric Company"],
+  "member_indices": [0, 1],
+  "sources": ["sec", "usaspending"],
+  "link_confidence": 0.6,
+}
+```
+
+`link_confidence` is the strongest evidence that actually merged the cluster: an identifier's confidence if an identifier shared between members merged them, otherwise 0.60 for a name link. A single-record entity is 1.0.
+
+Each match or refusal receipt:
+
+```python
+{
+  "left_index": 0, "right_index": 1,
+  "method": "name_exact_normalized",
+  "confidence": 0.0, "merged": False,
+  "left_original": "Meta Platforms, Inc.",
+  "right_original": "META PLATFORMS INC",
+  "normalized": "meta platforms",
+  "evidence": [],
+  "refusal_reason": "identical normalized names but conflicting CIK - refusing to merge",
+}
+```
+</details>
+
+<details>
+<summary><b>Extending it, and running the tests</b></summary>
+
+The normalization is deliberately small and readable. Add legal suffixes to `LEGAL_SUFFIXES`, agency aliases to `AGENCY_ALIASES`, or new identifier types to `IDENTIFIERS` with a normalizer and a confidence. Everything is exact-match on the normalized value; there is nothing fuzzy to tune.
+
+```bash
+git clone https://github.com/Mattbusel/reckoner
+cd reckoner
+python -m unittest discover -s tests
+python -m reckoner --demo
+```
+
+Or just copy `reckoner/resolver.py` into your project. It is standard library only.
+</details>
+
+## License
+
+MIT, see [LICENSE](LICENSE).
+
+---
+
+Built by the team behind [Tensorust](https://tensorust-site.vercel.app/), where reconciling public records across systems that each spell reality slightly differently is the whole job.