else:

                # Filter out new accruals after the report date.

                # e.g., cover the case that the same invoices has multiple

                # postings over time, and we don't want to report too-recent

                # ones.

                cutoff_date = self.ods.date - datetime.timedelta(

                    days=group.accrual_type.value.aging_thresholds[-1],

                )

                group = AccrualPostings(

                    post for post in group.since_last_nonzero()

                    if post.meta.date <= cutoff_date

                    or group.accrual_type.normalize_amount(post.units.number) < 0

                )

            if group and not group.is_zero():

                rows.append(group)

        rows.sort(key=lambda related: (

            related.account,

            related[0].meta.date,

            ('\0'.join(related.entities())

             if related.entity is related.INCONSISTENT

             else related.entity),

        ))

        self.ods.write(rows)

        self.ods.save_file(self.out_bin)

class BalanceReport(BaseReport):

    def _report(self, posts: AccrualPostings, index: int) -> Iterable[str]:

        posts = posts.since_last_nonzero()

        date_s = posts[0].meta.date.strftime('%Y-%m-%d')

        balance_s = posts.balance_at_cost().format(zero="Zero balance")

        if index:

            yield ""

        yield f"{posts.invoice}:"

        yield f"  {balance_s} outstanding since {date_s}"

class OutgoingReport(BaseReport):

    PAYMENT_METHODS = {

        'ach': 'ACH',

        'check': 'Check',

        'creditcard': 'Credit Card',

        'debitcard': 'Debit Card',

        'fxwire': 'International Wire',

        'paypal': 'PayPal',

        'uswire': 'Domestic Wire',

        'vendorportal': 'Vendor Portal',

    }

    def __init__(self, rt_wrapper: rtutil.RT, out_file: TextIO) -> None:

        super().__init__(out_file)

        self.rt_wrapper = rt_wrapper

        self.rt_client = rt_wrapper.rt

    def _primary_rt_id(self, posts: AccrualPostings) -> rtutil.TicketAttachmentIds:

        rt_id = posts.rt_id

        if rt_id is None:

            raise ValueError("no rt-id links found")

        elif isinstance(rt_id, Sentinel):

            raise ValueError("multiple rt-id links found")

        parsed = rtutil.RT.parse(rt_id)

        if parsed is None:

            raise ValueError("rt-id is not a valid RT reference")

        else:

            return parsed

    def _report(self, posts: AccrualPostings, index: int) -> Iterable[str]:

        posts = posts.since_last_nonzero()

        try:

            ticket_id, _ = self._primary_rt_id(posts)

            ticket = self.rt_client.get_ticket(ticket_id)

            # Note we only use this when ticket is None.

            errmsg = f"ticket {ticket_id} not found"

        except (ValueError, rt.RtError) as error:

            ticket = None

            errmsg = error.args[0]

        if ticket is None:

            self.logger.error(

                "can't generate outgoings report for %s because no RT ticket available: %s",

                posts.invoice, errmsg,

            )

            return

        try:

            rt_requestor = self.rt_client.get_user(ticket['Requestors'][0])

        except (IndexError, rt.RtError):

            rt_requestor = None

        if rt_requestor is None:

            requestor = ''

            requestor_name = ''

        else:

            requestor_name = (

                rt_requestor.get('RealName')

                or ticket.get('CF.{payment-to}')

                or ''

            )

            requestor = f'{requestor_name} <{rt_requestor["EmailAddress"]}>'.strip()

        balance_s = posts.end_balance.format(None)

        raw_balance = -posts.balance()

        payment_amount = raw_balance.format('¤¤ #,##0.00')

        if raw_balance != posts.end_balance:

            payment_amount += f' ({balance_s})'

            balance_s = f'{raw_balance} ({balance_s})'

        payment_to = ticket.get('CF.{payment-to}') or requestor_name

        contract_links = list(posts.all_meta_links('contract'))

        if contract_links:

            contract_s = ' , '.join(self.rt_wrapper.iter_urls(

                contract_links, missing_fmt='<BROKEN RT LINK: {}>',

            ))

        else:

            contract_s = "NO CONTRACT GOVERNS THIS TRANSACTION"

        projects = [v for v in posts.meta_values('project')

                    if isinstance(v, str)]

        yield "PAYMENT FOR APPROVAL:"

        yield f"REQUESTOR: {requestor}"

        yield f"PAYMENT TO: {payment_to}"

        yield f"TOTAL TO PAY: {balance_s}"

        yield f"AGREEMENT: {contract_s}"

        yield f"PROJECT: {', '.join(projects)}"

        yield "\nBEANCOUNT ENTRIES:\n"

        last_txn: Optional[Transaction] = None

        for post in posts:

            txn = post.meta.txn

            if txn is not last_txn:

                last_txn = txn

                txn = self.rt_wrapper.txn_with_urls(txn, '{}')

                # Suppress payment-method metadata from the report.

                txn.meta.pop('payment-method', None)

                for txn_post in txn.postings:

                    if txn_post.meta:

                        txn_post.meta.pop('payment-method', None)

                yield bc_printer.format_entry(txn)

        cf_targets = {

            'payment-amount': payment_amount,

            'payment-to': payment_to,

        }

            self.logger.warning(

                "cannot set payment-method for rt:%s: %s metadata values found",

                ticket_id, payment_method_count,

            )

        else:

            if match is None:

                self.logger.warning(

                    "cannot set payment-method for rt:%s: invalid value %r",

                    ticket_id, payment_method,

                )

            else:

                cf_targets['payment-method'] = '{} {}'.format(

                    match.group(1).upper(),

                )

        cf_updates = {

            f'CF_{key}': value

            for key, value in cf_targets.items()

            if ticket.get(f'CF.{{{key}}}') != value

        }

        if cf_updates:

            try:

                ok = self.rt_client.edit_ticket(ticket_id, **cf_updates)

            except rt.RtError:

                self.logger.debug("RT exception on edit_ticket", exc_info=True)

                ok = False

            if not ok:

                self.logger.warning("failed to set custom fields for rt:%s", ticket_id)

class ReportType(enum.Enum):

    AGING = AgingReport

    BALANCE = BalanceReport

    OUTGOING = OutgoingReport

    AGE = AGING

    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

class ReturnFlag(enum.IntFlag):

    LOAD_ERRORS = 1

    # 2 was used in the past, it can probably be reclaimed.

    REPORT_ERRORS = 4

    NOTHING_TO_REPORT = 8

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)

#!/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

        # 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

        'rt>=2.0',

    ],

    setup_requires=[

        'pytest-mypy',

        'pytest-runner',  # Debian:python3-pytest-runner

    ],

    tests_require=[

        'mypy>=0.770',  # Debian:python3-mypy

        'pytest',  # Debian:python3-pytest

    ],

    packages=[

        'conservancy_beancount',

        'conservancy_beancount.plugin',

        'conservancy_beancount.reports',

    ],

    entry_points={

        'console_scripts': [

            'accrual-report = conservancy_beancount.reports.accrual:entry_point',

            'fund-report = conservancy_beancount.reports.fund:entry_point',

            'ledger-report = conservancy_beancount.reports.ledger:entry_point',

        ],

    },

)