| 1 |
import datetime |
| 2 |
import re |
| 3 |
import sys |
| 4 |
import ast |
| 5 |
from typing import Tuple, Optional |
| 6 |
from dataclasses import dataclass |
| 7 |
|
| 8 |
from . import * |
| 9 |
|
| 10 |
from dateutil.relativedelta import relativedelta |
| 11 |
|
| 12 |
try: |
| 13 |
from beancount.utils.date_utils import parse_date_liberally |
| 14 |
except (ImportError, ModuleNotFoundError): |
| 15 |
from beangulp.date_utils import parse_date as parse_date_liberally |
| 16 |
|
| 17 |
RE_TOTAL = '\\s*(?P<total>\\d+(?:\\.\\d+)?)\\s*-' |
| 18 |
PART_DURATION_NAMED = "(?:Day|Week|Month|Quarter|Year)" |
| 19 |
PART_DURATION_NAMED_SHORTEN = "[DWMQY]" |
| 20 |
DURATION_NUM = f'(?P<num>\\d+)?\\s*(?:(?P<unit_named>{PART_DURATION_NAMED}s?)|(?P<unit_named_shorten>' \ |
| 21 |
f'{PART_DURATION_NAMED_SHORTEN}))?' |
| 22 |
RE_DATE_START = "@\\s*(?P<date_start>\\d{4}-\\d{2}-\\d{2})" |
| 23 |
RE_DATE_END = "~\\s*(?P<date_end>\\d{4}-\\d{2}-\\d{2})" |
| 24 |
RE_DURATION = f'(?:{DURATION_NUM}\\s*(?:{RE_DATE_START}\\s*)?(?:{RE_DATE_END})?)' |
| 25 |
RE_STEP_A = f'(?P<step_num>\\d+)\\s*(?:(?P<step_unit_named>{PART_DURATION_NAMED}s?[!]?)|(?P<step_unit_named_shorten>' \ |
| 26 |
f'{PART_DURATION_NAMED_SHORTEN}[!]?))?' |
| 27 |
RE_STEP_B = f'(?P<step_named>(?:Dai|Week|Month|Quarter|Year)ly[!]?)' |
| 28 |
RE_STEP = f'{RE_STEP_A}|{RE_STEP_B}' |
| 29 |
RE_VALUE = "[\\+\\=]\\s*(?P<value>\\d+(?:\\.\\d+)?%?)" |
| 30 |
RE_FORMULA = "\\s*\\*(?P<formula>linear|straight|line|load|work-load|accelerated-sum|sum|accelerated-declining" \ |
| 31 |
"|declining)" |
| 32 |
RE = fr'^\s*(?:{RE_TOTAL}\s*)?(?:{RE_DURATION}\s*)?(?:/\s*(?:{RE_STEP})\s*)?(?:{RE_FORMULA}\s*)?(?:{RE_VALUE}\s*)?$' |
| 33 |
# sys.stderr.write('%s\n' % RE) |
| 34 |
CONFIG_STR_PATTERN = re.compile(RE) |
| 35 |
CONFIG_STR_PATTERN_DURATION = re.compile(fr'{RE_DURATION}') |
| 36 |
CONFIG_STR_PATTERN_STEP = re.compile(fr'{RE_STEP}') |
| 37 |
|
| 38 |
|
| 39 |
def get_duration(start_date, num, unit_named, unit_named_shorten): |
| 40 |
""" |
| 41 |
Calculate the number of days by natural date |
| 42 |
:param start_date: |
| 43 |
:param num: |
| 44 |
:param unit_named: |
| 45 |
:param unit_named_shorten: |
| 46 |
:return: days num |
| 47 |
""" |
| 48 |
unit = unit_named if unit_named else unit_named_shorten |
| 49 |
if unit: |
| 50 |
key_letter = unit[:1] |
| 51 |
if key_letter == 'D': |
| 52 |
return 1 * num |
| 53 |
elif key_letter == 'W': |
| 54 |
return 7 * num |
| 55 |
elif key_letter == 'M': |
| 56 |
delta = (start_date + relativedelta(months=num)) - start_date |
| 57 |
return delta.days |
| 58 |
elif key_letter == 'Q': |
| 59 |
delta = (start_date + relativedelta(months=num * 3)) - start_date |
| 60 |
return delta.days |
| 61 |
pass |
| 62 |
elif key_letter == 'Y': |
| 63 |
delta = (start_date + relativedelta(years=num)) - start_date |
| 64 |
return delta.days |
| 65 |
else: |
| 66 |
return num |
| 67 |
|
| 68 |
|
| 69 |
def get_steps(start_date, duration, num, unit_named, unit_named_shorten): |
| 70 |
""" |
| 71 |
Calculate the step length of each settlement based on the natural date (the actual number of days) |
| 72 |
:param start_date: |
| 73 |
:param duration: |
| 74 |
:param num: |
| 75 |
:param unit_named: |
| 76 |
:param unit_named_shorten: |
| 77 |
:return: |
| 78 |
""" |
| 79 |
unit = unit_named if unit_named else unit_named_shorten |
| 80 |
if unit: |
| 81 |
key_letter = unit[:1] |
| 82 |
if key_letter == 'D': |
| 83 |
return get_steps_simple(duration, num) |
| 84 |
elif key_letter == 'W': |
| 85 |
return get_steps_simple(duration, 7 * num) |
| 86 |
elif key_letter == 'M': |
| 87 |
return __get_steps(start_date, duration, lambda i: relativedelta(months=i)) |
| 88 |
elif key_letter == 'Q': |
| 89 |
return __get_steps(start_date, duration, lambda i: relativedelta(months=i * 3)) |
| 90 |
elif key_letter == 'Y': |
| 91 |
return __get_steps(start_date, duration, lambda i: relativedelta(years=i)) |
| 92 |
else: |
| 93 |
return get_steps_simple(duration, num) |
| 94 |
|
| 95 |
|
| 96 |
def get_steps_simple(duration, step): |
| 97 |
""" |
| 98 |
Simple calculation of the step length for each settlement |
| 99 |
:param duration: |
| 100 |
:param step: |
| 101 |
:return: |
| 102 |
""" |
| 103 |
steps = [] |
| 104 |
remainder = duration |
| 105 |
while True: |
| 106 |
if step <= remainder: |
| 107 |
steps.append((step, 1)) |
| 108 |
remainder -= step |
| 109 |
else: |
| 110 |
if remainder > 0: |
| 111 |
steps.append((remainder, Decimal(remainder) / step)) |
| 112 |
break |
| 113 |
return steps |
| 114 |
|
| 115 |
|
| 116 |
def __get_steps(start_date, duration, delta_callback): |
| 117 |
steps = [] |
| 118 |
start = start_date |
| 119 |
remainder = duration |
| 120 |
for i in range(duration): |
| 121 |
tail_date = start_date + delta_callback(i + 1) |
| 122 |
delta = tail_date - start |
| 123 |
if delta.days <= remainder: |
| 124 |
steps.append((delta.days, 1)) |
| 125 |
start = tail_date |
| 126 |
remainder -= delta.days |
| 127 |
else: |
| 128 |
if remainder > 0: |
| 129 |
steps.append((remainder, Decimal(remainder) / delta.days)) |
| 130 |
break |
| 131 |
return steps |
| 132 |
|
| 133 |
|
| 134 |
def parse( |
| 135 |
config, |
| 136 |
default_total, |
| 137 |
default_start_date: datetime.date, |
| 138 |
default_duration_str: str, |
| 139 |
default_step_str: str, |
| 140 |
default_value: Decimal, |
| 141 |
default_formula_str, |
| 142 |
) -> Tuple[PeriodicConfig, PeriodicConfigError]: |
| 143 |
""" |
| 144 |
Parse the configuration |
| 145 |
:param config: |
| 146 |
:param default_total: |
| 147 |
:param default_start_date: |
| 148 |
:param default_duration_str: |
| 149 |
:param default_step_str: |
| 150 |
:param default_value: |
| 151 |
:param default_formula_str: |
| 152 |
:return: |
| 153 |
""" |
| 154 |
if isinstance(config, str): |
| 155 |
match = CONFIG_STR_PATTERN.search(config) |
| 156 |
if match: |
| 157 |
total = match.group('total') |
| 158 |
num = match.group('num') |
| 159 |
unit_named = match.group('unit_named') |
| 160 |
unit_named_shorten = match.group('unit_named_shorten') |
| 161 |
date_start = match.group('date_start') |
| 162 |
date_end = match.group('date_end') |
| 163 |
step_num = match.group('step_num') |
| 164 |
step_unit_named = match.group('step_unit_named') |
| 165 |
step_unit_named_shorten = match.group('step_unit_named_shorten') |
| 166 |
step_named = match.group('step_named') |
| 167 |
value = match.group('value') |
| 168 |
formula = match.group('formula') |
| 169 |
__print_config_match_result(date_end, date_start, formula, num, step_named, step_num, step_unit_named, |
| 170 |
step_unit_named_shorten, total, unit_named, unit_named_shorten, value) |
| 171 |
|
| 172 |
total = Decimal(total if total else default_total) |
| 173 |
if value: |
| 174 |
if value.endswith('%'): |
| 175 |
salvage_value = Decimal(value[:-1]) / 100 * total |
| 176 |
else: |
| 177 |
salvage_value = Decimal(value) |
| 178 |
else: |
| 179 |
salvage_value = default_value |
| 180 |
start_date = parse_date_liberally(date_start, {}) if date_start else default_start_date |
| 181 |
|
| 182 |
if num or unit_named or unit_named_shorten: |
| 183 |
num = int(num) if num else 1 |
| 184 |
duration = get_duration(start_date, num, unit_named, unit_named_shorten) |
| 185 |
elif date_end: |
| 186 |
duration = (parse_date_liberally(date_end, {}) - start_date).days |
| 187 |
else: |
| 188 |
duration_math = CONFIG_STR_PATTERN_DURATION.match(default_duration_str) |
| 189 |
if duration_math: |
| 190 |
num = duration_math.group('num') |
| 191 |
unit_named = duration_math.group('unit_named') |
| 192 |
unit_named_shorten = duration_math.group('unit_named_shorten') |
| 193 |
num = int(num) if num else 1 |
| 194 |
duration = get_duration(start_date, num, unit_named, unit_named_shorten) |
| 195 |
else: |
| 196 |
return None, PeriodicConfigError(None, 'fail to parse default duration: %s' % default_duration_str, |
| 197 |
None) |
| 198 |
|
| 199 |
if step_num or step_named or step_unit_named or step_unit_named_shorten: |
| 200 |
if step_named: |
| 201 |
steps = get_steps(start_date, duration, 1, step_named, None) |
| 202 |
else: |
| 203 |
step_num = int(step_num) if step_num else 1 |
| 204 |
steps = get_steps(start_date, duration, step_num, step_unit_named, step_unit_named_shorten) |
| 205 |
else: |
| 206 |
step_match = CONFIG_STR_PATTERN_STEP.match(default_step_str) |
| 207 |
if step_match: |
| 208 |
step_num = step_match.group('step_num') |
| 209 |
step_unit_named = step_match.group('step_unit_named') |
| 210 |
step_unit_named_shorten = step_match.group('step_unit_named_shorten') |
| 211 |
step_named = step_match.group('step_named') |
| 212 |
if step_named: |
| 213 |
steps = get_steps(start_date, duration, 1, step_named, None) |
| 214 |
else: |
| 215 |
step_num = int(step_num) if step_num else 1 |
| 216 |
steps = get_steps(start_date, duration, step_num, step_unit_named, step_unit_named_shorten) |
| 217 |
else: |
| 218 |
return None, PeriodicConfigError(None, 'fail to parse default steps: %s' % default_step_str, None) |
| 219 |
|
| 220 |
use_real_days_for_step_amount = next( |
| 221 |
(unit for unit in [step_named, step_unit_named, step_unit_named_shorten] if unit is not None), |
| 222 |
'').endswith('!') |
| 223 |
|
| 224 |
config_obj = PeriodicConfig( |
| 225 |
total=total, |
| 226 |
start=start_date, |
| 227 |
duration=duration, |
| 228 |
steps=steps, |
| 229 |
equal_amount=not use_real_days_for_step_amount, |
| 230 |
salvage_value=salvage_value, |
| 231 |
formula=formula if formula else default_formula_str |
| 232 |
) |
| 233 |
return config_obj, None |
| 234 |
else: |
| 235 |
return None, PeriodicConfigError(None, 'fail to parse: %s' % config, None) |
| 236 |
return None, None |
| 237 |
|
| 238 |
|
| 239 |
def __print_config_match_result(date_end, date_start, formula, num, step_named, step_num, step_unit_named, |
| 240 |
step_unit_named_shorten, total, unit_named, unit_named_shorten, value): |
| 241 |
# sys.stderr.write('total: %s\n' % total) |
| 242 |
# sys.stderr.write('num: %s\n' % num) |
| 243 |
# sys.stderr.write('unit_named: %s\n' % unit_named) |
| 244 |
# sys.stderr.write('unit_named_shorten: %s\n' % unit_named_shorten) |
| 245 |
# sys.stderr.write('date_start: %s\n' % date_start) |
| 246 |
# sys.stderr.write('date_end: %s\n' % date_end) |
| 247 |
# sys.stderr.write('step_num: %s\n' % step_num) |
| 248 |
# sys.stderr.write('step_unit_named: %s\n' % step_unit_named) |
| 249 |
# sys.stderr.write('step_unit_named_shorten: %s\n' % step_unit_named_shorten) |
| 250 |
# sys.stderr.write('step_named: %s\n' % step_named) |
| 251 |
# sys.stderr.write('value: %s\n' % value) |
| 252 |
# sys.stderr.write('formula: %s\n' % ear) |
| 253 |
pass |
| 254 |
|
| 255 |
|
| 256 |
@dataclass |
| 257 |
class PluginConfig: |
| 258 |
generate_until: Optional[datetime.date] = None |
| 259 |
|
| 260 |
@staticmethod |
| 261 |
def from_string(config_str: str) -> 'PluginConfig': |
| 262 |
ret = PluginConfig() |
| 263 |
|
| 264 |
if not config_str: |
| 265 |
return ret |
| 266 |
config_dict = ast.literal_eval(config_str) |
| 267 |
|
| 268 |
try: |
| 269 |
generate_until_str = config_dict.get('generate_until', None) |
| 270 |
if generate_until_str == 'today': |
| 271 |
ret.generate_until = datetime.date.today() |
| 272 |
elif generate_until_str: |
| 273 |
ret.generate_until = datetime.date.fromisoformat(generate_until_str) |
| 274 |
except (ValueError, TypeError): |
| 275 |
raise RuntimeError('Bad "generate_until" value - it must be a valid date, formatted in ISO 8601 (e.g. ' |
| 276 |
'"2024-12-31") or the literal "today".') |
| 277 |
|
| 278 |
return ret |