sieve-crowd 0.2.0__tar.gz

sieve_crowd-0.2.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Kai IWASAKI
+
+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.

sieve_crowd-0.2.0/PKG-INFO

@@ -0,0 +1,188 @@
+Metadata-Version: 2.4
+Name: sieve-crowd
+Version: 0.2.0
+Summary: Make every record one of a crowd, and measure it: deterministic, offline k-anonymity for CSV, JSON and XML tables.
+Author: Kai IWASAKI
+License: MIT
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# Sieve Crowd v0.2.0
+
+English | [日本語](README.ja.md)
+
+**Table data anonymization and privacy protection engine**
+
+[![PyPI Version](https://img.shields.io/pypi/v/sieve-crowd.svg)](https://pypi.org/project/sieve-crowd/)
+[![Python Version](https://img.shields.io/pypi/pyversions/sieve-crowd.svg)](https://pypi.org/project/sieve-crowd/)
+[![CI](https://github.com/neguseatama/sieve-crowd/actions/workflows/test.yml/badge.svg)](https://github.com/neguseatama/sieve-crowd/actions/workflows/test.yml)
+[![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](https://opensource.org/licenses/MIT)
+
+> Sieve Crowd is a table-data processing engine that suppresses the risk of identifying individuals in tabular data, so that the data can be shared safely. Building on the principles of k-anonymity and l-diversity, it deterministically performs attribute rounding (generalization) and partial record removal (suppression).
+
+A fully local, zero-dependency, deterministic (100% reproducible) mathematical transformation engine that anonymizes tabular data and disables re-identification. It extends the design philosophy of [Sieve-Core](https://github.com/neguseatama/sieve-core) into the tabular-data domain.
+
+---
+
+## 💡 Concept and design philosophy
+
+Even when personal data is kept safely on your own machine, you sometimes have to provide or publish tabular data that contains it — or you face the risk of leakage. From a statistical standpoint, the combination of attributes such as age, postal code and sex always carries a risk of identifying individuals.
+
+Consider, for example, a dataset of about 600 people. The risk structure becomes clear:
+
+- **Before**: 574 of the 600 people (96%) were "alone" on the combination of age, postal code and sex — no one else shared their exact values, so an outsider could single them out easily.
+- **How the transformation works**: rather than leaving these isolated records as they are, the engine groups similar records together (by rounding and generalization) so that everyone is hidden inside a safe crowd.
+- **After**: every person belongs to a group of at least 5 (4 look-alikes besides themselves). Even an outsider who tries to identify someone can be right at most 1 in 5 times (20%).
+
+Sieve Crowd does not rely on probabilistic inference or black-box AI. It transforms tabular data into a state in which no one stands out, deterministically, on the basis of the rigorous mathematical models of k-anonymity and l-diversity.
+
+- **Deterministic approach**: the same input and settings always produce the same output. The result never depends on the execution environment, the clock, or random numbers.
+- **A measurement, not a promise**: after the transformation, the finished table is re-counted to check whether it meets the target safety level. If it falls short, the reason is given on a receipt and the table is not written.
+- **Explainability**: a receipt records the data processing performed for anonymization, so that what was done can be fully traced.
+
+---
+
+## 🧩 Sieve series
+
+Sieve is a family of engines that share three design principles — deterministic, zero-dependency, fully local. Each engine handles one observation or one removal, and they connect to each other:
+
+| Package | Role | Connection |
+| :--- | :--- | :--- |
+| [sieve-core-engine](https://github.com/neguseatama/sieve-core) | Ecosystem base logic / plugin host | — |
+| [sieve-lens](https://github.com/neguseatama/sieve-lens) | Observes invisible content and hidden prompts in documents | — |
+| [sieve-scope](https://github.com/neguseatama/sieve-scope) | Detects structurally similar code pairs | — |
+| [sieve-referee](https://github.com/neguseatama/sieve-referee) | Detects paraphrased or reused text pairs | — |
+| [sieve-redact](https://github.com/neguseatama/sieve-redact) | Masks sensitive regions with a receipt (text & PNG) | ← lens, → tray |
+| [sieve-crowd](https://github.com/neguseatama/sieve-crowd) | Observes and anonymizes re-identification risk in tabular data (k-anonymity) | — |
+| [sieve-tray](https://github.com/neguseatama/sieve-tray) | Desktop front-end that routes files to the right engine | ← all engines |
+
+---
+
+## 🔥 Main features
+
+- **k-anonymity and l-diversity**
+  Attributes are generalized so that each record has at least k−1 look-alikes, and the diversity of sensitive values is also guaranteed.
+- **Zero dependencies, fully local**
+  Implemented with the Python standard library only. Data never leaves your computer (no account, offline, no upload).
+- **Minimal generalization and suppression**
+  Data is not rounded more than necessary; resolution is preserved as much as possible while grouping. Records that still cannot form a group are safely removed (suppressed) rather than distorted.
+- **Receipt for the record**
+  A machine-readable receipt records what was done (rules applied, suppression count, measurements). The receipt contains no personal information.
+- **Supported formats**
+  CSV, JSON and XML (UTF-8). Excel is excluded to keep the tool dependency-free.
+
+---
+
+## 🎯 Use cases
+
+- Keeping data on hand for internal use or in-house sharing, stored and managed safely
+- Providing survey or customer data to a university, agency, or analytics contractor
+- Publishing statistics or open data from hospitals, schools, or local governments
+- Feeding realistic test data into a development environment, safely
+- Keeping a record of anonymization and processing for legal or audit purposes
+
+---
+
+## 📦 Install
+
+```bash
+pip install git+https://github.com/neguseatama/sieve-crowd.git
+```
+
+Or from a local clone:
+
+```bash
+git clone https://github.com/neguseatama/sieve-crowd.git
+cd sieve-crowd
+pip install .
+```
+
+---
+
+## 💻 Quick start
+
+### 1. Inspect the structure
+
+Reads the file and writes a configuration file that proposes a role for each column (name, quasi-identifier, sensitive value, etc.).
+
+```bash
+sieve-crowd inspect people.csv --config-out config.json
+```
+
+### 2. Review and edit the configuration
+
+Edit the generated `config.json` to define the role of each column.
+
+### 3. Run anonymization
+
+```bash
+sieve-crowd run people.csv -c config.json -o people_safe.csv --receipt receipt.json
+```
+
+Input and output example:
+
+```
+people.csv                                       people_safe.csv   (rows shuffled)
+name,birth_date,age,zip,sex,diagnosis            age,zip,sex,diagnosis
+Takahashi Hina,1986-11-02,40,1500052,M,none     20-24,15100**,F,cold
+Kobayashi Haruto,2003-01-03,23,1000042,F,flu    20-24,16000**,M,none
+Yamamoto Aoi,1971-10-04,55,1510061,M,flu        55-59,15100**,M,asthma
+```
+
+---
+
+## ⚙️ Settings and options
+
+| Setting | Default | Meaning |
+| :--- | :--- | :--- |
+| `k` | 5 | Each record must have at least k−1 look-alikes. Larger is safer but increases generalization. |
+| `l` | optional | Every crowd must hold at least l distinct sensitive values, preventing "everyone has the same diagnosis". |
+| `max_suppression` | 0.05 (5%) | The maximum fraction of records that may be removed (suppressed) instead of lowering the resolution of the whole table. |
+| Role (`role`) | — | `id` (drop or pseudonymize) · `qi` (generalize) · `sensitive` (keep) · `keep` (keep) · `drop` (remove) |
+
+Main command-line options:
+
+- `--dry-run`: do not write data; only measure anonymization and assess risk
+- `--lang ja`: issue a Japanese receipt (default is English; JSON output is also available)
+- `--in-format` / `--out-format`: explicitly set the input/output format (csv, json, xml)
+- `sieve-crowd keygen -o key.txt`: generate a cryptographic key for pseudonymization
+
+Exit codes:
+
+- `0`: success
+- `1`: I/O error
+- `2`: configuration error
+- `3`: refused (the target anonymization level could not be reached; no output written)
+
+---
+
+## 🔬 Tests
+
+```bash
+python -m unittest discover -s tests -v
+```
+
+All test suites run with no external dependencies (standard library only).
+
+---
+
+## ⚠️ Known limitations and caveats
+
+1. **Model assumption** — Sieve Crowd protects against an attacker who knows the attributes you declared as `qi` (quasi-identifiers). It is not a universal shield against re-identification through auxiliary information you did not anticipate.
+2. **Not a substitute for legal or privacy review** — It does not guarantee legal or regulatory compliance under privacy laws or guidelines; it is a tool that supports such review technically.
+3. **Excel is not supported** — To keep the dependency-free principle, the binary `.xlsx` format is out of scope (use CSV / JSON / XML).
+4. **Row shuffling** — To minimize re-identification risk, the output row order is deterministically shuffled.
+
+---
+
+## 📄 License
+
+MIT License. See [LICENSE](LICENSE) for details.
+
+---
+
+## 👤 Author
+
+* **Kai IWASAKI**

sieve_crowd-0.2.0/README.md

@@ -0,0 +1,177 @@
+# Sieve Crowd v0.2.0
+
+English | [日本語](README.ja.md)
+
+**Table data anonymization and privacy protection engine**
+
+[![PyPI Version](https://img.shields.io/pypi/v/sieve-crowd.svg)](https://pypi.org/project/sieve-crowd/)
+[![Python Version](https://img.shields.io/pypi/pyversions/sieve-crowd.svg)](https://pypi.org/project/sieve-crowd/)
+[![CI](https://github.com/neguseatama/sieve-crowd/actions/workflows/test.yml/badge.svg)](https://github.com/neguseatama/sieve-crowd/actions/workflows/test.yml)
+[![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](https://opensource.org/licenses/MIT)
+
+> Sieve Crowd is a table-data processing engine that suppresses the risk of identifying individuals in tabular data, so that the data can be shared safely. Building on the principles of k-anonymity and l-diversity, it deterministically performs attribute rounding (generalization) and partial record removal (suppression).
+
+A fully local, zero-dependency, deterministic (100% reproducible) mathematical transformation engine that anonymizes tabular data and disables re-identification. It extends the design philosophy of [Sieve-Core](https://github.com/neguseatama/sieve-core) into the tabular-data domain.
+
+---
+
+## 💡 Concept and design philosophy
+
+Even when personal data is kept safely on your own machine, you sometimes have to provide or publish tabular data that contains it — or you face the risk of leakage. From a statistical standpoint, the combination of attributes such as age, postal code and sex always carries a risk of identifying individuals.
+
+Consider, for example, a dataset of about 600 people. The risk structure becomes clear:
+
+- **Before**: 574 of the 600 people (96%) were "alone" on the combination of age, postal code and sex — no one else shared their exact values, so an outsider could single them out easily.
+- **How the transformation works**: rather than leaving these isolated records as they are, the engine groups similar records together (by rounding and generalization) so that everyone is hidden inside a safe crowd.
+- **After**: every person belongs to a group of at least 5 (4 look-alikes besides themselves). Even an outsider who tries to identify someone can be right at most 1 in 5 times (20%).
+
+Sieve Crowd does not rely on probabilistic inference or black-box AI. It transforms tabular data into a state in which no one stands out, deterministically, on the basis of the rigorous mathematical models of k-anonymity and l-diversity.
+
+- **Deterministic approach**: the same input and settings always produce the same output. The result never depends on the execution environment, the clock, or random numbers.
+- **A measurement, not a promise**: after the transformation, the finished table is re-counted to check whether it meets the target safety level. If it falls short, the reason is given on a receipt and the table is not written.
+- **Explainability**: a receipt records the data processing performed for anonymization, so that what was done can be fully traced.
+
+---
+
+## 🧩 Sieve series
+
+Sieve is a family of engines that share three design principles — deterministic, zero-dependency, fully local. Each engine handles one observation or one removal, and they connect to each other:
+
+| Package | Role | Connection |
+| :--- | :--- | :--- |
+| [sieve-core-engine](https://github.com/neguseatama/sieve-core) | Ecosystem base logic / plugin host | — |
+| [sieve-lens](https://github.com/neguseatama/sieve-lens) | Observes invisible content and hidden prompts in documents | — |
+| [sieve-scope](https://github.com/neguseatama/sieve-scope) | Detects structurally similar code pairs | — |
+| [sieve-referee](https://github.com/neguseatama/sieve-referee) | Detects paraphrased or reused text pairs | — |
+| [sieve-redact](https://github.com/neguseatama/sieve-redact) | Masks sensitive regions with a receipt (text & PNG) | ← lens, → tray |
+| [sieve-crowd](https://github.com/neguseatama/sieve-crowd) | Observes and anonymizes re-identification risk in tabular data (k-anonymity) | — |
+| [sieve-tray](https://github.com/neguseatama/sieve-tray) | Desktop front-end that routes files to the right engine | ← all engines |
+
+---
+
+## 🔥 Main features
+
+- **k-anonymity and l-diversity**
+  Attributes are generalized so that each record has at least k−1 look-alikes, and the diversity of sensitive values is also guaranteed.
+- **Zero dependencies, fully local**
+  Implemented with the Python standard library only. Data never leaves your computer (no account, offline, no upload).
+- **Minimal generalization and suppression**
+  Data is not rounded more than necessary; resolution is preserved as much as possible while grouping. Records that still cannot form a group are safely removed (suppressed) rather than distorted.
+- **Receipt for the record**
+  A machine-readable receipt records what was done (rules applied, suppression count, measurements). The receipt contains no personal information.
+- **Supported formats**
+  CSV, JSON and XML (UTF-8). Excel is excluded to keep the tool dependency-free.
+
+---
+
+## 🎯 Use cases
+
+- Keeping data on hand for internal use or in-house sharing, stored and managed safely
+- Providing survey or customer data to a university, agency, or analytics contractor
+- Publishing statistics or open data from hospitals, schools, or local governments
+- Feeding realistic test data into a development environment, safely
+- Keeping a record of anonymization and processing for legal or audit purposes
+
+---
+
+## 📦 Install
+
+```bash
+pip install git+https://github.com/neguseatama/sieve-crowd.git
+```
+
+Or from a local clone:
+
+```bash
+git clone https://github.com/neguseatama/sieve-crowd.git
+cd sieve-crowd
+pip install .
+```
+
+---
+
+## 💻 Quick start
+
+### 1. Inspect the structure
+
+Reads the file and writes a configuration file that proposes a role for each column (name, quasi-identifier, sensitive value, etc.).
+
+```bash
+sieve-crowd inspect people.csv --config-out config.json
+```
+
+### 2. Review and edit the configuration
+
+Edit the generated `config.json` to define the role of each column.
+
+### 3. Run anonymization
+
+```bash
+sieve-crowd run people.csv -c config.json -o people_safe.csv --receipt receipt.json
+```
+
+Input and output example:
+
+```
+people.csv                                       people_safe.csv   (rows shuffled)
+name,birth_date,age,zip,sex,diagnosis            age,zip,sex,diagnosis
+Takahashi Hina,1986-11-02,40,1500052,M,none     20-24,15100**,F,cold
+Kobayashi Haruto,2003-01-03,23,1000042,F,flu    20-24,16000**,M,none
+Yamamoto Aoi,1971-10-04,55,1510061,M,flu        55-59,15100**,M,asthma
+```
+
+---
+
+## ⚙️ Settings and options
+
+| Setting | Default | Meaning |
+| :--- | :--- | :--- |
+| `k` | 5 | Each record must have at least k−1 look-alikes. Larger is safer but increases generalization. |
+| `l` | optional | Every crowd must hold at least l distinct sensitive values, preventing "everyone has the same diagnosis". |
+| `max_suppression` | 0.05 (5%) | The maximum fraction of records that may be removed (suppressed) instead of lowering the resolution of the whole table. |
+| Role (`role`) | — | `id` (drop or pseudonymize) · `qi` (generalize) · `sensitive` (keep) · `keep` (keep) · `drop` (remove) |
+
+Main command-line options:
+
+- `--dry-run`: do not write data; only measure anonymization and assess risk
+- `--lang ja`: issue a Japanese receipt (default is English; JSON output is also available)
+- `--in-format` / `--out-format`: explicitly set the input/output format (csv, json, xml)
+- `sieve-crowd keygen -o key.txt`: generate a cryptographic key for pseudonymization
+
+Exit codes:
+
+- `0`: success
+- `1`: I/O error
+- `2`: configuration error
+- `3`: refused (the target anonymization level could not be reached; no output written)
+
+---
+
+## 🔬 Tests
+
+```bash
+python -m unittest discover -s tests -v
+```
+
+All test suites run with no external dependencies (standard library only).
+
+---
+
+## ⚠️ Known limitations and caveats
+
+1. **Model assumption** — Sieve Crowd protects against an attacker who knows the attributes you declared as `qi` (quasi-identifiers). It is not a universal shield against re-identification through auxiliary information you did not anticipate.
+2. **Not a substitute for legal or privacy review** — It does not guarantee legal or regulatory compliance under privacy laws or guidelines; it is a tool that supports such review technically.
+3. **Excel is not supported** — To keep the dependency-free principle, the binary `.xlsx` format is out of scope (use CSV / JSON / XML).
+4. **Row shuffling** — To minimize re-identification risk, the output row order is deterministically shuffled.
+
+---
+
+## 📄 License
+
+MIT License. See [LICENSE](LICENSE) for details.
+
+---
+
+## 👤 Author
+
+* **Kai IWASAKI**

sieve_crowd-0.2.0/pyproject.toml

@@ -0,0 +1,19 @@
+[build-system]
+requires = ["setuptools>=61"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "sieve-crowd"
+version = "0.2.0"
+description = "Make every record one of a crowd, and measure it: deterministic, offline k-anonymity for CSV, JSON and XML tables."
+readme = "README.md"
+requires-python = ">=3.10"
+license = { text = "MIT" }
+authors = [{ name = "Kai IWASAKI" }]
+dependencies = []
+
+[project.scripts]
+sieve-crowd = "sieve_crowd.cli:main"
+
+[tool.setuptools]
+packages = ["sieve_crowd"]

sieve_crowd-0.2.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

sieve_crowd-0.2.0/sieve_crowd/__init__.py

@@ -0,0 +1,16 @@
+"""Sieve Crowd: make every record one of a crowd, and measure it.
+
+Deterministic, offline, zero-dependency k-anonymity (with optional l-diversity)
+for CSV, JSON and XML tables.
+"""
+
+__version__ = "0.2.0"
+
+from .config import Config, parse_config, parse_key  # noqa: E402
+from .engine import Result, anonymize, inspect_table  # noqa: E402
+from .model import ConfigError, InputError, Role  # noqa: E402
+
+__all__ = [
+    "__version__", "anonymize", "inspect_table", "Result", "Config", "parse_config", "parse_key",
+    "ConfigError", "InputError", "Role",
+]

sieve_crowd-0.2.0/sieve_crowd/__main__.py

@@ -0,0 +1,3 @@
+from .cli import main
+
+raise SystemExit(main())

sieve_crowd-0.2.0/sieve_crowd/cli.py

@@ -0,0 +1,206 @@
+"""Command line: inspect / keygen / run.  Cell values never appear in messages or logs."""
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import secrets
+import sys
+import tempfile
+from typing import Optional, Sequence
+
+from . import __version__
+from .config import parse_config, parse_key
+from .engine import anonymize, inspect_table
+from .hints import hint
+from .model import ConfigError, InputError
+from .tableio import FORMATS, detect_format, read_any, write_any
+
+EXIT_OK, EXIT_IO, EXIT_CONFIG, EXIT_REFUSED = 0, 1, 2, 3
+
+
+def _atomic_write(path: str, data: bytes, private: bool = False) -> None:
+    directory = os.path.dirname(os.path.abspath(path))
+    fd, tmp = tempfile.mkstemp(dir=directory, prefix=".sieve-crowd-")
+    try:
+        with os.fdopen(fd, "wb") as fh:
+            fh.write(data)
+        if private:
+            os.chmod(tmp, 0o600)
+        os.replace(tmp, path)
+    except BaseException:
+        try:
+            os.unlink(tmp)
+        except OSError:
+            pass
+        raise
+
+
+def _parser() -> argparse.ArgumentParser:
+    p = argparse.ArgumentParser(prog="sieve-crowd",
+                                description="Make every record one of a crowd of at least k, and measure it.")
+    p.add_argument("--version", action="version", version=f"sieve-crowd {__version__}")
+    sub = p.add_subparsers(dest="cmd", required=True)
+
+    i = sub.add_parser("inspect", help="describe the columns of a table (csv, json or xml) and write a config template")
+    i.add_argument("input")
+    i.add_argument("--delimiter", help="CSV only")
+    i.add_argument("--in-format", choices=FORMATS,
+                   help="force the input format (default: from the file extension)")
+    i.add_argument("--lang", choices=["en", "ja"], default="en")
+    i.add_argument("--config-out", metavar="FILE", help="write a template with role '?' for every column")
+    i.add_argument("--force", action="store_true")
+
+    k = sub.add_parser("keygen", help="create a key for pseudonyms")
+    k.add_argument("-o", "--output", required=True)
+    k.add_argument("--force", action="store_true")
+
+    r = sub.add_parser("run", help="anonymize a table (csv, json or xml)")
+    r.add_argument("input")
+    r.add_argument("-c", "--config", required=True)
+    r.add_argument("-o", "--output")
+    r.add_argument("--dry-run", action="store_true", help="measure only; write no table")
+    r.add_argument("--delimiter", help="CSV only")
+    r.add_argument("--in-format", choices=FORMATS,
+                   help="force the input format (default: from the file extension)")
+    r.add_argument("--out-format", choices=FORMATS,
+                   help="force the output format (default: from the output extension)")
+    r.add_argument("--key-file")
+    r.add_argument("--k", type=int)
+    r.add_argument("--l", type=int)
+    r.add_argument("--max-suppression", type=float)
+    r.add_argument("--keep-order", action="store_true", help="relaxation: do not shuffle the rows (recorded)")
+    r.add_argument("--shuffle-seed", type=int, default=0)
+    r.add_argument("--lang", choices=["en", "ja"], default="en")
+    r.add_argument("--max-rows", type=int, default=200_000)
+    r.add_argument("--max-evals", type=int, default=20_000)
+    r.add_argument("--report-json", metavar="FILE")
+    r.add_argument("--quiet", action="store_true")
+    r.add_argument("--force", action="store_true")
+    return p
+
+
+def _read(path: str) -> bytes:
+    if path == "-":
+        return sys.stdin.buffer.read()
+    with open(path, "rb") as fh:
+        return fh.read()
+
+
+def _resolve_format(path: str, explicit: Optional[str], *, dash_default: str) -> str:
+    if explicit:
+        return explicit
+    if path == "-":
+        return dash_default
+    return detect_format(os.path.splitext(path)[1])
+
+
+def _delimiter(given: Optional[str], sides: set[str]) -> Optional[str]:
+    if given is None:
+        return None
+    if sides - {"csv"}:
+        raise InputError("--delimiter applies to csv only (the table is json/xml)")
+    return given
+
+
+def _cmd_inspect(a: argparse.Namespace) -> int:
+    try:
+        in_fmt = _resolve_format(a.input, a.in_format, dash_default="csv")
+        delim = _delimiter(a.delimiter, {in_fmt})
+        header, rows = read_any(_read(a.input), in_fmt, delim)
+    except InputError as exc:
+        print(f"error: {exc}", file=sys.stderr); return EXIT_CONFIG
+    except OSError as exc:
+        print(f"error: cannot read the input ({exc.strerror})", file=sys.stderr); return EXIT_IO
+    info = inspect_table(header, rows)
+    en = a.lang == "en"
+    print(f"records: {len(rows)}" if en else f"レコード数: {len(rows)}")
+    hints = {}
+    for c in info:
+        role, text_en, text_ja = hint(c["name"], c, len(rows))
+        hints[c["name"]] = (role, text_en if en else text_ja)
+        shown = f"  {c['name']}: {c['distinct']} distinct, {c['empty']} empty, {c['unique_ratio']:.0%} unique values, looks like {c['shape']}" \
+            if en else f"  {c['name']}: 異なる値 {c['distinct']}、空 {c['empty']}、一意な値 {c['unique_ratio']:.0%}、形は {c['shape']}"
+        print(shown)
+        if role:
+            print(f"      -> {hints[c['name']][1]}")
+    if a.config_out:
+        if os.path.exists(a.config_out) and not a.force:
+            print("error: the config file exists (use --force)", file=sys.stderr); return EXIT_IO
+        template = {"k": 5, "l": 1, "max_suppression": 0.05,
+                    "columns": {c["name"]: ({"role": "?", "_hint": hints[c["name"]][1]} if hints[c["name"]][0]
+                                    else {"role": "?"}) for c in info}}
+        try:
+            _atomic_write(a.config_out, (json.dumps(template, ensure_ascii=False, indent=2) + "\n").encode())
+        except OSError as exc:
+            print(f"error: cannot write ({exc.strerror})", file=sys.stderr); return EXIT_IO
+    return EXIT_OK
+
+
+def _cmd_keygen(a: argparse.Namespace) -> int:
+    if os.path.exists(a.output) and not a.force:
+        print("error: the key file exists (use --force)", file=sys.stderr); return EXIT_IO
+    try:
+        _atomic_write(a.output, (secrets.token_hex(32) + "\n").encode(), private=True)
+    except OSError as exc:
+        print(f"error: cannot write ({exc.strerror})", file=sys.stderr); return EXIT_IO
+    return EXIT_OK
+
+
+def _cmd_run(a: argparse.Namespace) -> int:
+    if not a.dry_run and not a.output:
+        print("error: give -o/--output or --dry-run", file=sys.stderr); return EXIT_CONFIG
+    if a.output and a.input != "-" and os.path.realpath(a.output) == os.path.realpath(a.input):
+        print("error: the output must not be the input file", file=sys.stderr); return EXIT_CONFIG
+    if a.output and os.path.exists(a.output) and not a.force:
+        print("error: output exists (use --force to replace it)", file=sys.stderr); return EXIT_IO
+    try:
+        in_fmt = _resolve_format(a.input, a.in_format, dash_default="csv")
+        out_fmt = _resolve_format(a.output, a.out_format, dash_default="csv") if a.output else None
+        delim = _delimiter(a.delimiter, {in_fmt} | (set() if out_fmt is None else {out_fmt}))
+    except InputError as exc:
+        print(f"error: {exc}", file=sys.stderr); return EXIT_CONFIG
+    try:
+        with open(a.config, "rb") as fh:
+            raw = json.loads(fh.read().decode("utf-8-sig"))
+        key = parse_key(open(a.key_file, encoding="utf-8").read()) if a.key_file else None
+        cfg = parse_config(raw, k=a.k, l=a.l, max_suppression=a.max_suppression,
+                           shuffle=not a.keep_order, shuffle_seed=a.shuffle_seed, lang=a.lang,
+                           max_rows=a.max_rows, max_evals=a.max_evals, key=key)
+    except ConfigError as exc:
+        print(f"error: {exc}", file=sys.stderr); return EXIT_CONFIG
+    except (json.JSONDecodeError, UnicodeDecodeError):
+        print("error: the configuration is not valid JSON", file=sys.stderr); return EXIT_CONFIG
+    except OSError as exc:
+        print(f"error: cannot read the configuration or key ({exc.strerror})", file=sys.stderr); return EXIT_IO
+    try:
+        header, rows = read_any(_read(a.input), in_fmt, delim)
+    except InputError as exc:
+        print(f"error: {exc}", file=sys.stderr); return EXIT_CONFIG
+    except OSError as exc:
+        print(f"error: cannot read the input ({exc.strerror})", file=sys.stderr); return EXIT_IO
+    try:
+        result = anonymize(header, rows, cfg, io=(in_fmt, out_fmt))
+    except ConfigError as exc:
+        print(f"error: {exc}", file=sys.stderr); return EXIT_CONFIG
+    if not a.quiet:
+        print(result.report.text(cfg.lang), file=sys.stderr)
+    try:
+        if a.report_json:
+            _atomic_write(a.report_json, (result.report.to_json() + "\n").encode("utf-8"))
+        if result.status == "refused":
+            return EXIT_REFUSED
+        if not a.dry_run:
+            data = write_any(result.header, result.rows, out_fmt, delim)
+            if a.output == "-":
+                sys.stdout.buffer.write(data); sys.stdout.buffer.flush()
+            else:
+                _atomic_write(a.output, data)
+    except OSError as exc:
+        print(f"error: cannot write ({exc.strerror})", file=sys.stderr); return EXIT_IO
+    return EXIT_OK
+
+
+def main(argv: Optional[Sequence[str]] = None) -> int:
+    a = _parser().parse_args(argv)
+    return {"inspect": _cmd_inspect, "keygen": _cmd_keygen, "run": _cmd_run}[a.cmd](a)