def sort_and_filter_accounts(

        accounts: Iterable[data.Account],

        order: Sequence[str],

) -> Iterator[Tuple[int, data.Account]]:

    """Reorganize accounts based on an ordered set of names

    This function takes a iterable of Account objects, and a sequence of

    account names. Usually the account names are higher parts of the account

    hierarchy like Income, Equity, or Assets:Receivable.

    It returns an iterator of 2-tuples, ``(index, account)`` where ``index`` is

    an index into the ordering sequence, and ``account`` is one of the input

    Account objects that's under the account name ``order[index]``. Tuples are

    sorted, so ``index`` increases monotonically, and Account objects using the

    same index are yielded sorted by name.

    For example, if your order is

    ``['Liabilities:Payable', 'Assets:Receivable']``, the return value will

    first yield zero or more results with index 0 and an account under

    Liabilities:Payable, then zero or more results with index 1 and an account

    under Accounts:Receivable.

    Input Accounts that are not under any of the account names in ``order`` do

    not appear in the output iterator. That's the filtering part.

    Note that if none of the input Accounts are under one of the ordering

    sequence accounts, its index will never appear in the results. This is why

    the 2-tuples include an index rather than the original account name string,

    to make it easier for callers to know when this happens and do something

    with unused ordering accounts.

    """

    index_map = {s: ii for ii, s in enumerate(order)}

    retval: Mapping[int, List[data.Account]] = collections.defaultdict(list)

    for account in accounts:

        acct_key = account.is_under(*order)

        if acct_key is not None:

            retval[index_map[acct_key]].append(account)

    return (

        (key, account)

        for key in sorted(retval)

        for account in sorted(retval[key])

    )

        for _, account in core.sort_and_filter_accounts(

        for sheet_index, account in core.sort_and_filter_accounts(

from conservancy_beancount.data import Account

def test_sort_and_filter_accounts():

    accounts = (Account(s) for s in [

        'Expenses:Services',

        'Assets:Receivable',

        'Income:Other',

        'Liabilities:Payable',

        'Equity:Funds:Unrestricted',

        'Income:Donations',

        'Expenses:Other',

    ])

    actual = core.sort_and_filter_accounts(accounts, ['Equity', 'Income', 'Expenses'])

    assert list(actual) == [

        (0, 'Equity:Funds:Unrestricted'),

        (1, 'Income:Donations'),

        (1, 'Income:Other'),

        (2, 'Expenses:Other'),

        (2, 'Expenses:Services'),

    ]

def test_sort_and_filter_accounts_unused_name():

    accounts = (Account(s) for s in [

        'Liabilities:CreditCard',

        'Assets:Cash',

        'Assets:Receivable:Accounts',

    ])

    actual = core.sort_and_filter_accounts(

        accounts, ['Assets:Receivable', 'Liabilities:Payable', 'Assets', 'Liabilities'],

    )

    assert list(actual) == [

        (0, 'Assets:Receivable:Accounts'),

        (2, 'Assets:Cash'),

        (3, 'Liabilities:CreditCard'),

    ]

def test_sort_and_filter_accounts_with_subaccounts():

    accounts = (Account(s) for s in [

        'Assets:Checking',

        'Assets:Receivable:Fraud',

        'Assets:Cash',

        'Assets:Receivable:Accounts',

    ])

    actual = core.sort_and_filter_accounts(accounts, ['Assets:Receivable', 'Assets'])

    assert list(actual) == [

        (0, 'Assets:Receivable:Accounts'),

        (0, 'Assets:Receivable:Fraud'),

        (1, 'Assets:Cash'),

        (1, 'Assets:Checking'),

    ]

@pytest.mark.parametrize('empty_arg', ['accounts', 'order'])

def test_sort_and_filter_accounts_empty_accounts(empty_arg):

    accounts = [Account(s) for s in ['Expenses:Other', 'Income:Other']]

    if empty_arg == 'accounts':

        args = ([], accounts)

    else:

        args = (accounts, [])

    actual = core.sort_and_filter_accounts(*args)

    assert next(actual, None) is None