import logging

import operator

import os

import pkg_resources

import re

import signal

import sys

import traceback

import types

from pathlib import Path

from . import data

from . import filters

from . import rtutil

from typing import (

    cast,

    Any,

    BinaryIO,

    Callable,

    IO,

    Iterable,

    NamedTuple,

    Union,

)

from .beancount_types import (

    MetaKey,

)

OutputFile = Union[int, IO]

STDSTREAM_PATH = Path('-')

VERSION = pkg_resources.require(PKGNAME)[0].version

class ExceptHook:

        if logger is None:

            logger = logging.getLogger()

        self.logger = logger

    def __call__(self,

                 exc_type: Type[BaseException],

                 exc_value: BaseException,

                 exc_tb: types.TracebackType,

    ) -> NoReturn:

        if isinstance(exc_value, KeyboardInterrupt):

            signal.signal(signal.SIGINT, signal.SIG_DFL)

            os.kill(0, signal.SIGINT)

            signal.pause()

        elif isinstance(exc_value, OSError):

        else:

        self.logger.debug(

            ''.join(traceback.format_exception(exc_type, exc_value, exc_tb)),

        )

        raise SystemExit(exitcode)

class InfoAction(argparse.Action):

    def __call__(self,

                 parser: argparse.ArgumentParser,

                 namespace: argparse.Namespace,

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

                 option_string: Optional[str]=None,

    ) -> NoReturn:

        if isinstance(self.const, str):

            info = self.const

            exitcode = 0

        else:

            info, exitcode = self.const

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

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

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

    if args.stop_date is None:

        if args.start_date is None:

            args.stop_date = datetime.date.today()

        else:

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

    if args.start_date is None:

        args.start_date = cliutil.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.set_common_properties(config.books_repo())

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

    today = datetime.date.today()

    if args.start_date is None:

        args.start_date = cliutil.diff_year(today, -1)

        if args.stop_date is None:

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

    elif args.stop_date is None:

        args.stop_date = cliutil.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(

                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.set_common_properties(config.books_repo())

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

        config.load_file()

    fy = config.fiscal_year_begin()

    if args.as_of_date is None:

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

#!/usr/bin/env python3

from setuptools import setup

setup(

    name='conservancy_beancount',

    description="Plugin, library, and reports for reading Conservancy's books",

    author='Software Freedom Conservancy',

    author_email='info@sfconservancy.org',

    license='GNU AGPLv3+',

    install_requires=[

        'babel>=2.6',  # Debian:python3-babel

        'beancount>=2.2',  # Debian:beancount

        'GitPython>=2.0',  # Debian:python3-git

        # 1.4.1 crashes when trying to save some documents.

        'odfpy>=1.4.0,!=1.4.1',  # Debian:python3-odf

        'PyYAML>=3.0',  # Debian:python3-yaml

        'regex',  # Debian:python3-regex

    actual = cliutil.text_output(path, stream)

    assert actual is stream

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

    errno.EACCES,

    errno.EPERM,

    errno.ENOENT,

])

def test_excepthook_oserror(errnum, caplog):

    error = OSError(errnum, os.strerror(errnum), 'TestFilename')

    with pytest.raises(SystemExit) as exc_check:

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

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

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

            rt_client=RTClient(),

        )

    if out_type is io.BytesIO:

        arglist.insert(0, '--output-file=-')

    output = out_type()

    errors = io.StringIO()

    retcode = accrual.main(arglist, output, errors, config)

    output.seek(0)

    errors.seek(0)

    return retcode, output, errors

    retcode, output, errors = run_main(arglist, config)

    assert not output.getvalue()

    return errors

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

    ['--report-type=balance', 'entity=EarlyBird'],

    ['--report-type=outgoing', 'entity=EarlyBird'],

])

def test_output_excludes_payments(arglist):

    retcode, output, errors = run_main(arglist)

    assert not errors.getvalue()

    assert retcode == 0

    output.seek(0)

    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)