'''
Plugin that closes an account by transferring its whole balance to another account.
'''
__copyright__ = 'Copyright (c) 2020 Kristóf Marussy <kristof@marussy.com>'
__license__ = 'GNU GPLv2'
import datetime as dt
from decimal import Decimal
from typing import Any, Dict, List, NamedTuple, Optional, Tuple
from beancount.core import amount
from beancount.core.data import Custom, Directive, Entries, Meta, Transaction, Union
from beancount.core.number import ZERO
__plugins__ = ('apply_templates',)
TEMPLATE_META = 'template'
TEMPLATE_USE_CUSTOM = 'template-use'
TEMPLATE_DELETE_CUSTOM = 'template-delete'
TEMPLATE_TAG_PREFIX = 'template'
Templates = Dict[str, Transaction]
class TemplateError(NamedTuple):
source: Optional[Meta]
message: str
entry: Directive
def _create_transaction(date: dt.date,
meta: Meta,
template: Transaction,
scale_factor: Decimal) -> Transaction:
return template._replace(
date=date,
meta={**template.meta, **meta},
postings=[posting._replace(units=amount.mul(posting.units, scale_factor))
for posting in template.postings])
def _use_template(entry: Custom,
templates: Templates) -> Union[Transaction, TemplateError]:
if len(entry.values) == 0:
return TemplateError(entry.meta, 'Template name missing', entry)
if len(entry.values) > 2:
return TemplateError(
entry.meta,
f'Too many {TEMPLATE_USE_CUSTOM} arguments',
entry)
template_name = entry.values[0].value
if not isinstance(template_name, str):
return TemplateError(
entry.meta,
f'Template name must be a string, got {template_name} instead',
entry)
template = templates.get(template_name, None)
if template is None:
return TemplateError(
entry.meta,
f'Unknown template: {template_name}',
entry)
if len(entry.values) == 2:
scale_factor = entry.values[1].value
if not isinstance(scale_factor, Decimal):
return TemplateError(
entry.meta,
f'Invalid scale factor {scale_factor}',
entry)
if scale_factor == ZERO:
return TemplateError(
entry.meta,
f'Scale factor must not be {ZERO}',
entry)
else:
scale_factor = Decimal(1.0)
return _create_transaction(entry.date, entry.meta, template, scale_factor)
def _add_template(entry: Transaction, templates: Templates) -> Optional[TemplateError]:
template_name = entry.meta[TEMPLATE_META]
if not isinstance(template_name, str):
return TemplateError(
entry.meta,
f'{TEMPLATE_META} must be a string, got {template_name} instead',
entry)
new_meta = dict(entry.meta)
del new_meta[TEMPLATE_META]
templates[template_name] = entry._replace(
meta=new_meta,
links={*entry.links, f'{TEMPLATE_TAG_PREFIX}_{template_name}'})
return None
def _delete_template(entry: Custom, templates: Templates) -> Optional[TemplateError]:
if len(entry.values) != 1:
return TemplateError(
entry.meta,
f'{TEMPLATE_DELETE_CUSTOM} takes a single argument',
entry)
template_name = entry.values[0].value
if not isinstance(template_name, str):
return TemplateError(
entry.meta,
f'Template name must be a string, got {template_name} instead',
entry)
if template_name not in templates:
return TemplateError(
entry.meta,
f'Unknown template: {template_name}',
entry)
del templates[template_name]
return None
def apply_templates(entries: Entries,
options_map: Dict[str, Any],
config_str: Optional[str] = None) -> \
Tuple[Entries, List[TemplateError]]:
new_entries: Entries = []
errors: List[TemplateError] = []
templates: Templates = {}
for entry in entries:
if isinstance(entry, Transaction) and TEMPLATE_META in entry.meta:
result = _add_template(entry, templates)
if result:
errors.append(result)
elif isinstance(entry, Custom):
if entry.type == TEMPLATE_USE_CUSTOM:
result = _use_template(entry, templates)
if isinstance(result, TemplateError):
errors.append(result)
else:
new_entries.append(result)
elif entry.type == TEMPLATE_DELETE_CUSTOM:
result = _delete_template(entry, templates)
if result:
errors.append(result)
else:
new_entries.append(entry)
else:
new_entries.append(entry)
return new_entries, errors
