| """Content generators for documents that are not IRS forms. |
| |
| Each generator returns ``(items, sub_kind)`` for ``render.render``. Statement |
| kinds deliberately reuse tax-form vocabulary (a mortgage statement shows |
| interest paid year to date and says the Form 1098 is coming; a final paystub |
| shows year-to-date wages) because that overlap is exactly where the v1.0 head |
| failed. The label is what the document is, not which forms it mentions. |
| """ |
|
|
| from __future__ import annotations |
|
|
| import random |
|
|
| from render import address, date, ein, masked, money, person |
| from specs import (BANKS, BROKERS, BUSINESSES, CARD_ISSUERS, CARD_PRODUCTS, CHARITIES, CITIES, CLINICS, COUNTIES, |
| EMPLOYERS, EXCHANGES, HSA_TRUSTEES, INSURERS, LENDERS, MAKES, OTHER_TAX_FORMS, RETIREMENT_ADMINS, |
| SCHOOLS, SECURITIES, SERVICERS, STORES, TELCOS, UNKNOWN_KINDS, UTILITIES) |
|
|
| MERCHANTS = ["WHOLE FOODS #1021", "SHELL OIL 5741", "AMAZON MKTPLACE", "NETFLIX.COM", "TARGET T-2231", "UBER TRIP", |
| "COSTCO WHSE #412", "CVS/PHARMACY 0832", "DELTA AIR LINES", "STARBUCKS #11872", "HOME DEPOT 0612"] |
|
|
|
|
| def _period(rng: random.Random, year: int) -> tuple[str, str]: |
| m = rng.randint(1, 12) |
| return f"{m:02d}/01/{year}", f"{m:02d}/{rng.choice([28, 30, 31]) if m != 2 else 28}/{year}" |
|
|
|
|
| def _txns(rng: random.Random, year: int, n: int, signed: bool = True) -> list[list[str]]: |
| rows = [] |
| for _ in range(n): |
| amount = rng.uniform(4, 900) |
| sign = "-" if signed and rng.random() < 0.8 else "" |
| rows.append([f"{rng.randint(1, 12):02d}/{rng.randint(1, 28):02d}", rng.choice(MERCHANTS), f"{sign}{amount:,.2f}"]) |
| return rows |
|
|
|
|
| def _mention(rng: random.Random, form: str, year: int, p: float = 0.45) -> list[tuple]: |
| """Statements often announce a tax form; that does not make them the form.""" |
| if rng.random() > p: |
| return [] |
| return [("line", rng.choice([ |
| f"Your {year} Form {form} will be available online by January 31, {year + 1}.", |
| f"Tax reminder: amounts on this statement may differ from your Form {form}.", |
| f"This statement is not a Form {form}. Keep it for your records.", |
| f"IRS Form {form} information for {year} will be mailed separately.", |
| ]))] |
|
|
|
|
| def bank_statement(rng: random.Random, year: int) -> tuple[list[tuple], str]: |
| bank = rng.choice(BANKS) |
| kind = rng.choice(["checking", "savings", "money_market", "year_end"]) |
| start, end = _period(rng, year) |
| begin = rng.uniform(200, 60000) |
| items: list[tuple] = [("line", bank), ("title", {"checking": "Checking Account Statement", "savings": "Savings Statement", |
| "money_market": "Money Market Account Statement", |
| "year_end": f"{year} Year-End Account Summary"}[kind])] |
| items += [("kv", "Account number", masked(rng, 4)), ("kv", "Statement period", f"{start} - {end}"), |
| ("line", person(rng)), ("line", " ".join(address(rng)))] |
| deposits, withdrawals = rng.uniform(100, 9000), rng.uniform(50, 8000) |
| items += [("line", "Account summary"), ("kv", "Beginning balance", f"${begin:,.2f}"), |
| ("kv", "Deposits and other credits", f"${deposits:,.2f}"), |
| ("kv", "Withdrawals and other debits", f"-${withdrawals:,.2f}"), |
| ("kv", "Ending balance", f"${max(0.0, begin + deposits - withdrawals):,.2f}")] |
| if kind != "checking" or rng.random() < 0.4: |
| items += [("kv", "Interest paid this period", money(rng, 0.01, 60)), |
| ("kv", "Interest paid year-to-date", money(rng, 1, 900)), |
| ("kv", "Annual percentage yield earned", f"{rng.uniform(0.01, 4.8):.2f}%")] |
| if kind != "year_end": |
| items.append(("table", ["Date", "Description", "Amount"], _txns(rng, year, rng.randint(3, 7)))) |
| items += _mention(rng, "1099-INT", year) |
| items.append(("line", rng.choice(["Member FDIC", "Federally insured by NCUA", "Equal Housing Lender"]))) |
| return items, kind |
|
|
|
|
| def credit_card_statement(rng: random.Random, year: int) -> tuple[list[tuple], str]: |
| kind = rng.choice(["monthly", "monthly", "year_end_summary"]) |
| items: list[tuple] = [("line", rng.choice(CARD_ISSUERS)), ("title", rng.choice(CARD_PRODUCTS))] |
| if kind == "year_end_summary": |
| items.append(("title", f"{year} Year-End Summary")) |
| cats = ["Dining", "Groceries", "Travel", "Gas", "Merchandise", "Services"] |
| items.append(("table", ["Category", "Transactions", "Total"], |
| [[c, str(rng.randint(2, 90)), f"{rng.uniform(80, 9000):,.2f}"] for c in rng.sample(cats, 4)])) |
| items.append(("kv", "Total purchases this year", money(rng, 4000, 60000))) |
| items.append(("kv", "Total interest charged this year", money(rng, 0, 900))) |
| items.append(("line", "This summary is provided for your records and is not a tax form.")) |
| else: |
| prev = rng.uniform(0, 8000) |
| items += [("kv", "Account ending in", masked(rng, 4)[-4:]), |
| ("kv", "Opening/Closing Date", " - ".join(_period(rng, year))), |
| ("line", "Account Summary"), ("kv", "Previous Balance", f"${prev:,.2f}"), |
| ("kv", "Payments, Credits", f"-${prev:,.2f}"), ("kv", "Purchases", money(rng, 50, 5000, 1)), |
| ("kv", "Fees Charged", "$0.00"), ("kv", "Interest Charged", money(rng, 0, 120, 1)), |
| ("kv", "New Balance", money(rng, 50, 6000, 1)), ("kv", "Minimum Payment Due", money(rng, 25, 200, 1)), |
| ("kv", "Payment Due Date", date(rng, year)), |
| ("kv", "Purchase APR", f"{rng.uniform(17, 29.9):.2f}%")] |
| items.append(("table", ["Trans Date", "Description", "Amount"], _txns(rng, year, rng.randint(3, 7), signed=False))) |
| if rng.random() < 0.5: |
| items.append(("line", "Late Payment Warning: If we do not receive your minimum payment by the date listed above, you may have to pay a late fee.")) |
| return items, kind |
|
|
|
|
| def mortgage_statement(rng: random.Random, year: int) -> tuple[list[tuple], str]: |
| kind = rng.choice(["monthly", "monthly", "monthly", "escrow_analysis", "payoff"]) |
| servicer = rng.choice(SERVICERS) |
| principal = rng.uniform(90000, 640000) |
| items: list[tuple] = [("line", servicer)] |
| street, city = address(rng) |
| if kind == "escrow_analysis": |
| items += [("title", "Annual Escrow Account Disclosure Statement"), ("kv", "Loan number", masked(rng, 6)), |
| ("kv", "Property address", f"{street} {city}"), |
| ("kv", "Projected property taxes", money(rng, 1500, 14000)), |
| ("kv", "Projected homeowners insurance", money(rng, 700, 4200)), |
| ("kv", "Escrow shortage", money(rng, 0, 1200)), |
| ("kv", "New monthly escrow payment", money(rng, 150, 1500)), |
| ("kv", "New total monthly payment effective", date(rng, year + 1))] |
| elif kind == "payoff": |
| items += [("title", "Mortgage Payoff Statement"), ("kv", "Loan number", masked(rng, 6)), |
| ("kv", "Good through date", date(rng, year)), ("kv", "Unpaid principal balance", f"${principal:,.2f}"), |
| ("kv", "Interest from last paid date", money(rng, 200, 2200)), ("kv", "Recording fee", "$45.00"), |
| ("kv", "Total amount to pay off loan", f"${principal + rng.uniform(300, 2500):,.2f}")] |
| else: |
| interest = rng.uniform(250, 3200) |
| items += [("title", rng.choice(["Mortgage Statement", "Monthly Mortgage Statement", "Home Loan Statement"])), |
| ("kv", "Statement date", date(rng, year)), ("kv", "Loan number", masked(rng, 6)), |
| ("kv", "Property address", f"{street} {city}"), ("kv", "Payment due date", date(rng, year)), |
| ("kv", "Amount due", money(rng, 900, 5200, 1)), ("line", "Explanation of amount due"), |
| ("kv", "Principal", money(rng, 200, 2500)), ("kv", "Interest", f"{interest:,.2f}"), |
| ("kv", "Escrow (for taxes and insurance)", money(rng, 150, 1500)), |
| ("kv", "Regular monthly payment", money(rng, 900, 5200)), |
| ("line", "Past payments breakdown Paid last month Paid year to date"), |
| ("kv", "Interest paid year to date", f"{interest * rng.randint(2, 12):,.2f}"), |
| ("kv", "Outstanding principal", f"${principal:,.2f}"), |
| ("kv", "Escrow balance", money(rng, 200, 6000, 1)), |
| ("kv", "Interest rate", f"{rng.uniform(2.5, 7.9):.3f}%")] |
| if rng.random() < 0.5: |
| items.append(("line", "If you are experiencing financial difficulty, call a HUD-approved housing counselor.")) |
| if rng.random() < 0.3: |
| items.append(("line", "Late fee of $75.00 will be charged if payment is received after the 16th.")) |
| items += _mention(rng, "1098", year, 0.55) |
| items.append(("line", "This is an attempt to collect a debt. NMLS ID " + str(rng.randint(1000, 999999)))) |
| return items, kind |
|
|
|
|
| def loan_statement(rng: random.Random, year: int) -> tuple[list[tuple], str]: |
| kind = rng.choice(["auto", "student", "personal", "heloc"]) |
| lender = rng.choice(LENDERS) |
| title = rng.choice({"auto": ["Auto Loan Statement", "Vehicle Loan Billing Statement", "Your auto loan bill"], |
| "student": ["Student Loan Statement", "Your monthly student loan bill", "Billing Statement - Student Loans"], |
| "personal": ["Personal Loan Statement", "Installment Loan Statement", "Your loan bill"], |
| "heloc": ["Home Equity Line of Credit Statement", "HELOC Billing Statement"]}[kind]) |
| balance = rng.uniform(0, 90000) if rng.random() > 0.1 else 0.0 |
| items: list[tuple] = [("line", lender), ("title", title), ("kv", "Account number", masked(rng, 6)), |
| ("kv", "Statement period", " - ".join(_period(rng, year))), |
| ("kv", rng.choice(["Principal balance", "Outstanding principal", "Current principal", "Unpaid principal balance", "Remaining balance"]), f"${balance:,.2f}"), |
| ("kv", rng.choice(["Interest rate", "APR", "Fixed rate"]), f"{rng.uniform(2.9, 13.9):.2f}%"), |
| ("kv", rng.choice(["Payment due", "Current amount due", "Amount due", "Monthly payment"]), money(rng, 80, 1400, 1)), |
| ("kv", rng.choice(["Due date", "Payment due date", "Due by"]), date(rng, year))] |
| if kind == "auto": |
| make, model = rng.choice(MAKES) |
| items += [("kv", "Vehicle", f"{year - rng.randint(0, 5)} {make} {model}"), |
| ("kv", "Payments remaining", str(rng.randint(0, 60)))] |
| if kind == "student": |
| items += [("kv", "Loan type", rng.choice(["Direct Subsidized", "Direct Unsubsidized", "Private refinance"])), |
| ("kv", "Interest paid this year", money(rng, 50, 2500)), |
| ("kv", "Repayment plan", rng.choice(["Standard", "Income-Driven Repayment", "Graduated"]))] |
| items += _mention(rng, "1098-E", year, 0.6) |
| if kind == "heloc": |
| items += [("kv", "Credit limit", money(rng, 20000, 150000)), ("kv", "Available credit", money(rng, 1000, 80000))] |
| items += _mention(rng, "1098", year) |
| if balance == 0.0: |
| items.append(("line", "Loan status: Paid in full")) |
| return items, kind |
|
|
|
|
| def brokerage_statement(rng: random.Random, year: int) -> tuple[list[tuple], str]: |
| kind = rng.choice(["monthly", "quarterly", "holdings_export"]) |
| items: list[tuple] = [("line", rng.choice(BROKERS))] |
| items.append(("title", {"monthly": "Investment Report", "quarterly": "Quarterly Account Statement", |
| "holdings_export": "Positions"}[kind])) |
| items += [("kv", "Account", rng.choice(["Individual Brokerage Account", "Joint WROS", "Individual - TOD"]) + " " + masked(rng, 4)), |
| ("kv", "Statement period", " - ".join(_period(rng, year)))] |
| begin = rng.uniform(1000, 900000) |
| if kind != "holdings_export": |
| items += [("kv", "Beginning account value", f"${begin:,.2f}"), |
| ("kv", "Ending account value", f"${begin * rng.uniform(0.9, 1.12):,.2f}"), |
| ("line", "Income summary This period Year to date"), |
| ("kv", "Dividends", f"{rng.uniform(0, 900):,.2f} {rng.uniform(100, 8000):,.2f}"), |
| ("kv", "Interest", f"{rng.uniform(0, 90):,.2f} {rng.uniform(1, 600):,.2f}"), |
| ("kv", "Realized gain/loss", f"{rng.uniform(-3000, 9000):,.2f}")] |
| rows = [] |
| for sym in rng.sample(SECURITIES[:6] + ["SCHB", "IVV", "QQQ"], 4): |
| qty = rng.uniform(1, 400) |
| price = rng.uniform(20, 500) |
| rows.append([sym, f"{qty:,.3f}", f"{price:,.2f}", f"{qty * price:,.2f}", f"{rng.uniform(-2000, 9000):,.2f}"]) |
| items.append(("table", ["Symbol", "Quantity", "Last Price", "Current Value", "Total Gain/Loss"], rows)) |
| items += _mention(rng, "1099", year, 0.5) |
| if rng.random() < 0.5: |
| items.append(("line", "Securities offered through a member of FINRA/SIPC. Not FDIC insured.")) |
| return items, kind |
|
|
|
|
| def retirement_statement(rng: random.Random, year: int) -> tuple[list[tuple], str]: |
| kind = rng.choice(["401k_quarterly", "ira_statement", "403b_annual"]) |
| admin = rng.choice(RETIREMENT_ADMINS) |
| plan = f"{rng.choice(EMPLOYERS)} {'401(k) Savings Plan' if kind != '403b_annual' else '403(b) Plan'}" |
| items: list[tuple] = [("line", admin)] |
| if kind == "ira_statement": |
| items += [("title", rng.choice(["Traditional IRA Statement", "Roth IRA Statement", "Rollover IRA Statement"])), |
| ("kv", "Account", masked(rng, 4)), ("kv", "Statement period", " - ".join(_period(rng, year))), |
| ("kv", f"{year} contributions", money(rng, 0, 7000)), |
| ("kv", f"{year - 1} contributions made in {year}", money(rng, 0, 7000)), |
| ("kv", "Account value", money(rng, 3000, 600000)), |
| ("kv", "Required minimum distribution for " + str(year), rng.choice(["Not applicable", money(rng, 1000, 30000)]))] |
| items += _mention(rng, "5498", year, 0.5) |
| else: |
| items += [("title", "Retirement Account Statement" if kind == "401k_quarterly" else "Annual Benefit Statement"), |
| ("kv", "Plan", plan), ("kv", "Participant", person(rng)), |
| ("kv", "Statement period", " - ".join(_period(rng, year))), |
| ("kv", "Beginning balance", money(rng, 1000, 500000)), |
| ("kv", "Employee contributions (pre-tax)", money(rng, 300, 23000)), |
| ("kv", "Roth contributions", money(rng, 0, 5000)), |
| ("kv", "Employer match", money(rng, 100, 9000)), |
| ("kv", "Investment gain/loss", f"{rng.uniform(-20000, 60000):,.2f}"), |
| ("kv", "Ending balance", money(rng, 1000, 600000)), |
| ("kv", "Vested balance", money(rng, 1000, 600000)), |
| ("kv", "Personal rate of return", f"{rng.uniform(-8, 22):.1f}%")] |
| funds = ["Target Retirement 2050 Fund", "S&P 500 Index Fund", "Stable Value Fund", "Total Bond Index"] |
| items.append(("table", ["Investment", "Allocation", "Balance"], |
| [[f, f"{rng.randint(5, 80)}%", f"{rng.uniform(500, 200000):,.2f}"] for f in rng.sample(funds, 3)])) |
| items += _mention(rng, "1099-R", year, 0.25) |
| return items, kind |
|
|
|
|
| def hsa_statement(rng: random.Random, year: int) -> tuple[list[tuple], str]: |
| kind = rng.choice(["monthly", "transaction_export", "annual_summary"]) |
| items: list[tuple] = [("line", rng.choice(HSA_TRUSTEES)), |
| ("title", {"monthly": "Health Savings Account Statement", "transaction_export": "HSA Transaction History", |
| "annual_summary": f"{year} HSA Annual Summary"}[kind]), |
| ("kv", "Account holder", person(rng)), ("kv", "Account number", masked(rng, 4))] |
| if kind != "transaction_export": |
| items += [("kv", "Cash balance", money(rng, 100, 9000)), ("kv", "Invested balance", money(rng, 0, 40000)), |
| ("kv", "Employer contributions", money(rng, 0, 1500)), ("kv", "Employee contributions", money(rng, 100, 4300)), |
| ("kv", "Distributions / claims paid", money(rng, 0, 4000)), ("kv", "Interest and earnings", money(rng, 0, 900))] |
| rows = [] |
| for _ in range(rng.randint(3, 6)): |
| desc, sign = rng.choice([("Payroll contribution", ""), ("Employer contribution", ""), |
| ("Card purchase CVS/PHARMACY", "-"), ("Claim reimbursement - Sample Family Clinic", "-"), |
| ("Interest", ""), ("Card purchase Brightsmile Dental", "-")]) |
| rows.append([date(rng, year), desc, f"{sign}{rng.uniform(5, 800):,.2f}"]) |
| items.append(("table", ["Date", "Description", "Amount"], rows)) |
| items += _mention(rng, rng.choice(["5498-SA", "1099-SA"]), year, 0.4) |
| return items, kind |
|
|
|
|
| def paystub(rng: random.Random, year: int) -> tuple[list[tuple], str]: |
| kind = rng.choice(["biweekly", "biweekly", "semimonthly", "final_of_year"]) |
| employer = rng.choice(EMPLOYERS) |
| rate = rng.uniform(16, 95) |
| hours = rng.choice([80, 86.67, 40, 75]) |
| gross = rate * hours |
| periods = 26 if kind != "final_of_year" else 26 |
| ytd_mult = periods if kind == "final_of_year" else rng.randint(2, 24) |
| items: list[tuple] = [("line", employer), ("line", " ".join(address(rng))), |
| ("title", rng.choice(["Earnings Statement", "Pay Statement", "Payroll Advice", "Statement of Earnings and Deductions"]))] |
| start, end = _period(rng, year) |
| items += [("kv", "Employee", person(rng)), ("kv", "Employee ID", str(rng.randint(10000, 99999))), |
| ("kv", "Pay period", f"{start} - {end}"), |
| ("kv", "Pay date", f"12/31/{year}" if kind == "final_of_year" else date(rng, year))] |
| items.append(("table", ["Earnings", "Rate", "Hours", "Current", "YTD"], |
| [["Regular", f"{rate:.2f}", f"{hours:.2f}", f"{gross:,.2f}", f"{gross * ytd_mult:,.2f}"], |
| ["Overtime", f"{rate * 1.5:.2f}", f"{rng.randint(0, 9):.2f}", f"{rng.uniform(0, 600):,.2f}", f"{rng.uniform(0, 9000):,.2f}"]])) |
| ded = [("Federal Income Tax", 0.11), ("Social Security", 0.062), ("Medicare", 0.0145), ("State Income Tax", 0.04), |
| ("401(k)", 0.06), ("Medical Pre-Tax", 0.03)] |
| items.append(("table", ["Deductions", "Current", "YTD"], |
| [[n, f"{gross * r:,.2f}", f"{gross * r * ytd_mult:,.2f}"] for n, r in ded if rng.random() < 0.9])) |
| items += [("kv", "Gross pay", f"{gross:,.2f}"), ("kv", "Net pay", f"{gross * 0.68:,.2f}"), |
| ("kv", "Direct deposit to checking", masked(rng, 4))] |
| if kind == "final_of_year" and rng.random() < 0.6: |
| items.append(("line", f"Your {year} Form W-2 will be available in the employee portal by January 31.")) |
| return items, kind |
|
|
|
|
| def insurance_document(rng: random.Random, year: int) -> tuple[list[tuple], str]: |
| kind = rng.choice(["auto_declarations", "home_declarations", "eob", "life_annual", "premium_notice"]) |
| insurer = rng.choice(INSURERS) |
| items: list[tuple] = [("line", insurer)] |
| if kind == "auto_declarations": |
| make, model = rng.choice(MAKES) |
| items += [("title", "Auto Policy Declarations"), ("kv", "Policy number", f"PA-{rng.randint(100000, 999999)}"), |
| ("kv", "Policy period", f"{date(rng, year)} to {date(rng, year + 1)}"), |
| ("kv", "Named insured", person(rng)), ("kv", "Vehicle", f"{year - rng.randint(0, 9)} {make} {model}"), |
| ("kv", "Bodily injury liability", "$100,000 / $300,000"), ("kv", "Collision deductible", "$500"), |
| ("kv", "Six-month premium", money(rng, 300, 1900, 1))] |
| elif kind == "home_declarations": |
| items += [("title", "Homeowners Policy Declarations"), ("kv", "Policy number", f"HO-{rng.randint(100000, 999999)}"), |
| ("kv", "Residence premises", " ".join(address(rng))), ("kv", "Coverage A - Dwelling", money(rng, 150000, 900000, 1)), |
| ("kv", "Coverage E - Personal liability", "$300,000"), ("kv", "All other perils deductible", "$1,000"), |
| ("kv", "Annual premium", money(rng, 700, 5200, 1)), ("kv", "Mortgagee", rng.choice(SERVICERS))] |
| elif kind == "eob": |
| items += [("title", "Explanation of Benefits"), ("line", "THIS IS NOT A BILL"), ("kv", "Member", person(rng)), |
| ("kv", "Claim number", str(rng.randint(10 ** 9, 10 ** 10))), ("kv", "Provider", rng.choice(CLINICS)), |
| ("kv", "Date of service", date(rng, year))] |
| billed = rng.uniform(90, 4000) |
| items.append(("table", ["Amount billed", "Plan discount", "Plan paid", "You may owe"], |
| [[f"{billed:,.2f}", f"{billed * 0.3:,.2f}", f"{billed * 0.5:,.2f}", f"{billed * 0.2:,.2f}"]])) |
| items.append(("kv", "Deductible met year to date", money(rng, 0, 3000, 1))) |
| elif kind == "life_annual": |
| items += [("title", "Annual Policy Statement - Universal Life"), ("kv", "Policy number", f"UL{rng.randint(10 ** 6, 10 ** 7)}"), |
| ("kv", "Insured", person(rng)), ("kv", "Death benefit", money(rng, 50000, 1000000, 1)), |
| ("kv", "Premiums paid this year", money(rng, 300, 9000, 1)), ("kv", "Cash value", money(rng, 0, 90000, 1)), |
| ("kv", "Cost of insurance charges", money(rng, 100, 3000, 1))] |
| else: |
| items += [("title", "Premium Due Notice"), ("kv", "Policy number", f"{rng.randint(10 ** 7, 10 ** 8)}"), |
| ("kv", "Policyholder", person(rng)), ("kv", "Amount due", money(rng, 80, 2400, 1)), |
| ("kv", "Due date", date(rng, year)), ("line", "Pay online to avoid a lapse in coverage.")] |
| if rng.random() < 0.3: |
| items.append(("line", "Health coverage information forms (1095) are issued separately when required.")) |
| return items, kind |
|
|
|
|
| def crypto_tax_report(rng: random.Random, year: int) -> tuple[list[tuple], str]: |
| kind = rng.choice(["gain_loss", "transaction_history", "tax_software_summary"]) |
| source = rng.choice(EXCHANGES + ["CoinLedger-style report", "TaxBit-style report"]) |
| items: list[tuple] = [("line", source), |
| ("title", {"gain_loss": f"{year} Realized Gains and Losses Report", |
| "transaction_history": "Crypto Transaction History Export", |
| "tax_software_summary": f"{year} Crypto Tax Summary"}[kind])] |
| items += [("kv", "Account", person(rng)), ("kv", "Cost basis method", rng.choice(["FIFO", "HIFO", "Specific ID"]))] |
| if kind != "transaction_history": |
| items += [("kv", "Short-term realized gain/loss", f"{rng.uniform(-9000, 20000):,.2f}"), |
| ("kv", "Long-term realized gain/loss", f"{rng.uniform(-9000, 40000):,.2f}"), |
| ("kv", "Staking and other income", money(rng, 0, 3000))] |
| rows = [] |
| for _ in range(rng.randint(3, 6)): |
| coin = rng.choice(["BTC", "ETH", "SOL", "USDC", "ADA"]) |
| proceeds = rng.uniform(20, 20000) |
| rows.append([coin, f"{rng.uniform(0.001, 30):.6f}", date(rng, year - rng.randint(0, 2)), date(rng, year), |
| f"{proceeds:,.2f}", f"{proceeds * rng.uniform(0.5, 1.4):,.2f}"]) |
| items.append(("table", ["Asset", "Amount", "Date Acquired", "Date Sold", "Proceeds", "Cost Basis"], rows)) |
| items.append(("line", rng.choice([ |
| "This report is for informational purposes and is not an IRS form.", |
| "Use this report to prepare Form 8949; it is not a Form 1099-DA.", |
| "Generated by tax software from your exchange history.", |
| ]))) |
| return items, kind |
|
|
|
|
| def property_tax_bill(rng: random.Random, year: int) -> tuple[list[tuple], str]: |
| kind = rng.choice(["annual_bill", "installment_notice", "paid_receipt"]) |
| items: list[tuple] = [("line", rng.choice(COUNTIES)), |
| ("title", {"annual_bill": f"{year} Real Estate Property Tax Bill", |
| "installment_notice": "Second Installment Property Tax Notice", |
| "paid_receipt": "Property Tax Payment Receipt"}[kind]), |
| ("kv", "Parcel number", f"{rng.randint(10, 99)}-{rng.randint(10, 99)}-{rng.randint(100, 999)}-{rng.randint(10, 99)}"), |
| ("kv", "Property location", " ".join(address(rng))), ("kv", "Owner", person(rng)), |
| ("kv", "Assessed value", money(rng, 60000, 700000, 1)), |
| ("kv", "Homestead exemption", money(rng, 0, 10000, 1)), |
| ("kv", "Tax rate", f"{rng.uniform(1.1, 9.8):.4f}%")] |
| items.append(("table", ["Taxing district", "Amount"], |
| [[d, f"{rng.uniform(100, 5000):,.2f}"] for d in rng.sample( |
| ["County General", "School District 204", "City of Testville", "Park District", "Library District", |
| "Community College 502"], 4)])) |
| total = rng.uniform(1200, 16000) |
| items += [("kv", "Total tax", f"${total:,.2f}"), ("kv", "First installment due", date(rng, year)), |
| ("kv", "Second installment due", date(rng, year))] |
| if kind == "paid_receipt": |
| items.append(("kv", "Amount paid", f"${total / 2:,.2f}")) |
| if rng.random() < 0.4: |
| items.append(("line", "If your taxes are paid through an escrow account, forward this bill to your mortgage company.")) |
| return items, kind |
|
|
|
|
| def profit_and_loss(rng: random.Random, year: int) -> tuple[list[tuple], str]: |
| kind = rng.choice(["annual", "monthly", "cash_basis"]) |
| business = rng.choice(BUSINESSES) |
| items: list[tuple] = [("line", business), ("title", rng.choice(["Profit and Loss", "Profit & Loss Statement", "Income Statement"])), |
| ("line", f"January - December {year}" if kind != "monthly" else f"{rng.choice(['March', 'June', 'October'])} {year}"), |
| ("line", "Cash Basis" if kind == "cash_basis" else "Accrual Basis")] |
| sales = rng.uniform(20000, 600000) |
| cogs = sales * rng.uniform(0.1, 0.5) |
| exp = [("Advertising & Marketing", 0.03), ("Contract Labor", 0.08), ("Insurance", 0.02), ("Office Supplies", 0.01), |
| ("Rent or Lease", 0.06), ("Software Subscriptions", 0.01), ("Travel", 0.02), ("Utilities", 0.01)] |
| rows = [[n, f"{sales * r * rng.uniform(0.5, 1.5):,.2f}"] for n, r in exp if rng.random() < 0.8] |
| total_exp = sum(float(r[1].replace(",", "")) for r in rows) |
| items += [("line", "Income"), ("kv", "Sales", f"{sales:,.2f}"), ("kv", "Total Income", f"{sales:,.2f}"), |
| ("kv", "Cost of Goods Sold", f"{cogs:,.2f}"), ("kv", "Gross Profit", f"{sales - cogs:,.2f}"), |
| ("table", ["Expenses", "Total"], rows), ("kv", "Total Expenses", f"{total_exp:,.2f}"), |
| ("kv", "Net Operating Income", f"{sales - cogs - total_exp:,.2f}"), |
| ("kv", "Net Income", f"{sales - cogs - total_exp:,.2f}")] |
| return items, kind |
|
|
|
|
| def consolidated_1099(rng: random.Random, year: int) -> tuple[list[tuple], str]: |
| kind = rng.choice(["summary_page", "div_int_detail", "b_detail"]) |
| broker = rng.choice(BROKERS) |
| items: list[tuple] = [("line", broker), ("title", rng.choice([f"{year} Consolidated Form 1099", "Tax Reporting Statement", |
| f"{year} Tax Information Statement", |
| "Form 1099 Composite & Year-End Summary"])), |
| ("kv", "Account", masked(rng, 4)), ("kv", "Recipient", person(rng)), |
| ("kv", "Payer's Federal ID number", ein(rng)), ("line", "Copy B for Recipient OMB No. 1545-0715"), |
| ("line", f"Page {rng.randint(1, 3)} of {rng.randint(8, 30)}")] |
| if kind in ("summary_page", "div_int_detail"): |
| items += [("line", "1099-DIV Dividends and Distributions"), ("kv", "1a Total ordinary dividends", money(rng, 10, 9000, 0)), |
| ("kv", "1b Qualified dividends", money(rng, 10, 8000, 0)), ("kv", "2a Total capital gain distributions", money(rng, 0, 3000, 0)), |
| ("line", "1099-INT Interest Income"), ("kv", "1 Interest income", money(rng, 0, 900, 0)), |
| ("line", "1099-MISC Miscellaneous Information"), ("kv", "3 Other income", money(rng, 0, 200, 0))] |
| if kind in ("summary_page", "b_detail"): |
| items += [("line", "1099-B Summary of Proceeds, Gains & Losses, Adjustments and Withholding"), |
| ("table", ["Term", "Form 8949 type", "Proceeds", "Cost basis", "Wash sale loss disallowed", "Net gain or loss"], |
| [["Short", "A (basis reported to the IRS)", f"{rng.uniform(100, 90000):,.2f}", f"{rng.uniform(100, 90000):,.2f}", "0.00", f"{rng.uniform(-5000, 9000):,.2f}"], |
| ["Long", "D (basis reported to the IRS)", f"{rng.uniform(100, 90000):,.2f}", f"{rng.uniform(100, 90000):,.2f}", "0.00", f"{rng.uniform(-5000, 30000):,.2f}"]])] |
| items.append(("line", "This is important tax information and is being furnished to the Internal Revenue Service.")) |
| return items, kind |
|
|
|
|
| def estimated_tax_confirmation(rng: random.Random, year: int) -> tuple[list[tuple], str]: |
| kind = rng.choice(["direct_pay", "eftps", "state_portal", "card_processor"]) |
| title = {"direct_pay": "IRS Direct Pay - Payment Confirmation", "eftps": "EFTPS Payment Acknowledgement", |
| "state_portal": "Estimated Payment Submitted", "card_processor": "Tax Payment Receipt"}[kind] |
| items: list[tuple] = [("title", title), ("kv", "Confirmation number", "-".join(str(rng.randint(1000, 9999)) for _ in range(3))), |
| ("kv", "Name", person(rng)), ("kv", "Reason for payment", "Estimated Tax"), |
| ("kv", "Apply payment to", rng.choice(["1040ES (for 1040, 1040A, 1040EZ)", "Form 1040-ES", "Estimated tax"])), |
| ("kv", "Tax period for payment", str(year)), ("kv", "Payment amount", money(rng, 100, 20000, 1)), |
| ("kv", "Payment date", date(rng, year)), ("kv", "Bank account", masked(rng, 4))] |
| if kind == "card_processor": |
| items.append(("kv", "Convenience fee", money(rng, 2, 90, 1))) |
| items.append(("line", rng.choice(["Keep this confirmation for your records.", "Your payment has been scheduled.", |
| "Do not mail a voucher for payments made online."]))) |
| return items, kind |
|
|
|
|
| def tax_instructions(rng: random.Random, year: int) -> tuple[list[tuple], str]: |
| form = rng.choice(["1099-INT", "W-2", "1098", "1040", "1099-B", "1099-R", "Schedule C", "8949"]) |
| kind = rng.choice(["irs_instructions", "employer_guide", "preparer_checklist"]) |
| items: list[tuple] = [] |
| if kind == "irs_instructions": |
| items += [("title", f"Instructions for Form {form}"), ("line", f"(Rev. January {year})"), |
| ("line", "Section references are to the Internal Revenue Code unless otherwise noted."), |
| ("line", "What's New"), ("line", f"Future developments. For the latest information about developments related to Form {form}, go to IRS.gov."), |
| ("line", "General Instructions"), ("line", "Specific Instructions"), |
| ("line", f"Box 1. Enter the amount reported to you. Do not include amounts reported on another form."), |
| ("line", "Paperwork Reduction Act Notice. We ask for the information on this form to carry out the Internal Revenue laws.")] |
| elif kind == "employer_guide": |
| items += [("title", f"Understanding your Form {form}"), ("line", f"This guide explains each box on the Form {form} you receive."), |
| ("line", "Box 1 shows the amount reported to the IRS."), ("line", "Boxes 15 through 17 show state information."), |
| ("line", "This page is an explanation only; your actual form is attached separately.")] |
| else: |
| items += [("title", f"{year} Tax Organizer Checklist"), ("line", "Please bring the following documents:"), |
| ("line", "☐ All Forms W-2 and 1099"), ("line", "☐ Form 1098 mortgage interest statements"), |
| ("line", "☐ Property tax bills and charitable receipts"), ("line", "☐ Last year's federal and state returns")] |
| return items, kind |
|
|
|
|
| def annual_giving_statement(rng: random.Random, year: int) -> tuple[list[tuple], str]: |
| kind = rng.choice(["church", "nonprofit", "daf_grant_summary"]) |
| org = rng.choice(CHARITIES) |
| items: list[tuple] = [("line", org), ("line", f"Tax ID {ein(rng)} A 501(c)(3) organization"), |
| ("title", rng.choice([f"{year} Annual Giving Statement", f"Contribution Statement for {year}", |
| "Year-End Giving Summary"])), |
| ("line", f"Dear {person(rng)},"), ("line", "Thank you for your generous support this year.")] |
| gifts = [[date(rng, year), rng.choice(["Cash", "Check #" + str(rng.randint(1000, 9999)), "Online gift", "Stock transfer"]), |
| f"{rng.uniform(10, 2500):,.2f}"] for _ in range(rng.randint(3, 8))] |
| items.append(("table", ["Date", "Method", "Amount"], gifts)) |
| items.append(("kv", "Total contributions", f"${sum(float(g[2].replace(',', '')) for g in gifts):,.2f}")) |
| items.append(("line", rng.choice(["No goods or services were provided in exchange for these contributions.", |
| "Only intangible religious benefits were provided in exchange for your gifts."]))) |
| return items, kind |
|
|
|
|
| def donation_appeal(rng: random.Random, year: int) -> tuple[list[tuple], str]: |
| org = rng.choice(CHARITIES) |
| kind = rng.choice(["year_end_letter", "email", "matching_campaign", "reply_card"]) |
| goal = rng.randint(20, 900) * 1000 |
| pool = [ |
| "Every gift provides warm meals and shelter for families in need.", |
| f"Give ${rng.choice([25, 35, 50, 75])}, ${rng.choice([100, 150])}, or ${rng.choice([250, 500, 1000])} today.", |
| f"A generous donor will match every gift until {date(rng, year)}.", |
| "Donate now at our website or return the enclosed reply card.", |
| "Your gift may be tax-deductible to the extent allowed by law.", |
| f"We are ${goal:,} away from our {year} goal.", |
| f"Last year you helped serve {rng.randint(400, 40000):,} neighbors.", |
| "Become a monthly sustainer and make a difference all year long.", |
| "P.S. Gifts made by December 31 count toward this year's campaign.", |
| f"Scan the QR code or call {rng.randint(200, 989)}-555-{rng.randint(1000, 9999)} to give by phone.", |
| "This is a solicitation for a charitable contribution, not a receipt.", |
| ] |
| items: list[tuple] = [("line", org), ("title", rng.choice(["Will you help a neighbor this winter?", "Your gift matters", |
| "Double your impact today", f"{year} Annual Appeal", |
| "Spring Giving Campaign", "Please give before midnight"])), |
| ("line", f"Dear {rng.choice([person(rng).split()[0], 'Friend', 'Neighbor', 'Supporter'])},")] |
| items += [("line", s) for s in rng.sample(pool, rng.randint(3, 6))] |
| if kind == "reply_card": |
| items += [("kv", "Name", person(rng)), ("kv", "Gift amount", "$______"), ("line", "☐ Check enclosed ☐ Charge my card")] |
| return items, kind |
|
|
|
|
| def charity_event_receipt(rng: random.Random, year: int) -> tuple[list[tuple], str]: |
| org = rng.choice(CHARITIES) |
| ticket = rng.uniform(75, 500) |
| fmv = ticket * rng.uniform(0.2, 0.6) |
| items: list[tuple] = [("line", org), ("title", rng.choice(["Gala Ticket Receipt", "Event Registration Receipt", "Charity Auction Receipt"])), |
| ("kv", "Attendee", person(rng)), ("kv", "Event date", date(rng, year)), |
| ("kv", "Amount paid", f"${ticket:,.2f}"), ("kv", "Fair market value of dinner and entertainment", f"${fmv:,.2f}"), |
| ("kv", "Deductible portion", f"${ticket - fmv:,.2f}"), |
| ("line", "The deductible amount is limited to the excess of your payment over the value of goods and services received.")] |
| return items, "event" |
|
|
|
|
| def medical_receipt(rng: random.Random, year: int) -> tuple[list[tuple], str]: |
| kind = rng.choice(["clinic", "pharmacy", "dental", "hospital_statement"]) |
| items: list[tuple] = [("line", rng.choice(CLINICS)), |
| ("title", {"clinic": "Patient Receipt", "pharmacy": "Prescription Receipt", "dental": "Dental Visit Receipt", |
| "hospital_statement": "Patient Account Statement"}[kind]), |
| ("kv", "Patient", person(rng)), ("kv", "Date of service", date(rng, year))] |
| charge = rng.uniform(20, 3000) |
| if kind == "pharmacy": |
| items += [("kv", "Rx #", str(rng.randint(100000, 999999))), ("kv", "Drug", rng.choice(["Atorvastatin 20mg", "Amoxicillin 500mg", "Lisinopril 10mg"])), |
| ("kv", "Qty", str(rng.choice([30, 60, 90]))), ("kv", "Insurance paid", f"{charge * 0.7:,.2f}"), |
| ("kv", "Your copay", f"{charge * 0.3:,.2f}")] |
| else: |
| items.append(("table", ["CPT", "Description", "Charge"], |
| [[str(rng.choice([99213, 99214, 80053, 36415, 1110, 2391])), rng.choice(["Office visit", "Lab panel", "Cleaning", "Filling"]), |
| f"{charge:,.2f}"]])) |
| items += [("kv", "Insurance adjustment", f"-{charge * 0.4:,.2f}"), ("kv", "Insurance paid", f"-{charge * 0.4:,.2f}"), |
| ("kv", "Patient paid", f"{charge * 0.2:,.2f}"), ("kv", "Balance due", "$0.00")] |
| items.append(("kv", "Payment method", rng.choice(["Visa ****" + masked(rng, 4)[-4:], "HSA card", "Cash"]))) |
| return items, kind |
|
|
|
|
| def purchase_receipt(rng: random.Random, year: int) -> tuple[list[tuple], str]: |
| store = rng.choice(STORES) |
| lines = [[rng.choice(["USB-C Cable", "Printer Paper 10pk", "Drill Bit Set", "Organic Apples", "Monitor 27in", "LED Bulbs 4pk"]), |
| str(rng.randint(1, 3)), f"{rng.uniform(2, 400):,.2f}"] for _ in range(rng.randint(2, 6))] |
| sub = sum(float(r[2].replace(",", "")) for r in lines) |
| items: list[tuple] = [("title", store), ("line", " ".join(address(rng))), ("line", f"{date(rng, year)} 3:41 PM Store 0{rng.randint(10, 99)}"), |
| ("table", ["Item", "Qty", "Price"], lines), ("kv", "Subtotal", f"{sub:,.2f}"), |
| ("kv", "Sales tax", f"{sub * 0.07:,.2f}"), ("kv", "Total", f"{sub * 1.07:,.2f}"), |
| ("kv", "Visa", masked(rng, 4)), ("line", "Thank you for shopping! Returns within 30 days with receipt.")] |
| return items, "retail" |
|
|
|
|
| def _fill(rng: random.Random, text: str, year: int) -> str: |
| city, _ = rng.choice(CITIES) |
| make, model = rng.choice(MAKES) |
| values = {"utility": rng.choice(UTILITIES), "telco": rng.choice(TELCOS), "address": " ".join(address(rng)), |
| "period": " - ".join(_period(rng, year)), "money": money(rng, 40, 3000, 1), "small": money(rng, 5, 300, 1), |
| "date": date(rng, year), "acct": str(rng.randint(10 ** 7, 10 ** 9)), "name": person(rng), |
| "company": rng.choice(["Oak Hollow Property Mgmt", "Riverbend Commons", "Granite Ridge"]), |
| "plate": "".join(rng.choice("ABCDEFGHJKLMNPRSTUVWXYZ0123456789") for _ in range(6)), |
| "vin": "".join(rng.choice("ABCDEFGHJKLMNPRSTUVWXYZ0123456789") for _ in range(17)), "year": str(year - 3), |
| "make": make, "model": model, "county": f"{city} County", "school": rng.choice(SCHOOLS), |
| "employer": rng.choice(EMPLOYERS), "bank": rng.choice(BANKS), "insurer": rng.choice(INSURERS), |
| "clinic": rng.choice(CLINICS).split()[0], "city_upper": city.upper(), |
| "email": f"{rng.choice(['jo', 'avery', 'm.lee', 'casey88', 'priya.k'])}@example.com", |
| "phone": f"{rng.randint(200, 989)}-555-{rng.randint(1000, 9999)}", "count": str(rng.randint(1, 600))} |
| return text.format(**values) |
|
|
|
|
| def unknown_document(rng: random.Random, year: int, kind_index: int) -> tuple[list[tuple], str]: |
| kind, titles, body = UNKNOWN_KINDS[kind_index] |
| items: list[tuple] = [("title", _fill(rng, t, year)) for t in titles] |
| items += [("line", _fill(rng, b, year)) for b in body if rng.random() < 0.9] |
| return items, kind |
|
|
|
|
| def other_tax_form(rng: random.Random, year: int, form_index: int) -> tuple[list[tuple], str]: |
| form, title, lines = OTHER_TAX_FORMS[form_index] |
| items: list[tuple] = [("title", f"Form {form}"), ("title", title)] |
| if rng.random() < 0.7: |
| items.append(("line", str(year))) |
| items.append(("line", rng.choice(["Department of the Treasury - Internal Revenue Service", "Copy B For Recipient", |
| "Keep for your records", "Department of Revenue"]))) |
| items.append(("kv", rng.choice(["Name", "Recipient's name", "Taxpayer name"]), person(rng))) |
| items.append(("kv", rng.choice(["Identification number", "Recipient's TIN", "SSN"]), masked(rng))) |
| for line in lines: |
| items.append(("kv", line, money(rng, 0, 30000, 0.3) if rng.random() < 0.8 else date(rng, year))) |
| return items, form |
|
|
|
|
| GENERATORS = { |
| "BANK_STATEMENT": bank_statement, "CREDIT_CARD_STATEMENT": credit_card_statement, |
| "MORTGAGE_STATEMENT": mortgage_statement, "LOAN_STATEMENT": loan_statement, |
| "BROKERAGE_STATEMENT": brokerage_statement, "RETIREMENT_ACCOUNT_STATEMENT": retirement_statement, |
| "HSA_ACCOUNT_STATEMENT": hsa_statement, "PAYSTUB": paystub, "INSURANCE_DOCUMENT": insurance_document, |
| "CRYPTO_TAX_REPORT": crypto_tax_report, "PROPERTY_TAX_BILL": property_tax_bill, |
| "PROFIT_AND_LOSS_STATEMENT": profit_and_loss, "CONSOLIDATED_1099": consolidated_1099, |
| "ESTIMATED_TAX_PAYMENT_CONFIRMATION": estimated_tax_confirmation, "TAX_INSTRUCTIONS": tax_instructions, |
| "ANNUAL_GIVING_STATEMENT": annual_giving_statement, "DONATION_APPEAL": donation_appeal, |
| "CHARITY_EVENT_RECEIPT": charity_event_receipt, "MEDICAL_RECEIPT": medical_receipt, |
| "PURCHASE_RECEIPT": purchase_receipt, |
| } |
|
|
|
|
| |
| |
| |
| |
|
|
| def _amt(rng: random.Random, low: float, high: float, neg: float = 0.0) -> str: |
| v = rng.uniform(low, high) |
| return f"-{v:.2f}" if rng.random() < neg else f"{v:.2f}" |
|
|
|
|
| def _iso(rng: random.Random, year: int) -> str: |
| return rng.choice([f"{year}-{rng.randint(1, 12):02d}-{rng.randint(1, 28):02d}", |
| f"{rng.randint(1, 12):02d}/{rng.randint(1, 28):02d}/{year}", |
| f"{rng.randint(1, 28):02d}/{rng.randint(1, 12):02d}/{year}"]) |
|
|
|
|
| EXPORTS = { |
| "BANK_STATEMENT": [ |
| (["Date", "Description", "Amount", "Running Bal."], |
| lambda r, y: [_iso(r, y), r.choice(MERCHANTS + ["PAYROLL DIRECT DEP", "ONLINE TRANSFER TO SAV", "ATM WITHDRAWAL", "ZELLE FROM J SMITH"]), _amt(r, 3, 2500, 0.7), _amt(r, 100, 30000)]), |
| (["Posting Date", "Description", "Amount", "Type", "Balance", "Check or Slip #"], |
| lambda r, y: [_iso(r, y), r.choice(MERCHANTS + ["ACH DEPOSIT EMPLOYER", "CHECK 1043"]), _amt(r, 3, 2500, 0.7), r.choice(["DEBIT_CARD", "ACH_CREDIT", "CHECK_PAID", "ATM"]), _amt(r, 100, 30000), r.choice(["", "", "1043"])]), |
| (["Transaction Date", "Transaction Description", "Debit", "Credit", "Balance"], |
| lambda r, y: [_iso(r, y), r.choice(MERCHANTS + ["INTEREST PAYMENT", "MOBILE DEPOSIT"]), r.choice(["", _amt(r, 3, 900)]), r.choice(["", _amt(r, 1, 3000)]), _amt(r, 100, 30000)]), |
| (["Date", "Payee", "Memo", "Withdrawal", "Deposit", "Balance"], |
| lambda r, y: [_iso(r, y), r.choice(MERCHANTS), r.choice(["", "groceries", "rent", "utilities"]), _amt(r, 3, 900), "", _amt(r, 100, 30000)]), |
| ], |
| "CREDIT_CARD_STATEMENT": [ |
| (["Transaction Date", "Post Date", "Description", "Category", "Type", "Amount", "Memo"], |
| lambda r, y: [_iso(r, y), _iso(r, y), r.choice(MERCHANTS), r.choice(["Groceries", "Travel", "Food & Drink", "Shopping", "Gas"]), r.choice(["Sale", "Sale", "Return", "Payment"]), _amt(r, 3, 900, 0.8), ""]), |
| (["Date", "Description", "Card Member", "Account #", "Amount"], |
| lambda r, y: [_iso(r, y), r.choice(MERCHANTS), person(r).upper(), "-" + str(r.randint(10000, 99999)), _amt(r, 3, 900)]), |
| (["Trans. Date", "Post Date", "Description", "Amount", "Category"], |
| lambda r, y: [_iso(r, y), _iso(r, y), r.choice(MERCHANTS + ["AUTOPAY PAYMENT - THANK YOU", "INTEREST CHARGE ON PURCHASES"]), _amt(r, 3, 900, 0.1), r.choice(["Merchandise", "Restaurants", "Payments and Credits"])]), |
| ], |
| "MORTGAGE_STATEMENT": [ |
| (["Payment Date", "Total Payment", "Principal", "Interest", "Escrow", "Principal Balance"], |
| lambda r, y: [_iso(r, y), _amt(r, 900, 4500), _amt(r, 200, 1600), _amt(r, 300, 2500), _amt(r, 150, 1200), _amt(r, 60000, 640000)]), |
| (["Date", "Transaction", "Amount", "Principal", "Interest", "Escrow", "Fees", "Unpaid Principal"], |
| lambda r, y: [_iso(r, y), r.choice(["Regular monthly payment", "Escrow disbursement - county tax", "Hazard insurance disbursement", "Additional principal"]), _amt(r, 100, 4500), _amt(r, 0, 1600), _amt(r, 0, 2500), _amt(r, 0, 1200), "0.00", _amt(r, 60000, 640000)]), |
| (["Due Date", "Amount Paid", "Principal Applied", "Interest Applied", "Escrow Deposit", "Remaining Balance"], |
| lambda r, y: [_iso(r, y), _amt(r, 900, 4500), _amt(r, 200, 1600), _amt(r, 300, 2500), _amt(r, 150, 1200), _amt(r, 60000, 640000)]), |
| ], |
| "LOAN_STATEMENT": [ |
| (["Date", "Description", "Payment", "Principal", "Interest", "Balance"], |
| lambda r, y: [_iso(r, y), r.choice(["Auto loan payment", "Student loan payment", "Loan payment", "Autopay", "Personal loan installment"]), _amt(r, 80, 1400), _amt(r, 40, 1200), _amt(r, 5, 400), _amt(r, 0, 90000)]), |
| (["Posted", "Type", "Amount", "To Principal", "To Interest", "Outstanding Balance"], |
| lambda r, y: [_iso(r, y), r.choice(["PAYMENT", "INTEREST ACCRUAL", "LATE FEE", "DISBURSEMENT", "INTEREST CAPITALIZATION"]), _amt(r, 5, 1400), _amt(r, 0, 1200), _amt(r, 0, 400), _amt(r, 0, 90000)]), |
| (["Payment Date", "Amount Paid", "Principal Paid", "Interest Paid", "Late Fee", "Loan Balance"], |
| lambda r, y: [_iso(r, y), _amt(r, 80, 1400), _amt(r, 40, 1200), _amt(r, 5, 400), "0.00", _amt(r, 0, 90000)]), |
| ], |
| "BROKERAGE_STATEMENT": [ |
| (["Symbol", "Description", "Quantity", "Price", "Market Value", "Cost Basis", "Gain/Loss"], |
| lambda r, y: [r.choice(["VTI", "AAPL", "MSFT", "BND", "SCHD", "QQQ", "SPAXX**"]), r.choice(["VANGUARD TOTAL STOCK MKT ETF", "APPLE INC", "MONEY MARKET", "ISHARES CORE S&P 500"]), _amt(r, 1, 400), _amt(r, 1, 500), _amt(r, 100, 90000), _amt(r, 100, 80000), _amt(r, 1, 9000, 0.3)]), |
| (["Account Number", "Account Name", "Symbol", "Description", "Quantity", "Last Price", "Current Value", "Total Gain/Loss Dollar", "Percent Of Account"], |
| lambda r, y: ["Z" + str(r.randint(10 ** 7, 10 ** 8)), "Individual", r.choice(["FXAIX", "VOO", "NVDA", "AMZN"]), r.choice(["FIDELITY 500 INDEX", "VANGUARD S&P 500 ETF", "NVIDIA CORP"]), _amt(r, 1, 400), _amt(r, 1, 900), _amt(r, 100, 90000), _amt(r, 1, 9000, 0.3), f"{r.uniform(1, 60):.2f}%"]), |
| (["Run Date", "Action", "Symbol", "Security Description", "Quantity", "Price", "Amount", "Settlement Date"], |
| lambda r, y: [_iso(r, y), r.choice(["YOU BOUGHT", "YOU SOLD", "DIVIDEND RECEIVED", "REINVESTMENT", "INTEREST EARNED"]), r.choice(["VTI", "AAPL", "SCHD"]), r.choice(["VANGUARD INDEX FDS", "APPLE INC", "SCHWAB US DIVIDEND EQUITY ETF"]), _amt(r, 0, 100), _amt(r, 1, 500), _amt(r, 1, 9000, 0.5), _iso(r, y)]), |
| (["Trade Date", "Transaction Type", "Investment Name", "Shares", "Share Price", "Net Amount"], |
| lambda r, y: [_iso(r, y), r.choice(["Buy", "Sell", "Dividend", "Reinvestment", "Capital gain (LT)"]), r.choice(["Total Stock Market Index Admiral", "Total Bond Market ETF", "500 Index Admiral"]), _amt(r, 0, 100), _amt(r, 1, 500), _amt(r, 1, 9000, 0.5)]), |
| ], |
| "RETIREMENT_ACCOUNT_STATEMENT": [ |
| (["Date", "Fund", "Employee Contribution", "Employer Match", "Gain/Loss", "Balance"], |
| lambda r, y: [_iso(r, y), r.choice(["Target Date 2055", "TDF2050", "S&P 500 Index", "Stable Value"]), _amt(r, 50, 1500), _amt(r, 0, 800), _amt(r, 1, 3000, 0.4), _amt(r, 1000, 600000)]), |
| (["Pay Date", "Source", "Investment", "Amount", "Units", "Unit Price"], |
| lambda r, y: [_iso(r, y), r.choice(["Employee Pre-Tax", "Roth 401(k)", "Safe Harbor Match", "Profit Sharing", "Rollover"]), r.choice(["Target Retirement 2050", "Stable Value Fund", "Large Cap Index"]), _amt(r, 20, 1500), _amt(r, 0, 60), _amt(r, 9, 300)]), |
| (["Account", "Account Type", "Symbol", "Quantity", "Value", "Contributions YTD"], |
| lambda r, y: ["..." + str(r.randint(1000, 9999)), r.choice(["Traditional IRA", "Roth IRA", "SEP IRA", "Rollover IRA", "SIMPLE IRA"]), r.choice(["VTI", "FXAIX", "VTTSX", "BND"]), _amt(r, 1, 400), _amt(r, 100, 300000), _amt(r, 0, 7000)]), |
| ], |
| "HSA_ACCOUNT_STATEMENT": [ |
| (["Date", "Description", "Type", "Amount", "Cash Balance"], |
| lambda r, y: [_iso(r, y), r.choice(["Payroll contribution", "Employer HSA contribution", "Card purchase - Pharmacy", "Reimbursement to self", "HSA interest", "Transfer to HSA investments"]), r.choice(["Contribution", "Distribution", "Interest", "Transfer"]), _amt(r, 1, 900, 0.4), _amt(r, 50, 12000)]), |
| (["Transaction Date", "Merchant", "Category", "Amount", "Status", "Receipt"], |
| lambda r, y: [_iso(r, y), r.choice(["CVS PHARMACY", "SAMPLE FAMILY CLINIC", "BRIGHTSMILE DENTAL", "VISION CENTER"]), r.choice(["Medical", "Pharmacy", "Dental", "Vision"]), _amt(r, 5, 900), r.choice(["Posted", "Pending"]), r.choice(["Uploaded", "Missing"])]), |
| ], |
| "CRYPTO_TAX_REPORT": [ |
| (["Timestamp", "Transaction Type", "Asset", "Quantity Transacted", "Spot Price at Transaction", "Subtotal", "Total (inclusive of fees)", "Fees"], |
| lambda r, y: [f"{_iso(r, y)}T{r.randint(0, 23):02d}:{r.randint(0, 59):02d}:00Z", r.choice(["Buy", "Sell", "Convert", "Send", "Receive", "Staking Income"]), r.choice(["BTC", "ETH", "SOL", "USDC"]), f"{r.uniform(0.0001, 20):.6f}", _amt(r, 1, 70000), _amt(r, 1, 9000), _amt(r, 1, 9100), _amt(r, 0, 40)]), |
| (["Date", "Sent Amount", "Sent Currency", "Received Amount", "Received Currency", "Fee Amount", "Fee Currency", "Tag"], |
| lambda r, y: [_iso(r, y), f"{r.uniform(0.01, 5000):.4f}", r.choice(["USD", "BTC", "ETH"]), f"{r.uniform(0.0001, 5000):.6f}", r.choice(["ETH", "SOL", "USD"]), f"{r.uniform(0, 5):.4f}", "USD", r.choice(["", "staking", "airdrop", "trade"])]), |
| (["Asset", "Date Acquired", "Date Sold", "Proceeds", "Cost Basis", "Gain (Loss)", "Holding Period"], |
| lambda r, y: [r.choice(["BTC", "ETH", "SOL"]), _iso(r, y - 1), _iso(r, y), _amt(r, 10, 20000), _amt(r, 10, 20000), _amt(r, 1, 9000, 0.4), r.choice(["Short-term", "Long-term"])]), |
| ], |
| "PROFIT_AND_LOSS_STATEMENT": [ |
| (["Account", "Q1", "Q2", "Q3", "Q4", "Total"], |
| lambda r, y: [r.choice(["Total Revenue", "Sales", "Cost of Goods Sold", "Gross Profit", "Payroll Expenses", "Rent", "Marketing", "Net Income"])] + [_amt(r, 100, 90000) for _ in range(5)]), |
| (["Category", "Jan", "Feb", "Mar", "YTD"], |
| lambda r, y: [r.choice(["Income", "Service revenue", "COGS", "Operating expenses", "Contractors", "Software", "Net operating income"])] + [_amt(r, 100, 30000) for _ in range(4)]), |
| ], |
| } |
| PREAMBLES = { |
| "BANK_STATEMENT": ["Everyday Checking ...{a}", "Savings Account XXXX{a} - transactions", "Account History: Checking"], |
| "CREDIT_CARD_STATEMENT": ["Card ending in {a} - Activity", "Credit Card Transactions", "Rewards Visa ...{a}"], |
| "MORTGAGE_STATEMENT": ["Mortgage loan {a} - payment history", "Home Loan Activity", "Loan History - Mortgage"], |
| "LOAN_STATEMENT": ["Loan {a} payment history", "Auto Loan Activity", "Student Loan Transactions", "Personal Loan History"], |
| "BROKERAGE_STATEMENT": ["Positions as of {d}", "Brokerage Account ...{a} - Activity", "Portfolio Positions"], |
| "RETIREMENT_ACCOUNT_STATEMENT": ["401(k) Plan contribution history", "IRA ...{a} Positions", "Retirement Plan Activity"], |
| "HSA_ACCOUNT_STATEMENT": ["HSA Activity", "Health Savings Account ...{a} transactions", "HSA Claims and Contributions"], |
| "CRYPTO_TAX_REPORT": ["Transaction history export", "Crypto gains and losses - {y}", "Exchange account statement"], |
| "PROFIT_AND_LOSS_STATEMENT": ["{b} - Profit and Loss - {y}", "Income statement by month", "P&L Summary {y}"], |
| } |
|
|
|
|
| def raw_export(rng: random.Random, year: int, label: str) -> tuple[list[tuple], str]: |
| """A downloaded account export: optional preamble, header row, rows.""" |
| header, row = rng.choice(EXPORTS[label]) |
| items: list[tuple] = [] |
| if rng.random() < 0.6: |
| pre = rng.choice(PREAMBLES[label]).format(a=rng.randint(1000, 9999), d=_iso(rng, year), y=year, |
| b=rng.choice(BUSINESSES)) |
| items.append(("title", pre)) |
| if rng.random() < 0.3: |
| items.append(("line", f"Downloaded {_iso(rng, year)}")) |
| items.append(("table", header, [row(rng, year) for _ in range(rng.randint(3, 9))])) |
| return items, "raw_export" |
|
|
|
|
| def with_exports(label: str, gen): |
| """Wrap a statement generator so a quarter of its rows are raw exports.""" |
| def wrapped(rng: random.Random, year: int) -> tuple[list[tuple], str]: |
| if rng.random() < 0.25: |
| return raw_export(rng, year, label) |
| return gen(rng, year) |
| return wrapped |
|
|
|
|
| for _label in EXPORTS: |
| GENERATORS[_label] = with_exports(_label, GENERATORS[_label]) |
|
|
