statement with the books (though we're only interested in the presence

of lines, not so much their order).

Problems in scope:

 - errors in the books take hours to find during reconciliation,

   succeptible to mistakes, such as not noticing when there are two

   payments for the same amount on the statement, but not in the books

 - adding statement/reconciliation metadata to books is/was manual and

   prone to mistakes

 - jumping to an individual transaction in a large ledger isn't

   trivial - Emacs grep mode is the current best option

def format_record(record: dict) -> str:

    if record['payee'] and record['check_id']:

        output = f"{record['date'].isoformat()}: {record['amount']:11,.2f} {record['payee'][:25]} #{record['check_id']}".ljust(59)

    elif record['payee']:

def format_multirecord(r1s: list[dict], r2s: list[dict], note: str) -> list[list]:

    assert len(r1s) == 1

    assert len(r2s) > 1

    match_output = []

def first_word_exact_match(a: str, b: str) -> float:

    if len(a) == 0 or len(b) == 0:

        return 0.0

    first_a = a.split()[0].strip()

def payee_match(a: str, b: str) -> float:

    fuzzy_match = float(fuzz.token_set_ratio(a, b) / 100.00)

    first_word_match = first_word_exact_match(a, b)

    return max(fuzzy_match, first_word_match)

def records_match(r1: Dict, r2: Dict) -> Tuple[float, List[str]]:

    """Do these records represent the same transaction?"""

    date_score = date_proximity(r1['date'], r2['date'])

    if r1['date'] == r2['date']:

        date_message = ''

def match_statement_and_books(statement_trans: List[Dict], books_trans: List[Dict]) -> Tuple[List[Tuple[List, List, List]], List[Dict], List[Dict]]:

    """

    matches = []

    remaining_books_trans = []

    return matches, remaining_statement_trans, remaining_books_trans

# TODO: Return list of tuples (instead of list of lists).

def format_matches(matches: List, csv_statement: str, show_reconciled_matches: bool) -> List[List]:

    match_output = []

    for r1s, r2s, note in matches:

        note = ', '.join(note)

def date_proximity(d1: datetime.date, d2: datetime.date) -> float:

    diff = abs(int((d1 - d2).days))

        return 0.0

    else:

def metadata_for_match(match: Tuple[List, List, List], statement_filename: str, csv_filename: str) -> List[Tuple[str, int, str]]:

    statement_filename = get_repo_relative_path(statement_filename)

    csv_filename = get_repo_relative_path(csv_filename)

    metadata = []

        ...,

    ]

    """

    file_contents: dict[str, list] = {}

    file_offsets: dict[str, int] = collections.defaultdict(int)

def get_repo_relative_path(path: str) -> str:

    return os.path.relpath(path, start=os.getenv('CONSERVANCY_REPOSITORY'))

def parse_path(path: str) -> str:

    if not os.path.exists(path):

        raise argparse.ArgumentTypeError(f'File {path} does not exist.')

    return path

def parse_repo_relative_path(path: str) -> str:

    if not os.path.exists(path):

        raise argparse.ArgumentTypeError(f'File {path} does not exist.')

    repo = os.getenv('CONSERVANCY_REPOSITORY')

def totals(matches: List[Tuple[List, List, List]]) -> Tuple[decimal.Decimal, decimal.Decimal, decimal.Decimal]:

    total_matched = decimal.Decimal(0)

    total_missing_from_books = decimal.Decimal(0)

    total_missing_from_statement = decimal.Decimal(0)

    return total_matched, total_missing_from_books, total_missing_from_statement

def process_unmatched(statement_trans: List[dict], books_trans: List[dict]) -> List[Tuple[List, List, List]]:

    matches: List[Tuple[List, List, List]] = []

    for r1 in statement_trans:

        matches.append(([r1], [], ['no match']))

        config = configmod.Config()

        config.load_file()

    if 'AMEX' in args.account:

        validate_csv = validate_amex_csv

        standardize_statement_record = standardize_amex_record

        f.seek(0)

        statement_trans = read_transactions_from_csv(f, standardize_statement_record)

    begin_date = statement_trans[0]['date']

    end_date = statement_trans[-1]['date']

    #

    # beancount.query.query_compile.compile() and

    # beancount.query.query_execute.filter_entries() look useful in this respect,

    # but I'm not clear on how to use compile(). An example would help.

    entries, _, options = loader.load_file(args.beancount_file)

    # String concatenation looks bad, but there's no SQL injection possible here

    # because BQL can't write back to the Beancount files. I hope!

    query = f'SELECT filename, META("lineno") AS line, META("bank-statement") AS bank_statement, date, number(cost(position)), payee, ENTRY_META("entity") as entity, ANY_META("check-id") as check_id, narration where account = "{args.account}" and date >= {begin_date} and date <= {end_date}'

    _, result_rows = run_query(entries, options, query)

    books_trans = sort_records([standardize_beancount_record(row) for row in result_rows])

    matches, remaining_statement_trans, remaining_books_trans = match_statement_and_books(statement_trans, books_trans)

    matches.extend(subset_matches)

    unmatched = process_unmatched(remaining_statement_trans, remaining_books_trans)

    matches.extend(unmatched)

    match_output = format_matches(matches, args.csv_statement, args.show_reconciled_matches)

    _, total_missing_from_books, total_missing_from_statement = totals(matches)

    print('-' * 155)

    statement_heading = f'Statement transactions {begin_date} to {end_date}'

    print(f'{statement_heading:<52}            {"Books transactions":<58}   Notes')

    print(f'Total:                      {total_missing_from_statement + total_missing_from_books:12,.2f}')

    print('-' * 155)

    metadata_to_apply = []

    for match in matches:

        metadata_to_apply.extend(metadata_for_match(match, args.bank_statement, args.csv_statement))