Reconcile two exports

# reconcile.py: match two CSV exports by rules you set. Python 3 only.
#   python3 reconcile.py profile   row count, total, dates and first rows of each file
#   python3 reconcile.py run       writes matched.csv, only_a.csv and only_b.csv
import csv, sys
from datetime import datetime
from decimal import Decimal, InvalidOperation

RULES = {
    "a": {"file": "a.csv", "date": "Date", "amount": "Amount", "text": "Description",
          "date_format": "%d/%m/%Y", "flip_sign": False, "decimal_comma": False},
    "b": {"file": "b.csv", "date": "Date", "amount": "Total", "text": "Contact",
          "date_format": "%Y-%m-%d", "flip_sign": False, "decimal_comma": False},
    "days": 3,               # dates may be this many days apart
    "tolerance": "0.00",     # amounts may differ by this much
}

def stop(msg):
    sys.exit("STOP: " + msg)

def money(text, decimal_comma):
    s = text.strip()
    for ch in " $£€¥":
        s = s.replace(ch, "")
    neg = s.startswith("(") and s.endswith(")")  # (63.50) means -63.50
    s = s.strip("()")
    s = s.replace(".", "").replace(",", ".") if decimal_comma else s.replace(",", "")
    try:
        v = Decimal(s)
    except InvalidOperation:
        stop(f"cannot read amount {text!r}; check the amount column and decimal_comma")
    return -v if neg else v

def load(side):
    r = RULES[side]
    rows = []
    with open(r["file"], newline="", encoding="utf-8-sig") as fh:
        reader = csv.DictReader(fh)
        for col in (r["date"], r["amount"]):
            if col not in (reader.fieldnames or []):
                stop(f"{r['file']} has no column {col!r}; it has {reader.fieldnames}")
        for rec in reader:
            if not any(isinstance(v, str) and v.strip() for v in rec.values()):
                continue  # a line of empty cells
            line = reader.line_num  # the line in the file, so you can find the row
            try:
                day = datetime.strptime((rec[r["date"]] or "").strip(), r["date_format"]).date()
            except ValueError:
                stop(f"{r['file']} line {line}: date {rec[r['date']]!r} does not fit {r['date_format']}")
            amt = money(rec[r["amount"]] or "", r["decimal_comma"])
            text = (rec.get(r["text"]) or "").strip() if r["text"] else ""
            rows.append({"line": line, "date": day, "text": text,
                         "amount": -amt if r["flip_sign"] else amt})
    if not rows:
        stop(f"{r['file']} has no rows")
    return rows

def total(rows):
    return sum((x["amount"] for x in rows), Decimal(0))

def profile():
    for side in ("a", "b"):
        r, rows = RULES[side], load(side)
        print(f"== {side.upper()}: {r['file']}")
        print(f"rows {len(rows)} | total {total(rows)} | dates "
              f"{min(x['date'] for x in rows)} to {max(x['date'] for x in rows)}")
        with open(r["file"], newline="", encoding="utf-8-sig") as fh:
            for i, row in zip(range(6), csv.reader(fh)):
                print("  ", row)

def run():
    a, b = load("a"), load("b")
    tol = Decimal(RULES["tolerance"])
    free, matched = list(b), []
    for x in sorted(a, key=lambda r: (r["date"], r["line"])):
        fits = [y for y in free if abs((x["date"] - y["date"]).days) <= RULES["days"]
                and abs(x["amount"] - y["amount"]) <= tol]
        if fits:  # take the closest date, then the closest amount
            y = min(fits, key=lambda y: (abs((x["date"] - y["date"]).days),
                                         abs(x["amount"] - y["amount"]), y["line"]))
            free = [z for z in free if z is not y]
            matched.append((x, y))
    used_a = {x["line"] for x, _ in matched}
    only_a = [x for x in a if x["line"] not in used_a]
    only_b = free
    m_a, m_b = total([x for x, _ in matched]), total([y for _, y in matched])

    # Tie-out: stop rather than write anything if a row was lost or used twice.
    if len(used_a) != len(matched) or len({y["line"] for _, y in matched}) != len(matched):
        stop("a row was matched twice")
    if len(matched) + len(only_a) != len(a) or len(matched) + len(only_b) != len(b):
        stop("rows do not add up")
    if m_a + total(only_a) != total(a) or m_b + total(only_b) != total(b):
        stop("totals do not tie")
    if abs(m_a - m_b) > tol * len(matched):
        stop("matched amounts differ by more than the tolerance")

    with open("matched.csv", "w", newline="", encoding="utf-8") as fh:
        w = csv.writer(fh)
        w.writerow(["a_line", "b_line", "a_date", "b_date", "days_apart",
                    "a_amount", "b_amount", "a_text", "b_text"])
        for x, y in matched:
            w.writerow([x["line"], y["line"], x["date"], y["date"], abs((x["date"] - y["date"]).days),
                        x["amount"], y["amount"], x["text"], y["text"]])
    for name, rows in (("only_a.csv", only_a), ("only_b.csv", only_b)):
        with open(name, "w", newline="", encoding="utf-8") as fh:
            w = csv.writer(fh)
            w.writerow(["line", "date", "amount", "text", "label"])
            for x in rows:
                w.writerow([x["line"], x["date"], x["amount"], x["text"], ""])
    print(f"A: {len(a)} rows, total {total(a)} | B: {len(b)} rows, total {total(b)}")
    print(f"matched {len(matched)} | only in A {len(only_a)} ({total(only_a)}) | "
          f"only in B {len(only_b)} ({total(only_b)})")
    print(f"difference A - B = {total(a) - total(b)} = only-A {total(only_a)} "
          f"- only-B {total(only_b)} + matched gap {m_a - m_b}")
    print("tie-out ok")

if __name__ == "__main__":
    if sys.argv[1:] == ["profile"]:
        profile()
    elif sys.argv[1:] == ["run"]:
        run()
    else:
        sys.exit("Usage: python3 reconcile.py profile | run")

I need to reconcile two CSV exports with a Python script. For each file its settings are: date column, amount column, text column, date_format (Python strptime), flip_sign, decimal_comma. Shared settings: days (date tolerance) and tolerance (amount tolerance).
Here is a profile of each file: row count, total, date range and the first rows.
<PROFILE>
A is <WHAT_A_IS>. B is <WHAT_B_IS>.
Propose a value for each setting, with one line on why. Then list what you cannot tell from the samples as questions for me: fees, split payments, refunds, pending items, or a different date basis such as posting date against transaction date. Do not write code.

These rows did not match between A (<WHAT_A_IS>) and B (<WHAT_B_IS>). Matching rules: dates within <DAYS> days, amounts within <TOLERANCE>.
only_a.csv:
<ONLY_A>
only_b.csv:
<ONLY_B>
For each row give: file | line | label | one-line reason.
Use only these labels: timing (will appear next period), fee, duplicate, split (one row in one file is several in the other), missing (recorded in one place only), amount error, unknown.
Use "unknown" when you are not sure. Do not guess. Point out any pair of leftovers, one from each file, that look like the same item.

A: 7 rows, total 3142.75 | B: 6 rows, total 3156.76
matched 5 | only in A 2 (-47.00) | only in B 1 (-32.99)
difference A - B = -14.01 = only-A -47.00 - only-B -32.99 + matched gap 0.00
tie-out ok