Changeset - 58b02b6f33c2
Parent rev.
Child rev.
[Not reviewed]
0 1 0
Brett Smith - 4 years ago 2020-06-03 22:51:48
brettcsmith@brettcsmith.org
accrual: Move more functionality into AccrualPostings.
1 file changed with 32 insertions and 26 deletions:
conservancy_beancount/reports/accrual.py
32
26
0 comments (0 inline, 0 general)
conservancy_beancount/reports/accrual.py
➞
Show inline comments
...
 
@@ -106,69 +106,62 @@ PROGNAME = 'accrual-report'
 

			




	
	
	
		
 
PostGroups = Mapping[Optional[MetaValue], 'AccrualPostings']


			




	
	
	
		
 
RTObject = Mapping[str, str]


			




	
	
	
		
 

			




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


			




	
	
	
		
 

			




	
	
	
		
 
class Sentinel:


			




	
	
	
		
 
    pass


			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
class Account(NamedTuple):


			




	
	
	
		
 
    name: str


			




	
	
	
		
 
    balance_paid: Callable[[core.Balance], bool]


			




	
	
	
		
 
    norm_func: Callable[[core.Balance], core.Balance]


			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
class AccrualAccount(enum.Enum):


			




	
	
	
		
 
    PAYABLE = Account('Liabilities:Payable', core.Balance.ge_zero)


			




	
	
	
		
 
    RECEIVABLE = Account('Assets:Receivable', core.Balance.le_zero)


			




	
	
	
		
 
    PAYABLE = Account('Liabilities:Payable', operator.neg)


			




	
	
	
		
 
    RECEIVABLE = Account('Assets:Receivable', lambda bal: bal)


			




	
	
	
		
 

			




	
	
	
		
 
    @classmethod


			




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


			




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


			




	
	
	
		
 

			




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


			




	
	
	
		
 

			




	
	
	
		
 
    @classmethod


			




	
	
	
		
 
    def filter_paid_accruals(cls, groups: PostGroups) -> PostGroups:


			




	
	
	
		
 
        return {


			




	
	
	
		
 
            key: related


			




	
	
	
		
 
            for key, related in groups.items()


			




	
	
	
		
 
            if not cls.classify(related).value.balance_paid(related.balance())


			




	
	
	
		
 
        }


			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
class AccrualPostings(core.RelatedPostings):


			




	
	
	
		
 
    def _meta_getter(key: MetaKey) -> Callable[[data.Posting], MetaValue]:  # type:ignore[misc]


			




	
	
	
		
 
        def meta_getter(post: data.Posting) -> MetaValue:


			




	
	
	
		
 
            return post.meta.get(key)


			




	
	
	
		
 
        return meta_getter


			




	
	
	
		
 

			




	
	
	
		
 
    _FIELDS: Dict[str, Callable[[data.Posting], MetaValue]] = {


			




	
	
	
		
 
        'account': operator.attrgetter('account'),


			




	
	
	
		
 
        'contract': _meta_getter('contract'),


			




	
	
	
		
 
        'cost': operator.attrgetter('cost'),


			




	
	
	
		
 
        'entity': _meta_getter('entity'),


			




	
	
	
		
 
        'invoice': _meta_getter('invoice'),


			




	
	
	
		
 
        'purchase_order': _meta_getter('purchase-order'),


			




	
	
	
		
 
    }


			




	
	
	
		
 
    INCONSISTENT = Sentinel()


			




	
	
	
		
 
    __slots__ = (


			




	
	
	
		
 
        'accrual_type',


			




	
	
	
		
 
        'final_bal',


			




	
	
	
		
 
        'account',


			




	
	
	
		
 
        'accounts',


			




	
	
	
		
 
        'contract',


			




	
	
	
		
 
        'contracts',


			




	
	
	
		
 
        'cost',


			




	
	
	
		
 
        'costs',


			




	
	
	
		
 
        'entity',


			




	
	
	
		
 
        'entitys',


			




	
	
	
		
 
        'entities',


			




	
	
	
		
 
        'invoice',


			




	
	
	
		
 
        'invoices',


			




	
	
	
		
 
        'purchase_order',


			




	...
	
		
 
@@ -189,26 +182,28 @@ class AccrualPostings(core.RelatedPostings):


			




	
	
	
		
 
        for name, get_func in self._FIELDS.items():


			




	
	
	
		
 
            values = frozenset(get_func(post) for post in self)


			




	
	
	
		
 
            setattr(self, f'{name}s', values)


			




	
	
	
		
 
            if len(values) == 1:


			




	
	
	
		
 
                one_value = next(iter(values))


			




	
	
	
		
 
            else:


			




	
	
	
		
 
                one_value = self.INCONSISTENT


			




	
	
	
		
 
            setattr(self, name, one_value)


			




	
	
	
		
 
        # Correct spelling = bug prevention for future users of this class.


			




	
	
	
		
 
        self.entities = self.entitys


			




	
	
	
		
 
        if self.account is self.INCONSISTENT:


			




	
	
	
		
 
            self.accrual_type: Optional[AccrualAccount] = None


			




	
	
	
		
 
            self.final_bal = self.balance()


			




	
	
	
		
 
        else:


			




	
	
	
		
 
            self.accrual_type = AccrualAccount.classify(self)


			




	
	
	
		
 
            self.final_bal = self.accrual_type.value.norm_func(self.balance())


			




	
	
	
		
 

			




	
	
	
		
 
    def make_consistent(self) -> Iterator[Tuple[MetaValue, 'AccrualPostings']]:


			




	
	
	
		
 
        account_ok = isinstance(self.account, str)


			




	
	
	
		
 
        # `'/' in self.invoice` is just our heuristic to ensure that the


			




	
	
	
		
 
        # invoice metadata is "unique enough," and not just a placeholder


			




	
	
	
		
 
        # value like "FIXME". It can be refined if needed.


			




	
	
	
		
 
        invoice_ok = isinstance(self.invoice, str) and '/' in self.invoice


			




	
	
	
		
 
        if account_ok and invoice_ok:


			




	
	
	
		
 
            yield (self.invoice, self)


			




	
	
	
		
 
            return


			




	
	
	
		
 
        groups = collections.defaultdict(list)


			




	
	
	
		
 
        for post in self:


			




	...
	
		
 
@@ -223,60 +218,72 @@ class AccrualPostings(core.RelatedPostings):


			




	
	
	
		
 

			




	
	
	
		
 
    def report_inconsistencies(self) -> Iterable[Error]:


			




	
	
	
		
 
        for field_name, get_func in self._FIELDS.items():


			




	
	
	
		
 
            if getattr(self, field_name) is self.INCONSISTENT:


			




	
	
	
		
 
                for post in self:


			




	
	
	
		
 
                    errmsg = 'inconsistent {} for invoice {}: {}'.format(


			




	
	
	
		
 
                        field_name.replace('_', '-'),


			




	
	
	
		
 
                        self.invoice or "<none>",


			




	
	
	
		
 
                        get_func(post),


			




	
	
	
		
 
                    )


			




	
	
	
		
 
                    yield Error(post.meta, errmsg, post.meta.txn)


			




	
	
	
		
 

			




	
	
	
		
 
    def is_paid(self, default: Optional[bool]=None) -> Optional[bool]:


			




	
	
	
		
 
        if self.accrual_type is None:


			




	
	
	
		
 
            return default


			




	
	
	
		
 
        else:


			




	
	
	
		
 
            return self.final_bal.le_zero()


			




	
	
	
		
 

			




	
	
	
		
 
class BaseReport:


			




	
	
	
		
 
    def __init__(self, out_file: TextIO) -> None:


			




	
	
	
		
 
        self.out_file = out_file


			




	
	
	
		
 
        self.logger = logger.getChild(type(self).__name__)


			




	
	
	
		
 
    def is_zero(self, default: Optional[bool]=None) -> Optional[bool]:


			




	
	
	
		
 
        if self.accrual_type is None:


			




	
	
	
		
 
            return default


			




	
	
	
		
 
        else:


			




	
	
	
		
 
            return self.final_bal.is_zero()


			




	
	
	
		
 

			




	
	
	
		
 
    def _since_last_nonzero(self, posts: AccrualPostings) -> AccrualPostings:


			




	
	
	
		
 
        for index, (post, balance) in enumerate(posts.iter_with_balance()):


			




	
	
	
		
 
    def since_last_nonzero(self) -> 'AccrualPostings':


			




	
	
	
		
 
        for index, (post, balance) in enumerate(self.iter_with_balance()):


			




	
	
	
		
 
            if balance.is_zero():


			




	
	
	
		
 
                start_index = index


			




	
	
	
		
 
        try:


			




	
	
	
		
 
            empty = start_index == index


			




	
	
	
		
 
        except NameError:


			




	
	
	
		
 
            empty = True


			




	
	
	
		
 
        return posts if empty else AccrualPostings(posts[start_index + 1:])


			




	
	
	
		
 
        return self if empty else self[start_index + 1:]


			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
class BaseReport:


			




	
	
	
		
 
    def __init__(self, out_file: TextIO) -> None:


			




	
	
	
		
 
        self.out_file = out_file


			




	
	
	
		
 
        self.logger = logger.getChild(type(self).__name__)


			




	
	
	
		
 

			




	
	
	
		
 
    def _report(self,


			




	
	
	
		
 
                invoice: str,


			




	
	
	
		
 
                posts: AccrualPostings,


			




	
	
	
		
 
                index: int,


			




	
	
	
		
 
    ) -> Iterable[str]:


			




	
	
	
		
 
        raise NotImplementedError("BaseReport._report")


			




	
	
	
		
 

			




	
	
	
		
 
    def run(self, groups: PostGroups) -> None:


			




	
	
	
		
 
        for index, invoice in enumerate(groups):


			




	
	
	
		
 
            for line in self._report(str(invoice), groups[invoice], index):


			




	
	
	
		
 
                print(line, file=self.out_file)


			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
class BalanceReport(BaseReport):


			




	
	
	
		
 
    def _report(self,


			




	
	
	
		
 
                invoice: str,


			




	
	
	
		
 
                posts: AccrualPostings,


			




	
	
	
		
 
                index: int,


			




	
	
	
		
 
    ) -> Iterable[str]:


			




	
	
	
		
 
        posts = self._since_last_nonzero(posts)


			




	
	
	
		
 
        posts = posts.since_last_nonzero()


			




	
	
	
		
 
        balance = posts.balance()


			




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


			




	
	
	
		
 
        if index:


			




	
	
	
		
 
            yield ""


			




	
	
	
		
 
        yield f"{invoice}:"


			




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


			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
class OutgoingReport(BaseReport):


			




	
	
	
		
 
    def __init__(self, rt_client: rt.Rt, out_file: TextIO) -> None:


			




	
	
	
		
 
        super().__init__(out_file)


			




	
	
	
		
 
        self.rt_client = rt_client


			




	...
	
		
 
@@ -289,25 +296,25 @@ class OutgoingReport(BaseReport):


			




	
	
	
		
 
            raise ValueError(f"{rt_ids_count} rt-id links found")


			




	
	
	
		
 
        parsed = rtutil.RT.parse(rt_ids.pop())


			




	
	
	
		
 
        if parsed is None:


			




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


			




	
	
	
		
 
        else:


			




	
	
	
		
 
            return parsed


			




	
	
	
		
 

			




	
	
	
		
 
    def _report(self,


			




	
	
	
		
 
                invoice: str,


			




	
	
	
		
 
                posts: AccrualPostings,


			




	
	
	
		
 
                index: int,


			




	
	
	
		
 
    ) -> Iterable[str]:


			




	
	
	
		
 
        posts = self._since_last_nonzero(posts)


			




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


			




	
	
	
		
 
                invoice, errmsg,


			




	...
	
		
 
@@ -320,31 +327,30 @@ class OutgoingReport(BaseReport):


			




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


			




	
	
	
		
 

			




	
	
	
		
 
        raw_balance = -posts.balance()


			




	
	
	
		
 
        cost_balance = -posts.balance_at_cost()


			




	
	
	
		
 
        cost_balance_s = cost_balance.format(None)


			




	
	
	
		
 
        if raw_balance == cost_balance:


			




	
	
	
		
 
        if posts.final_bal == cost_balance:


			




	
	
	
		
 
            balance_s = cost_balance_s


			




	
	
	
		
 
        else:


			




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


			




	
	
	
		
 
            balance_s = f'{posts.final_bal} ({cost_balance_s})'


			




	
	
	
		
 

			




	
	
	
		
 
        contract_links = 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:"


			




	...
	
		
 
@@ -373,26 +379,26 @@ class ReportType(enum.Enum):


			




	
	
	
		
 
    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


			




	
	
	
		
 

			




	
	
	
		
 
    @classmethod


			




	
	
	
		
 
    def default_for(cls, groups: PostGroups) -> 'ReportType':


			




	
	
	
		
 
        if len(groups) == 1 and all(


			




	
	
	
		
 
                AccrualAccount.classify(group) is AccrualAccount.PAYABLE


			




	
	
	
		
 
                and not AccrualAccount.PAYABLE.value.balance_paid(group.balance())


			




	
	
	
		
 
                group.accrual_type is AccrualAccount.PAYABLE


			




	
	
	
		
 
                and not group.is_paid()


			




	
	
	
		
 
                for group in groups.values()


			




	
	
	
		
 
        ):


			




	
	
	
		
 
            return cls.OUTGOING


			




	
	
	
		
 
        else:


			




	
	
	
		
 
            return cls.BALANCE


			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
class ReturnFlag(enum.IntFlag):


			




	
	
	
		
 
    LOAD_ERRORS = 1


			




	
	
	
		
 
    CONSISTENCY_ERRORS = 2


			




	
	
	
		
 
    REPORT_ERRORS = 4


			




	
	
	
		
 
    NOTHING_TO_REPORT = 8


			




	...
	
		
 
@@ -492,25 +498,25 @@ def main(arglist: Optional[Sequence[str]]=None,


			




	
	
	
		
 
    if books_loader is not None:


			




	
	
	
		
 
        entries, load_errors, _ = books_loader.load_fy_range(args.since)


			




	
	
	
		
 
    else:


			




	
	
	
		
 
        entries = []


			




	
	
	
		
 
        source = {


			




	
	
	
		
 
            'filename': str(config.config_file_path()),


			




	
	
	
		
 
            'lineno': 1,


			




	
	
	
		
 
        }


			




	
	
	
		
 
        load_errors = [Error(source, "no books to load in configuration", None)]


			




	
	
	
		
 
    filters.remove_opening_balance_txn(entries)


			




	
	
	
		
 
    postings = filter_search(data.Posting.from_entries(entries), args.search_terms)


			




	
	
	
		
 
    groups: PostGroups = dict(AccrualPostings.group_by_meta(postings, 'invoice'))


			




	
	
	
		
 
    groups = AccrualAccount.filter_paid_accruals(groups) or groups


			




	
	
	
		
 
    groups = {key: group for key, group in groups.items() if not group.is_paid()} or groups


			




	
	
	
		
 
    returncode = 0


			




	
	
	
		
 
    for error in load_errors:


			




	
	
	
		
 
        bc_printer.print_error(error, file=stderr)


			




	
	
	
		
 
        returncode |= ReturnFlag.LOAD_ERRORS


			




	
	
	
		
 
    for related in groups.values():


			




	
	
	
		
 
        for error in related.report_inconsistencies():


			




	
	
	
		
 
            bc_printer.print_error(error, file=stderr)


			




	
	
	
		
 
            returncode |= ReturnFlag.CONSISTENCY_ERRORS


			




	
	
	
		
 
    if args.report_type is None:


			




	
	
	
		
 
        args.report_type = ReportType.default_for(groups)


			




	
	
	
		
 
    if not groups:


			




	
	
	
		
 
        logger.warning("no matching entries found to report")


			




        

    



    


    



    



      

      





    
    0 comments (0 inline, 0 general)
    





    


  

  







    


    

  


    








    
        Server instance: kapok.sfconservancy.org-22622
    
    
        This site is powered by
            Kallithea 0.6.3,
        which is
        © 2010–2020 by various authors & licensed under GPLv3.
            – Support
        – Privacy Policy