def from_arg(cls, arg: str) -> int:

        try:

            return cls[arg.upper()].value

        except KeyError:

            raise ValueError(f"unknown loglevel {arg!r}") from None

    @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.

    Typical usage looks like::

      argument_parser.add_argument(

        'search_terms',

        type=SearchTerm.arg_parser(),

    BAL = BALANCE

    OUT = OUTGOING

    OUTGOINGS = OUTGOING

    @classmethod

    def by_name(cls, name: str) -> 'ReportType':

        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:

        postings = query.filter_postings(postings)

    return postings

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

    parser = argparse.ArgumentParser(prog=PROGNAME)

    cliutil.add_version_argument(parser)

        config.load_file()

    returncode = 0

    books_loader = config.books_loader()

    if books_loader is None:

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

    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().

    groups: PostGroups

    if args.report_type is None or args.report_type is ReportType.OUTGOING:

        groups = dict(AccrualPostings.group_by_first_meta_link(postings, 'rt-id'))

        if args.report_type is None and len(groups) == 1:

            key = next(iter(groups))

            group = groups[key]

    elif args.report_type is ReportType.OUTGOING:

        rt_wrapper = config.rt_wrapper()

        if rt_wrapper is None:

            logger.error("unable to generate outgoing report: RT client is required")

        else:

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

            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())

    ODS = ODSReport

    TXT = TEXT

    SPREADSHEET = ODS

    @classmethod

    def from_arg(cls, s: str) -> 'ReportType':

        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',

        metavar='DATE',

        type=cliutil.date_arg,

        help="""Date to start reporting entries, inclusive, in YYYY-MM-DD format.

The default is one year ago.

""")

    parser.add_argument(

            args.stop_date = diff_year(args.start_date, 1)

    if args.start_date is None:

        args.start_date = diff_year(args.stop_date, -1)

    returncode = 0

    books_loader = config.books_loader()

    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

    )

    for search_term in args.search_terms:

        postings = search_term.filter_postings(postings)

    fund_postings = {

        key: related

        for key, related in core.RelatedPostings.group_by_meta(postings, 'project')

        if isinstance(key, str)

    }

    period_cls = core.PeriodPostings.with_start_date(args.start_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)

        ods_report.write(fund_map.items())

        if args.output_file is None:

            out_dir_path = config.repository_path() or Path()

            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.units))

                self.add_row(

                    odf.table.TableCell(),

                    odf.table.TableCell(),

                    self.string_cell(post.account),

                    self.string_cell(post.meta.get('entity') or ''),

                    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,

    ) -> None:

        namespace.txn_filter = self.const

        if namespace.accounts is None:

            namespace.accounts = []

        namespace.accounts.append('Assets:PayPal')

        namespace.accounts.append('Cash')

            args.stop_date = today + datetime.timedelta(days=30)

    elif args.stop_date is None:

        args.stop_date = diff_year(args.start_date, 1)

    returncode = 0

    books_loader = config.books_loader()

    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)

    rt_wrapper = config.rt_wrapper()

    if rt_wrapper is None:

        logger.warning("could not initialize RT client; spreadsheet links will be broken")

    try:

        if args.txn_filter is None:

            report = LedgerODS(

                rt_wrapper,

                args.sheet_size,

                args.show_totals,

                args.add_totals,

                args.txn_filter,

            )

    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())

        if project is None:

            meta: Optional[Dict[MetaKey, MetaValue]] = None

        else:

            meta = {meta_key: project}

        for units, cost in sorted(inventory, key=cls._position_sortkey):

            if cost is None:

                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',

        metavar='KEY',

        dest='meta_key',

        default='project',

        help="""Name of the fund metadata key. Default %(default)s.

""")

    parser.add_argument(

        args.as_of_date = fy.for_date()

    if isinstance(args.as_of_date, int):

        args.as_of_date = fy.first_date(args.as_of_date)

    returncode = 0

    books_loader = config.books_loader()

    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

        fund_acct_match = post.account.is_under(*FUND_ACCOUNTS)

        is_equity = account.root_part() in EQUITY_ACCOUNTS

        if fund_acct_match is None:

            project: MetaValue = None

        else:

            project = post.meta.get(args.meta_key)

         for post in Posting.build_opening(key, args.meta_key, inventories[key])

        ])

    balance = Balance(get_cost(get_position(post))

                      for post in opening.postings)

    for amount in balance.clean_copy().values():

        opening.postings.append(bc_data.Posting(

            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())

    if arglist:

        recv_rows = [row for row in AGING_AR if 'Lawyer' in row.entity]

        pay_rows = [row for row in AGING_AP if 'Lawyer' in row.entity]

    else:

        recv_rows = AGING_AR

        pay_rows = AGING_AP

    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'),

    ])

])

def test_ods_report(start_date, stop_date):

    retcode, output, errors = run_main(io.BytesIO, [

        '--begin', start_date.isoformat(), '--end', stop_date.isoformat(),

    ])

    assert not errors.getvalue()

    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)

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

    'Assets:NoneSuchBank',

    'Funny money',

])

def test_main_invalid_account(caplog, arg):

    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)