logger = logging.getLogger('conservancy_beancount.reports.accrual')

class Account(NamedTuple):

    name: str

    aging_thresholds: Sequence[int]

class AccrualAccount(enum.Enum):

    # Note the aging report uses the same order accounts are defined here.

    # See AgingODS.start_spreadsheet().

    RECEIVABLE = Account('Assets:Receivable', [365, 120, 90, 60])

    PAYABLE = Account('Liabilities:Payable', [365, 90, 60, 30])

    PREPAID = Account('Assets:Prepaid', [365, 120, 90, 60])

    @classmethod

    def account_names(cls) -> Iterator[str]:

        return (acct.value.name for acct in cls)

    @classmethod

    def by_account(cls, name: data.Account) -> 'AccrualAccount':

        for account in cls:

            if name.is_under(account.value.name):

                return account

        raise ValueError(f"unrecognized account {name!r}")

    @classmethod

    def classify(cls, related: core.RelatedPostings) -> 'AccrualAccount':

        for account in cls:

            account_name = account.value.name

            if all(post.account.is_under(account_name) for post in related):

                return account

        raise ValueError("unrecognized account set in related postings")

    @property

    def normalize_amount(self) -> Callable[[T], T]:

        return core.normalize_amount_func(self.value.name)

class AccrualPostings(core.RelatedPostings):

    __slots__ = ()

    @classmethod

    def make_consistent(cls,

                        postings: Iterable[data.Posting],

    ) -> Iterator[Tuple[Hashable, 'AccrualPostings']]:

        accruals: Dict[Tuple[str, ...], List[data.Posting]] = collections.defaultdict(list)

        payments: Dict[Tuple[str, ...], Deque[data.Posting]] = collections.defaultdict(Deque)

        key: Tuple[str, ...]

        for post in postings:

            norm_func = core.normalize_amount_func(post.account)

            entity = str(post.meta.get('entity', 'BlankEntity'))

                invoice = entity

            else:

                invoice = str(post.meta.get('invoice', 'BlankInvoice'))

            if norm_func(post.units.number) >= 0:

                key = (post.meta.date.isoformat(), entity, invoice, post.account)

                accruals[key].append(post)

            else:

                key = (invoice, post.account)

                payments[key].append(post)

        for key, acc_posts in accruals.items():

            pay_posts = payments[key[2:]]

            if not pay_posts:

                continue

            norm_func = core.normalize_amount_func(key[-1])

            balance = norm_func(core.MutableBalance(post.at_cost() for post in acc_posts))

            while pay_posts and not balance.le_zero():

                pay_post = pay_posts.popleft()

                acc_posts.append(pay_post)

                balance += norm_func(pay_post.at_cost())

            if balance.le_zero() and not balance.is_zero():

                # pay_post causes the accrual to be overpaid. Split it into two

                # synthesized postings: one that causes the accrual to be

                # exactly zero, and one with the remainder back in payments.

                post_cost = pay_post.at_cost()

                # Calling norm_func() reverses the call in the while loop to add

                # the amount to the balance.

                overpayment = norm_func(balance[post_cost.currency])

                amt_to_zero = post_cost._replace(number=post_cost.number - overpayment.number)

                acc_posts[-1] = pay_post._replace(units=amt_to_zero, cost=None, price=None)

                pay_posts.appendleft(pay_post._replace(units=overpayment, cost=None, price=None))

            acc_posts.sort(key=lambda post: post.meta.date)

        for key, acc_posts in accruals.items():

            yield key, cls(acc_posts, _can_own=True)

        for key, pay_posts in payments.items():

            if pay_posts:

                yield key, cls(pay_posts, _can_own=True)

    def is_paid(self) -> Optional[bool]:

        try:

            accrual_type = AccrualAccount.classify(self)

        except ValueError:

            return None

        else:

            return accrual_type.normalize_amount(self.balance()).le_zero()

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

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

        'conservancy_beancount.tools',

    ],

    entry_points={

        'console_scripts': [

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

            'assemble-audit-reports = conservancy_beancount.tools.audit_report:entry_point',

            'balance-sheet-report = conservancy_beancount.reports.balance_sheet:entry_point',

            'bean-sort = conservancy_beancount.tools.sort_entries:entry_point',

            'extract-odf-links = conservancy_beancount.tools.extract_odf_links:entry_point',

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

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

            'opening-balances = conservancy_beancount.tools.opening_balances:entry_point',

            'split-ods-links = conservancy_beancount.tools.split_ods_links:entry_point',

        ],

    },

)