@classmethod

    def choices(cls) -> Iterable[str]:

        for level in sorted(cls, key=operator.attrgetter('value')):

            yield level.name.lower()

class SearchTerm(NamedTuple):

    """NamedTuple representing a user's metadata filter

    SearchTerm knows how to parse and store posting metadata filters provided

    by the user in `key=value` format. Reporting tools can use this to filter

    postings that match the user's criteria, to report on subsets of the books.

        try:

            return cls[name.upper()]

        except KeyError:

            raise ValueError(f"unknown report type {name!r}") from None

def filter_search(postings: Iterable[data.Posting],

                  search_terms: Iterable[cliutil.SearchTerm],

) -> Iterable[data.Posting]:

    accounts = tuple(AccrualAccount.account_names())

    postings = (post for post in postings if post.account.is_under(*accounts))

    for query in search_terms:

    else:

        load_since = None if args.report_type == ReportType.AGING else args.since

        entries, load_errors, _ = books_loader.load_all(load_since)

    filters.remove_opening_balance_txn(entries)

    for error in load_errors:

        bc_printer.print_error(error, file=stderr)

    postings = list(filter_search(

        data.Posting.from_entries(entries), args.search_terms,

    ))

    if not postings:

        logger.warning("no matching entries found to report")

    # groups is a mapping of metadata value strings to AccrualPostings.

    # The keys are basically arbitrary, the report classes don't rely on them,

    # but they do help symbolize what's being grouped.

    # For the outgoing approval report, groups maps rt-id link strings to

    # associated accruals.

    # For all other reports, groups comes from AccrualReport.make_consistent().

            report = OutgoingReport(rt_wrapper, out_file)

    else:

        out_file = cliutil.text_output(args.output_file, stdout)

        report = BalanceReport(out_file)

    if report is None:

    else:

        report.run(groups)

entry_point = cliutil.make_entry_point(__name__, PROGNAME)

if __name__ == '__main__':

    exit(entry_point())

        try:

            return cls[s.upper()]

        except KeyError:

            raise ValueError(f"no report type matches {s!r}") from None

def parse_arguments(arglist: Optional[Sequence[str]]=None) -> argparse.Namespace:

    parser = argparse.ArgumentParser(prog=PROGNAME)

    cliutil.add_version_argument(parser)

    parser.add_argument(

        '--begin', '--start', '-b',

        dest='start_date',

    if books_loader is None:

        entries, load_errors, _ = books.Loader.load_none(config.config_file_path())

    else:

        entries, load_errors, _ = books_loader.load_fy_range(args.start_date, args.stop_date)

    for error in load_errors:

        bc_printer.print_error(error, file=stderr)

    postings = (

        post

        for post in data.Posting.from_entries(entries)

        if post.meta.date < args.stop_date

    )

    fund_map = collections.OrderedDict(

        (fund, dict(period_cls.group_by_account(fund_postings[fund])))

        for fund in sorted(fund_postings, key=lambda s: locale.strxfrm(s.casefold()))

    )

    if not fund_map:

        logger.warning("no matching postings found to report")

    elif args.report_type is ReportType.TEXT:

        out_file = cliutil.text_output(args.output_file, stdout)

        report = TextReport(args.start_date, args.stop_date, out_file)

        report.write(fund_map.items())

    else:

        ods_report = ODSReport(args.start_date, args.stop_date)

            args.output_file = out_dir_path / 'FundReport_{}_{}.ods'.format(

                args.start_date.isoformat(), args.stop_date.isoformat(),

            )

            logger.info("Writing report to %s", args.output_file)

        ods_file = cliutil.bytes_output(args.output_file, stdout)

        ods_report.save_file(ods_file)

entry_point = cliutil.make_entry_point(__name__, PROGNAME)

if __name__ == '__main__':

    exit(entry_point())

                    amount_cell,

                    self.currency_cell(self.norm_func(post.at_cost())),

                    *meta_cells,

                )

class CashReportAction(argparse.Action):

    def __call__(self,

                 parser: argparse.ArgumentParser,

                 namespace: argparse.Namespace,

                 values: Union[Sequence[Any], str, None]=None,

                 option_string: Optional[str]=None,

    if books_loader is None:

        entries, load_errors, options = books.Loader.load_none(config.config_file_path())

    else:

        entries, load_errors, options = books_loader.load_fy_range(args.start_date, args.stop_date)

    for error in load_errors:

        bc_printer.print_error(error, file=stderr)

    data.Account.load_from_books(entries, options)

    postings = data.Posting.from_entries(entries)

    for search_term in args.search_terms:

        postings = search_term.filter_postings(postings)

    except ValueError as error:

        logger.error("%s: %r", *error.args)

        return 2

    report.write(postings)

    if not any(report.account_groups.values()):

        logger.warning("no matching postings found to report")

    if args.output_file is None:

        out_dir_path = config.repository_path() or Path()

        args.output_file = out_dir_path / '{}Report_{}_{}.ods'.format(

            report.report_name,

            args.start_date.isoformat(),

            args.stop_date.isoformat(),

        )

        logger.info("Writing report to %s", args.output_file)

    ods_file = cliutil.bytes_output(args.output_file, stdout)

    report.save_file(ods_file)

entry_point = cliutil.make_entry_point(__name__, PROGNAME)

if __name__ == '__main__':

    exit(entry_point())

                units = quantize_amount(units)

            yield bc_data.Posting(

                account, units, cost, None, None, copy.copy(meta),

            )

def parse_arguments(arglist: Optional[Sequence[str]]=None) -> argparse.Namespace:

    parser = argparse.ArgumentParser(prog=PROGNAME)

    cliutil.add_version_argument(parser)

    cliutil.add_loglevel_argument(parser)

    parser.add_argument(

        '--fund-metadata-key', '-m',

    if books_loader is None:

        entries, load_errors, _ = books.Loader.load_none(config.config_file_path())

    else:

        entries, load_errors, _ = books_loader.load_fy_range(0, args.as_of_date)

    for error in load_errors:

        bc_printer.print_error(error, file=stderr)

    inventories: Mapping[AccountWithFund, Inventory] = collections.defaultdict(Inventory)

    for post in Posting.from_entries(entries):

        if post.meta.date >= args.as_of_date:

            continue

        account = post.account

            UNRESTRICTED_ACCOUNT, quantize_amount(-amount), None, None, None,

            {args.meta_key: args.unrestricted_fund},

        ))

    dcontext = bc_dcontext.DisplayContext()

    dcontext.set_commas(True)

    bc_printer.print_entry(opening, dcontext, file=stdout)

entry_point = cliutil.make_entry_point(__name__, PROGNAME)

if __name__ == '__main__':

    exit(entry_point())

    retcode, output, errors = run_main(arglist, out_type=io.BytesIO)

    assert not errors.getvalue()

    assert retcode == 0

    check_aging_ods(output, datetime.date.today(), recv_rows, pay_rows)

def test_main_no_books():

    testutil.check_lines_match(iter(errors), [

        r':[01]: +no books to load in configuration\b',

    ])

@pytest.mark.parametrize('arglist', [

    ['499'],

    ['505/99999'],

    ['-t', 'balance', 'entity=NonExistent'],

])

def test_main_no_matches(arglist, caplog):

    testutil.check_logs_match(caplog, [

        ('WARNING', 'no matching entries found to report'),

    ])

def test_main_no_rt(caplog):

    config = testutil.TestConfig(

        books_path=testutil.test_path('books/accruals.beancount'),

    )

    testutil.check_logs_match(caplog, [

        ('ERROR', 'unable to generate outgoing report: RT client is required'),

    ])

    assert retcode == 0

    ods = odf.opendocument.load(output)

    check_ods_report(ods, start_date, stop_date)

def test_main_no_postings(caplog):

    retcode, output, errors = run_main(io.StringIO, ['NonexistentProject'])

    assert any(log.levelname == 'WARNING' for log in caplog.records)

    retcode, output, errors = run_main(['-a', arg])

    assert retcode == 2

    assert any(log.message.endswith(f': {arg!r}') for log in caplog.records)

def test_main_no_postings(caplog):

    retcode, output, errors = run_main(['NonexistentProject'])

    assert any(log.levelname == 'WARNING' for log in caplog.records)