"""

        if ticket_default_key is None:

            ticket_default_key = default_key

        def parse_search_term(arg: str) -> 'SearchTerm':

            key: Optional[str] = None

            if re.match(r'^[a-z][-\w]*=', arg):

                key, _, raw_link = arg.partition('=')

            else:

                raw_link = arg

            rt_ids = rtutil.RT.parse(raw_link)

            if rt_ids is None:

                rt_ids = rtutil.RT.parse('rt:' + raw_link)

            if rt_ids is None:

                if key is None:

                    key = default_key

                pattern = r'(?:^|\s){}(?:\s|$)'.format(re.escape(raw_link))

            else:

                ticket_id, attachment_id = rt_ids

                if key is None:

                    if attachment_id is None:

                        key = ticket_default_key

                    else:

                        key = default_key

                pattern = rtutil.RT.metadata_regexp(

                    ticket_id,

                    attachment_id,

                    first_link_only=key == 'rt-id' and attachment_id is None,

                )

            if key is None:

                raise ValueError(f"invalid search term {arg!r}: no metadata key")

            return cls(key, pattern)

        return parse_search_term

    def filter_postings(self, postings: Iterable[data.Posting]) -> Iterable[data.Posting]:

        return filters.filter_meta_match(

            postings, self.meta_key, re.compile(self.pattern),

        )

def add_loglevel_argument(parser: argparse.ArgumentParser,

                          default: LogLevel=LogLevel.INFO) -> argparse.Action:

    return parser.add_argument(

        '--loglevel',

        metavar='LEVEL',

        default=default.value,

        type=LogLevel.from_arg,

        help="Show logs at this level and above."

        f" Specify one of {', '.join(LogLevel.choices())}."

        f" Default {default.name.lower()}.",

    )

def add_version_argument(parser: argparse.ArgumentParser) -> argparse.Action:

    progname = parser.prog or sys.argv[0]

    return parser.add_argument(

        '--version', '--copyright', '--license',

        action=InfoAction,

        nargs=0,

        const=f"{progname} version {VERSION}\n{LICENSE}",

        help="Show program version and license information",

    )

def date_arg(arg: str) -> datetime.date:

    return datetime.datetime.strptime(arg, '%Y-%m-%d').date()

def year_or_date_arg(arg: str) -> Union[int, datetime.date]:

    """Get either a date or a year (int) from an argument string

    This is a useful argument type for arguments that will be passed into

    Books loader methods which can accept either a fiscal year or a full date.

    """

    try:

        year = int(arg, 10)

    except ValueError:

        ok = False

    else:

        ok = datetime.MINYEAR <= year <= datetime.MAXYEAR

    if ok:

        return year

    else:

        return date_arg(arg)

def make_entry_point(mod_name: str, prog_name: str=sys.argv[0]) -> Callable[[], int]:

    """Create an entry_point function for a tool

    The returned function is suitable for use as an entry_point in setup.py.

    It sets up the root logger and excepthook, then calls the module's main

    function.

    """

    def entry_point():  # type:ignore

        prog_mod = sys.modules[mod_name]

        setup_logger()

        prog_mod.logger = logging.getLogger(prog_name)

        sys.excepthook = ExceptHook(prog_mod.logger)

        return prog_mod.main()

    return entry_point

def setup_logger(logger: Union[str, logging.Logger]='',

                 stream: TextIO=sys.stderr,

                 fmt: str='%(name)s: %(levelname)s: %(message)s',

) -> logging.Logger:

    """Set up a logger with a StreamHandler with the given format"""

    if isinstance(logger, str):

        logger = logging.getLogger(logger)

    formatter = logging.Formatter(fmt)

    handler = logging.StreamHandler(stream)

    handler.setFormatter(formatter)

    logger.addHandler(handler)

    return logger

def set_loglevel(logger: logging.Logger, loglevel: int=logging.INFO) -> None:

    """Set the loglevel for a tool or module

    If the given logger is not under a hierarchy, this function sets the

    loglevel for the root logger, along with some specific levels for libraries

    used by reporting tools. Otherwise, it's the same as

    ``logger.setLevel(loglevel)``.

    """

    if '.' not in logger.name:

        logger = logging.getLogger()

        if loglevel <= logging.DEBUG:

            # At the debug level, the rt module logs the full body of every

            # request and response. That's too much.

            logging.getLogger('rt.rt').setLevel(logging.INFO)

    logger.setLevel(loglevel)

def bytes_output(path: Optional[Path]=None,

                 default: OutputFile=sys.stdout,

                 mode: str='w',

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

        '--end', '--stop', '-e',

        dest='stop_date',

        metavar='DATE',

        type=cliutil.date_arg,

        help="""Date to stop reporting entries, exclusive, in YYYY-MM-DD format.

The default is a year after the start date.

""")

    parser.add_argument(

        '--report-type', '-t',

        metavar='TYPE',

        type=ReportType.from_arg,

        help="""Type of report to generate. `text` gives a plain two-column text

report listing accounts and balances over the period, and is the default when

you search for a specific project/fund. `ods` produces a higher-level

spreadsheet, meant to provide an overview of all funds, and is the default when

you don't specify a project/fund.

""")

    parser.add_argument(

        '--output-file', '-O',

        metavar='PATH',

        type=Path,

        help="""Write the report to this file, or stdout when PATH is `-`.

The default is stdout for text reports, and a generated filename for ODS

reports.

""")

    cliutil.add_loglevel_argument(parser)

    parser.add_argument(

        'search_terms',

        metavar='FILTER',

        type=cliutil.SearchTerm.arg_parser('project', 'rt-id'),

        nargs=argparse.ZERO_OR_MORE,

        help="""Report on postings that match this criteria. The format is

NAME=TERM. TERM is a link or word that must exist in a posting's NAME

metadata to match. A single ticket number is a shortcut for

`rt-id=rt:NUMBER`. Any other word is a shortcut for `project=TERM`.

""")

    args = parser.parse_args(arglist)

    if args.report_type is None:

        if any(term.meta_key == 'project' for term in args.search_terms):

            args.report_type = ReportType.TEXT

        else:

            args.report_type = ReportType.ODS

    return args

def main(arglist: Optional[Sequence[str]]=None,

         stdout: TextIO=sys.stdout,

         stderr: TextIO=sys.stderr,

         config: Optional[configmod.Config]=None,

) -> int:

    args = parse_arguments(arglist)

    cliutil.set_loglevel(logger, args.loglevel)

    if config is None:

        config = configmod.Config()

        config.load_file()

    if args.stop_date is None:

        if args.start_date is None:

            args.stop_date = datetime.date.today()

        else:

    if args.start_date is None:

    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)

        returncode |= cliutil.ReturnFlag.LOAD_ERRORS

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

        returncode |= cliutil.ReturnFlag.NOTHING_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)

    return cliutil.ReturnFlag.returncode(returncode)

entry_point = cliutil.make_entry_point(__name__, PROGNAME)

if __name__ == '__main__':

    exit(entry_point())

classification from metadata. If not specified, the default set adapts to your

search criteria.

""")

    parser.add_argument(

        '--show-totals', '-S',

        metavar='ACCOUNT',

        action='append',

        help="""When entries for this account appear in the report, include

account balance(s) as well. You can specify this option multiple times. Pass in

a part of the account hierarchy. The default is all accounts.

""")

    parser.add_argument(

        '--add-totals', '-T',

        metavar='ACCOUNT',

        action='append',

        help="""When an account could be included in the report but does not

have any entries in the date range, include a header and account balance(s) for

it. You can specify this option multiple times. Pass in a part of the account

hierarchy. The default set adapts to your search criteria.

""")

    parser.add_argument(

        '--sheet-size', '--size',

        metavar='SIZE',

        type=int,

        default=LedgerODS.SHEET_SIZE,

        help="""Try to limit sheets to this many rows. The report will

automatically create new sheets to make this happen. When that's not possible,

it will issue a warning.

""")

    parser.add_argument(

        '--output-file', '-O',

        metavar='PATH',

        type=Path,

        help="""Write the report to this file, or stdout when PATH is `-`.

The default is `LedgerReport_<StartDate>_<StopDate>.ods`.

""")

    cliutil.add_loglevel_argument(parser)

    parser.add_argument(

        'search_terms',

        metavar='FILTER',

        type=cliutil.SearchTerm.arg_parser('project', 'rt-id'),

        nargs=argparse.ZERO_OR_MORE,

        help="""Report on postings that match this criteria. The format is

NAME=TERM. TERM is a link or word that must exist in a posting's NAME

metadata to match. A single ticket number is a shortcut for

`rt-id=rt:NUMBER`. Any other word is a shortcut for `project=TERM`.

""")

    args = parser.parse_args(arglist)

    if args.add_totals is None and args.search_terms:

        args.add_totals = []

    if args.accounts is None:

        if any(term.meta_key == 'project' for term in args.search_terms):

            args.accounts = [

                'Income',

                'Expenses',

                'Assets:Receivable',

                'Assets:Prepaid',

                'Liabilities:UnearnedIncome',

                'Liabilities:Payable',

            ]

        else:

            args.accounts = list(LedgerODS.ACCOUNT_COLUMNS)

    return args

def main(arglist: Optional[Sequence[str]]=None,

         stdout: TextIO=sys.stdout,

         stderr: TextIO=sys.stderr,

         config: Optional[configmod.Config]=None,

) -> int:

    args = parse_arguments(arglist)

    cliutil.set_loglevel(logger, args.loglevel)

    if config is None:

        config = configmod.Config()

        config.load_file()

    today = datetime.date.today()

    if args.start_date is None:

        if args.stop_date is None:

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

    elif args.stop_date is None:

    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)

        returncode |= cliutil.ReturnFlag.LOAD_ERRORS

    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(

                args.start_date,

                args.stop_date,

                args.accounts,

                rt_wrapper,

                args.sheet_size,

                args.show_totals,

                args.add_totals,

            )

        else:

            report = TransactionODS(

                args.start_date,

                args.stop_date,

                args.accounts,

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

        returncode |= cliutil.ReturnFlag.NOTHING_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)

    return cliutil.ReturnFlag.returncode(returncode)

entry_point = cliutil.make_entry_point(__name__, PROGNAME)

if __name__ == '__main__':

    assert caplog.records

    for log in caplog.records:

        assert log.levelname == 'CRITICAL'

        assert log.message == f"I/O error: {error.filename}: {error.strerror}"

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

    AttributeError,

    RuntimeError,

    ValueError,

])

def test_excepthook_bug(exc_type, caplog):

    error = exc_type("test message")

    with pytest.raises(SystemExit) as exc_check:

        cliutil.ExceptHook()(exc_type, error, None)

    assert exc_check.value.args[0] == 3

    assert caplog.records

    for log in caplog.records:

        assert log.levelname == 'CRITICAL'

        assert log.message == f"internal {exc_type.__name__}: {error.args[0]}"

def test_excepthook_traceback(caplog):

    error = KeyError('test')

    args = (type(error), error, MockTraceback())

    caplog.set_level(logging.DEBUG)

    with pytest.raises(SystemExit) as exc_check:

        cliutil.ExceptHook()(*args)

    assert caplog.records

    assert caplog.records[-1].message == ''.join(traceback.format_exception(*args))

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

    ('debug', logging.DEBUG),

    ('info', logging.INFO),

    ('warning', logging.WARNING),

    ('warn', logging.WARNING),

    ('error', logging.ERROR),

    ('err', logging.ERROR),

    ('critical', logging.CRITICAL),

    ('crit', logging.CRITICAL),

])

def test_loglevel_argument(argparser, arg, expected):

    for method in ['lower', 'title', 'upper']:

        args = argparser.parse_args(['--loglevel', getattr(arg, method)()])

        assert args.loglevel is expected

def test_setup_logger():

    stream = io.StringIO()

    logger = cliutil.setup_logger(

        'test_cliutil', stream, '%(name)s %(levelname)s: %(message)s',

    )

    logger.critical("test crit")

    assert stream.getvalue() == "test_cliutil CRITICAL: test crit\n"

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

    '--license',

    '--version',

    '--copyright',

])

def test_version_argument(argparser, capsys, arg):

    with pytest.raises(SystemExit) as exc_check:

        args = argparser.parse_args(['--version'])

    assert exc_check.value.args[0] == 0

    stdout, _ = capsys.readouterr()

    lines = iter(stdout.splitlines())

    assert re.match(r'^test_cliutil version \d+\.\d+\.\d+', next(lines, "<EOF>"))