X-Git-Url: https://plomlompom.com/repos/%7B%7B%20web_path%20%7D%7D/decks/%7B%7Bdeck_id%7D%7D/cards/%7B%7Bcard_id%7D%7D/static/%7B%7Bdb.prefix%7D%7D/todo?a=blobdiff_plain;f=ledger.py;h=358cf295c153597f8c91053a7ccc3ad557e18169;hb=HEAD;hp=02e0273c74f26590e426e7860d72576e0721073f;hpb=c8e39d2444ae290dba713c542a5f95a47ab67ba9;p=misc diff --git a/ledger.py b/ledger.py index 02e0273..358cf29 100755 --- a/ledger.py +++ b/ledger.py @@ -1,811 +1,615 @@ -from http.server import BaseHTTPRequestHandler, HTTPServer import os -import html -import jinja2 import decimal -import datetime +from datetime import datetime, timedelta from urllib.parse import parse_qs, urlparse -hostName = "localhost" -serverPort = 8082 - - -class HandledException(Exception): - pass - - -def apply_booking_to_account_balances(account_sums, account, currency, amount): - if not account in account_sums: - account_sums[account] = {currency: amount} - elif not currency in account_sums[account].keys(): - account_sums[account][currency] = amount - else: - account_sums[account][currency] += amount - - -def bookings_to_account_tree(bookings): - account_sums = {} - for booking in bookings: - for account, changes in booking.account_changes.items(): - for currency, amount in changes.items(): - apply_booking_to_account_balances(account_sums, account, currency, amount) - account_tree = {} - def collect_branches(account_name, path): - node = account_tree - path_copy = path[:] - while len(path_copy) > 0: - step = path_copy.pop(0) - node = node[step] - toks = account_name.split(":", maxsplit=1) - parent = toks[0] - if parent in node.keys(): - child = node[parent] - else: - child = {} - node[parent] = child - if len(toks) == 2: - k, v = collect_branches(toks[1], path + [parent]) - if k not in child.keys(): - child[k] = v - else: - child[k].update(v) - return parent, child - for account_name in sorted(account_sums.keys()): - k, v = collect_branches(account_name, []) - if k not in account_tree.keys(): - account_tree[k] = v +from jinja2 import Environment as JinjaEnv, FileSystemLoader as JinjaFSLoader +from plomlib import PlomDB, PlomException, run_server, PlomHandler +from os.path import split as path_split + +db_path = '/home/plom/org/ledger2024.dat' +server_port = 8082 +j2env = JinjaEnv(loader=JinjaFSLoader('ledger_templates')) + +class EditableException(PlomException): + def __init__(self, booking_index, *args, **kwargs): + self.booking_index = booking_index + super().__init__(*args, **kwargs) + + +class LedgerTextLine: + + def __init__(self, text_line): + self.text_line = text_line + self.comment = '' + split_by_comment = text_line.rstrip().split(sep=';', maxsplit=1) + self.non_comment = split_by_comment[0].rstrip() + self.empty = len(split_by_comment) == 1 and len(self.non_comment) == 0 + if self.empty: + return + if len(split_by_comment) == 2: + self.comment = split_by_comment[1].lstrip() + + +class Wealth: + + def __init__(self): + self.money_dict = {} + + def __iadd__(self, moneys): + money_dict = moneys + if type(moneys) == Wealth: + moneys = moneys.money_dict + for currency, amount in moneys.items(): + if not currency in self.money_dict.keys(): + self.money_dict[currency] = 0 + self.money_dict[currency] += amount + return self + + @property + def sink_empty(self): + return len(self.as_sink) == 0 + + @property + def as_sink(self): + sink = {} + for currency, amount in self.money_dict.items(): + if 0 == amount: + continue + sink[currency] = -amount + return sink + + +class Account: + + def __init__(self, own_name, parent): + self.own_name = own_name + self.parent = parent + if self.parent: + self.parent.children += [self] + self.own_moneys = Wealth() + self.children = [] + + def add_wealth(self, moneys): + self.own_moneys += moneys + + @property + def full_name(self): + if self.parent and len(self.parent.own_name) > 0: + return f'{self.parent.full_name}:{self.own_name}' else: - account_tree[k].update(v) - def collect_totals(parent_path, tree_node): - for k, v in tree_node.items(): - child_path = parent_path + ":" + k - for currency, amount in collect_totals(child_path, v).items(): - apply_booking_to_account_balances(account_sums, parent_path, currency, amount) - return account_sums[parent_path] - for account_name in account_tree.keys(): - account_sums[account_name] = collect_totals(account_name, account_tree[account_name]) - return account_tree, account_sums - - -def parse_lines(lines, validate_bookings=True): - import datetime + return self.own_name + + @property + def full_moneys(self): + full_moneys = Wealth() + full_moneys += self.own_moneys + for child in self.children: + full_moneys += child.full_moneys + return full_moneys + + +def parse_lines_to_bookings(lines, ignore_editable_exceptions=False): + lines = [LedgerTextLine(line) for line in lines] + lines += [LedgerTextLine('')] # to simulate ending of last booking + bookings = [] inside_booking = False - date_string, description = None, None booking_lines = [] - start_line = 0 - bookings = [] - comments = [] - lines = lines.copy() + [''] # to ensure a booking-ending last line - last_date = '' + booking_start_i = 0 + last_date = '' for i, line in enumerate(lines): - prefix = f"line {i}" - # we start with the case of an utterly empty line - comments += [""] - stripped_line = line.rstrip() - if stripped_line == '': + intro = f'file line {i}' + if line.empty: if inside_booking: - # assume we finished a booking, finalize, and commit to DB - if len(booking_lines) < 2: - raise HandledException(f"{prefix} booking ends to early") - booking = Booking(date_string, description, booking_lines, start_line, validate_bookings) + booking = Booking(lines=booking_lines, starts_at=booking_start_i) + if last_date > booking.date and not ignore_editable_exceptions: + raise EditableException(len(bookings), f'{intro}: out-of-order date (follows {last_date})') + last_date = booking.date bookings += [booking] - # expect new booking to follow so re-zeroall booking data - inside_booking = False - date_string, description = None, None - booking_lines = [] - continue - # if non-empty line, first get comment if any, and commit to DB - split_by_comment = stripped_line.split(sep=";", maxsplit=1) - if len(split_by_comment) == 2: - comments[i] = split_by_comment[1].lstrip() - # if pre-comment empty: if inside_booking, this must be a comment-only line so we keep it for later ledger-output to capture those comments; otherwise, no more to process for this line - non_comment = split_by_comment[0].rstrip() - if non_comment.rstrip() == '': - if inside_booking: - booking_lines += [''] - continue - # if we're starting a booking, parse by first-line pattern - if not inside_booking: - start_line = i - toks = non_comment.split(maxsplit=1) - date_string = toks[0] - try: - datetime.datetime.strptime(date_string, '%Y-%m-%d') - except ValueError: - raise HandledException(f"{prefix} bad date string: {date_string}") - if last_date > date_string: - raise HandledException(f"{prefix} out-of-order-date") - last_date = date_string - try: - description = toks[1] - except IndexError: - raise HandledException(f"{prefix} bad description: {description}") + inside_booking =False + booking_lines = [] + else: + if not inside_booking: + booking_start_i = i inside_booking = True - booking_lines += [non_comment] - continue - # otherwise, read as transfer data - toks = non_comment.split() # ignore specification's allowance of single spaces in names - if len(toks) > 3: - raise HandledException(f"{prefix} too many booking line tokens: {toks}") - amount, currency = None, None - account_name = toks[0] - if account_name[0] == '[' and account_name[-1] == ']': - # ignore specification's differentiation of "virtual" accounts - account_name = account_name[1:-1] - decimal_chars = ".-0123456789" - if len(toks) == 3: - i_currency = 1 - try: - amount = decimal.Decimal(toks[1]) - i_currency = 2 - except decimal.InvalidOperation: + booking_lines += [line] + if inside_booking: + raise PlomException(f'{intro}: last booking unfinished') + return bookings + + +class TransferLine: + + def __init__(self, line=None, account='', amount=None, currency='', comment='', validate=True): + self.account = account + self.amount = amount + self.currency = currency + self.comment = comment + if line: + if line.empty: + raise PlomException('line empty') + self.comment = line.comment + toks = line.non_comment.split() + if (len(toks) not in {1, 3}): + if validate: + raise PlomException(f'number of non-comment tokens not 1 or 3') + elif len(toks) == 2: + toks += [''] + else: + toks = 3*[''] + self.account = toks[0] + if len(toks) != 1: try: - amount = decimal.Decimal(toks[2]) + self.amount = decimal.Decimal(toks[1]) except decimal.InvalidOperation: - raise HandledException(f"{prefix} no decimal number in: {toks[1:]}") - currency = toks[i_currency] - if currency[0] in decimal_chars: - raise HandledException(f"{prefix} currency starts with int, dot, or minus: {currency}") - elif len(toks) == 2: - value = toks[1] - inside_amount = False - inside_currency = False - amount_string = "" - currency = "" - dots_counted = 0 - for i, c in enumerate(value): - if i == 0: - if c in decimal_chars: - inside_amount = True + if validate: + raise PlomException(f'invalid token for Decimal: {toks[1]}') else: - inside_currency = True - if inside_currency: - if c in decimal_chars and len(amount_string) == 0: - inside_currency = False - inside_amount = True - else: - currency += c - continue - if inside_amount: - if c not in decimal_chars: - if len(currency) > 0: - raise HandledException(f"{prefix} amount has non-decimal chars: {value}") - inside_currency = True - inside_amount = False - currency += c - continue - if c == '-' and len(amount_string) > 1: - raise HandledException(f"{prefix} amount has non-start '-': {value}") - if c == '.': - if dots_counted > 1: - raise HandledException(f"{prefix} amount has multiple dots: {value}") - dots_counted += 1 - amount_string += c - if len(currency) == 0: - raise HandledException(f"{prefix} currency missing: {value}") - if len(amount_string) > 0: - amount = decimal.Decimal(amount_string) - booking_lines += [(account_name, amount, currency)] - if inside_booking: - raise HandledException(f"{prefix} last booking unfinished") - return bookings, comments + self.comment = f'unparsed: {toks[1]}; {self.comment}' + self.currency = toks[2] + + @property + def amount_fmt(self): + if self.amount is None: + return '' + elif self.amount.as_tuple().exponent < -2: + return f'{self.amount:.1f}â¦' + else: + return f'{self.amount:.2f}' + + @property + def for_writing(self): + line = f' {self.account}' + if self.amount is not None: + line += f' {self.amount} {self.currency}' + if self.comment != '': + line += f' ; {self.comment}' + return line + + @property + def comment_cols(self): + return max(20, len(self.comment)) class Booking: - def __init__(self, date_string, description, booking_lines, start_line, process=True): - self.date_string = date_string - self.description = description - self.lines = booking_lines - self.start_line = start_line - if process: - self.validate_booking_lines() - self.sink = {} - self.account_changes = self.parse_booking_lines_to_account_changes() - - def validate_booking_lines(self): - prefix = f"booking at line {self.start_line}" - sums = {} - empty_values = 0 - for line in self.lines[1:]: - if line == '': - continue - _, amount, currency = line - if amount is None: - if empty_values > 0: - raise HandledException(f"{prefix} relates more than one empty value of same currency {currency}") - empty_values += 1 - continue - if currency not in sums: - sums[currency] = 0 - sums[currency] += amount - if empty_values == 0: - for k, v in sums.items(): - if v != 0: - raise HandledException(f"{prefix} does not add up to zero / {k} {v}") + def __init__(self, lines=None, starts_at='?', date='', description='', top_comment='', transfer_lines=None, validate=True): + self.validate = validate + self.starts_at = starts_at + self.intro = f'booking starting at line {self.starts_at}' + self.clean() + if lines: + self.lines = lines + self.parse_lines() else: - sinkable = False - for k, v in sums.items(): - if v != 0: - sinkable = True - if not sinkable: - raise HandledException(f"{prefix} has empty value that cannot be filled") - - def parse_booking_lines_to_account_changes(self): - account_changes = {} - debt = {} - sink_account = None - for line in self.lines[1:]: - if line == '': + self.date = date + self.description = description + self.top_comment = top_comment + self.validate_head() + self.transfer_lines = transfer_lines if transfer_lines else [] + if self.validate and len(self.transfer_lines) < 2: + raise PlomException(f'{self.intro}: too few transfer lines') + self.calculate_account_changes() + self.lines = [LedgerTextLine(l) for l in self.for_writing] + + @classmethod + def from_postvars(cls, postvars, starts_at='?', validate=True): + date = postvars['date'][0] + description = postvars['description'][0] + top_comment = postvars['top_comment'][0] + transfer_lines = [] + for i, account in enumerate(postvars['account']): + if len(account) == 0: continue - account, amount, currency = line - if amount is None: - sink_account = account - continue - apply_booking_to_account_balances(account_changes, account, currency, amount) - if currency not in debt: - debt[currency] = amount + amount = None + if len(postvars['amount'][i]) > 0: + amount = decimal.Decimal(postvars['amount'][i]) + transfer_lines += [TransferLine(None, account, amount, postvars['currency'][i], postvars['comment'][i])] + return cls(None, starts_at, date, description, top_comment, transfer_lines, validate=validate) + + def clean(self): + self.transfer_lines = [] + self.account_changes = {} + + def parse_lines(self): + if len(self.lines) < 3 and self.validate: + raise PlomException(f'{self.intro}: ends with less than 3 lines:' + str(self.lines)) + top_line = self.lines[0] + if top_line.empty and self.validate: + raise PlomException('{self.intro}: headline empty') + self.top_comment = top_line.comment + toks = top_line.non_comment.split(maxsplit=1) + if len(toks) < 2: + if self.validate: + raise PlomException(f'{self.intro}: headline missing elements: {non_comment}') + elif 0 == len(toks): + toks = 2*[''] else: - debt[currency] += amount - if sink_account: - for currency, amount in debt.items(): - apply_booking_to_account_balances(account_changes, sink_account, currency, -amount) - self.sink[currency] = -amount - return account_changes - - - -class Database: - - def __init__(self): - db_name = "_ledger" - self.db_file = db_name + ".json" - self.lock_file = db_name+ ".lock" - self.bookings = [] - self.comments = [] - self.real_lines = [] - if os.path.exists(self.db_file): - with open(self.db_file, "r") as f: - self.real_lines += [l.rstrip() for l in f.readlines()] - ret = parse_lines(self.real_lines) - self.bookings += ret[0] - self.comments += ret[1] - - def get_lines(self, start, end): - return self.real_lines[start:end] - - def write_db(self, text, mode='w'): - import shutil - if os.path.exists(self.lock_file): - raise HandledException('Sorry, lock file!') - f = open(self.lock_file, 'w+') - f.close() - - # always back up most recent to .bak - bakpath = f'{self.db_file}.bak' - shutil.copy(self.db_file, bakpath) - - # collect modification times of numbered .bak files - bak_prefix = f'{bakpath}.' - backup_dates = [] - i = 0 - bak_as = f'{bak_prefix}{i}' - while os.path.exists(bak_as): - mod_time = os.path.getmtime(bak_as) - backup_dates += [str(datetime.datetime.fromtimestamp(mod_time))] - i += 1 - bak_as = f'{bak_prefix}{i}' - - # collect what numbered .bak files to save: - # shrink datetime string right to left character by character, - # on each step add the oldest file whose mtime still fits the pattern - # (privilege older files to keep existing longer) - to_save = [] - datetime_len = 19 - now = str(datetime.datetime.now())[:datetime_len] - while datetime_len > 2: - # assume backup_dates starts with oldest dates - for i, date in enumerate(backup_dates): - if date[:datetime_len] == now: - if i not in to_save: - to_save += [i] - break - datetime_len -= 1 - now = now[:datetime_len] - - # remove redundant backup files - j = 0 - for i in to_save: - if i != j: - source = f'{bak_prefix}{i}' - target = f'{bak_prefix}{j}' - shutil.move(source, target) - j += 1 - for i in range(j, len(backup_dates)): + toks += [''] + self.date = toks[0] + self.description = toks[1] + self.validate_head() + for i, line in enumerate(self.lines[1:]): try: - os.remove(f'{bak_prefix}{i}') - except FileNotFoundError: - pass - - # put second backup copy of current state at end of bak list - shutil.copy(self.db_file, f'{bak_prefix}{j}') - with open(self.db_file, mode) as f: - f.write(text); - os.remove(self.lock_file) - - def replace(self, start, end, lines): - total_lines = self.real_lines[:start] + lines + self.real_lines[end:] - text = '\n'.join(total_lines) - self.write_db(text) - - def append(self, lines): - text = '\n\n' + '\n'.join(lines) + '\n\n' - self.write_db(text, 'a') - - def get_nth_for_booking_of_start_line(self, start_line): - nth = 0 - for b in self.bookings: - if b.start_line == start_line: + self.transfer_lines += [TransferLine(line, validate=self.validate)] + except PlomException as e: + raise PlomException(f'{self.intro}, transfer line {i}: {e}') + self.calculate_account_changes() + + def calculate_account_changes(self): + sink_account = None + money_changes = Wealth() + for i, transfer_line in enumerate(self.transfer_lines): + intro = f'{self.intro}, transfer line {i}' + if transfer_line.amount is None: + if sink_account is not None and self.validate: + raise PlomException(f'{intro}: second sink found (only one allowed)') + sink_account = transfer_line.account + else: + if not transfer_line.account in self.account_changes.keys(): + self.account_changes[transfer_line.account] = Wealth() + money = {transfer_line.currency: transfer_line.amount} + self.account_changes[transfer_line.account] += money + money_changes += money + if sink_account is None and (not money_changes.sink_empty) and self.validate: + raise PlomException(f'{intro}: does not balance (undeclared non-empty sink)') + if sink_account is not None: + if not sink_account in self.account_changes.keys(): + self.account_changes[sink_account] = Wealth() + self.account_changes[sink_account] += money_changes.as_sink + + @property + def for_writing(self): + lines = [f'{self.date} {self.description}'] + if self.top_comment is not None and self.top_comment.rstrip() != '': + lines[0] += f' ; {self.top_comment}' + for line in self.transfer_lines: + lines += [line.for_writing] + return lines + + @property + def comment_cols(self): + return max(20, len(self.top_comment)) + + def validate_head(self): + if not self.validate: + return + if len(self.date) == 0: + raise PlomException(f'{self.intro}: missing date') + if len(self.description) == 0: + raise PlomException(f'{self.intro}: missing description') + try: + datetime.strptime(self.date, '%Y-%m-%d') + except ValueError: + raise PlomException(f'{self.intro}: bad headline date format: {self.date}') + + def fill_sink(self): + replacement_lines = [] + for i, line in enumerate(self.transfer_lines): + if line.amount is None: + for currency, amount in self.account_changes[line.account].money_dict.items(): + replacement_lines += [TransferLine(None, f'{line.account}', amount, currency).for_writing] break - nth += 1 - return nth - - def add_taxes(self, lines, finish=False): - ret = [] - bookings, _ = parse_lines(lines) - date = bookings[0].date_string + lines = self.lines[:i+1] + [LedgerTextLine(l) for l in replacement_lines] + self.lines[i+2:] + self.clean() + self.lines = lines + self.parse_lines() + + def mirror(self): + new_transfer_lines = [] + for transfer_line in self.transfer_lines: + uncommented_source = LedgerTextLine(transfer_line.for_writing).non_comment + comment = f're: {uncommented_source.lstrip()}' + new_account = '?' + new_transfer_lines += [TransferLine(None, new_account, -transfer_line.amount, transfer_line.currency, comment)] + for transfer_line in new_transfer_lines: + self.lines += [LedgerTextLine(transfer_line.for_writing)] + self.clean() + self.parse_lines() + + def replace(self, replace_from, replace_to): + lines = [] + for l in self.for_writing: + lines += [l.replace(replace_from, replace_to)] + self.lines = [LedgerTextLine(l) for l in lines] + self.clean() + self.parse_lines() + + def add_taxes(self, db): acc_kk_add = 'Reserves:KrankenkassenBeitragsWachstum' - acc_kk_minimum = 'Reserves:Month:KrankenkassenDefaultBeitrag' + acc_kk_minimum = 'Reserves:Monthly:KrankenkassenDefaultBeitrag' acc_kk = 'Expenses:KrankenKasse' - acc_est = 'Reserves:Einkommenssteuer' + acc_ESt = 'Reserves:EinkommensSteuer' acc_assets = 'Assets' - acc_buffer = 'Reserves:NeuAnfangsPuffer:Ausgaben' - last_monthbreak_assets = 0 - last_monthbreak_est = 0 - last_monthbreak_kk_minimum = 0 - last_monthbreak_kk_add = 0 - buffer_expenses = 0 - kk_expenses = 0 - est_expenses = 0 - months_passed = -int(finish) - for b in self.bookings: - if date == b.date_string: + acc_neuanfangspuffer_expenses = 'Reserves:NeuAnfangsPuffer:Ausgaben' + months_passed = datetime.strptime(self.date, '%Y-%m-%d').month - 1 + past_kk_expenses = 0 + past_kk_add = 0 + past_neuanfangspuffer_expenses = 0 + for b in db.bookings: + if b.date == self.date: break - acc_keys = b.account_changes.keys() - if acc_buffer in acc_keys: - buffer_expenses -= b.account_changes[acc_buffer]['â¬'] - if acc_kk_add in acc_keys: - kk_expenses += b.account_changes[acc_kk_add]['â¬'] - if acc_kk in acc_keys: - kk_expenses += b.account_changes[acc_kk]['â¬'] - if acc_est in acc_keys: - est_expenses += b.account_changes[acc_est]['â¬'] - if acc_kk_add in acc_keys and acc_kk_minimum in acc_keys: - months_passed += 1 - if finish: - last_monthbreak_kk_add = b.account_changes[acc_kk_add]['â¬'] - last_monthbreak_est = b.account_changes[acc_est]['â¬'] - last_monthbreak_kk_minimum = b.account_changes[acc_kk_minimum]['â¬'] - last_monthbreak_assets = b.account_changes[acc_buffer]['â¬'] - old_needed_income_before_anything = - last_monthbreak_assets - last_monthbreak_kk_add - last_monthbreak_kk_minimum - last_monthbreak_est - if finish: - ret += [f' {acc_est} {-last_monthbreak_est}⬠; for old assumption of needed income: {old_needed_income_before_anything}â¬'] - _, account_sums = bookings_to_account_tree(bookings) - expenses_so_far = -1 * account_sums[acc_assets]['â¬'] + old_needed_income_before_anything - needed_income_before_kk = expenses_so_far + if acc_neuanfangspuffer_expenses in b.account_changes.keys(): + past_neuanfangspuffer_expenses -= b.account_changes[acc_neuanfangspuffer_expenses].money_dict['â¬'] + if acc_kk_add in b.account_changes.keys(): + past_kk_add += b.account_changes[acc_kk_add].money_dict['â¬'] + if acc_kk_minimum in b.account_changes.keys(): + past_kk_expenses += b.account_changes[acc_kk_minimum].money_dict['â¬'] + + needed_netto = -self.account_changes['Assets'].money_dict['â¬'] + past_taxed_needs_before_kk = past_neuanfangspuffer_expenses - past_kk_expenses ESt_this_month = 0 - left_over = needed_income_before_kk - ESt_this_month + E0 = decimal.Decimal(11604) + E1 = decimal.Decimal(17006) + E2 = decimal.Decimal(66761) + E3 = decimal.Decimal(277826) + taxed_income_before_kk = needed_netto too_low = 0 - too_high = 2 * needed_income_before_kk - E0 = decimal.Decimal(10908) - E1 = decimal.Decimal(15999) - E2 = decimal.Decimal(62809) - E3 = decimal.Decimal(277825) + too_high = 2 * needed_netto while True: - zvE = buffer_expenses - kk_expenses + (12 - months_passed) * needed_income_before_kk - if finish: - zvE += last_monthbreak_assets + last_monthbreak_kk_add + last_monthbreak_kk_minimum + estimate_for_remaining_year = (12 - months_passed) * taxed_income_before_kk + zvE = past_taxed_needs_before_kk + estimate_for_remaining_year if zvE < E0: - ESt = decimal.Decimal(0) + ESt_year = decimal.Decimal(0) elif zvE < E1: y = (zvE - E0)/10000 - ESt = (decimal.Decimal(979.18) * y + 1400) * y + ESt_year = (decimal.Decimal(922.98) * y + 1400) * y elif zvE < E2: y = (zvE - E1)/10000 - ESt = (decimal.Decimal(192.59) * y + 2397) * y + decimal.Decimal(966.53) + ESt_year = (decimal.Decimal(181.19) * y + 2397) * y + decimal.Decimal(1025.38) elif zvE < E3: - ESt = decimal.Decimal(0.42) * (zvE - decimal.Decimal(62809)) + decimal.Decimal(16405.54) + ESt_year = decimal.Decimal(0.42) * zvE - 10602.13 else: - ESt = decimal.Decimal(0.45) * (zvE - decimal.Decimal(277825)) + decimal.Decimal(106713.52) - ESt_this_month = (ESt + last_monthbreak_est - est_expenses) / (12 - months_passed) - left_over = needed_income_before_kk - ESt_this_month - if abs(left_over - expenses_so_far) < 0.001: + ESt_year = decimal.Decimal(0.45) * zvE - 18936.88 + ESt_this_month = ESt_year / 12 + taxed_income_minus_ESt = taxed_income_before_kk - ESt_this_month + if abs(taxed_income_minus_ESt - needed_netto) < 0.001: break - elif left_over < expenses_so_far: - too_low = needed_income_before_kk - elif left_over > expenses_so_far: - too_high = needed_income_before_kk - needed_income_before_kk = too_low + (too_high - too_low)/2 + elif taxed_income_minus_ESt < needed_netto: + too_low = taxed_income_before_kk + elif taxed_income_minus_ESt > needed_netto: + too_high = taxed_income_before_kk + taxed_income_before_kk = too_low + (too_high - too_low)/2 ESt_this_month = ESt_this_month.quantize(decimal.Decimal('0.00')) - ret += [f' {acc_est} {ESt_this_month}⬠; expenses so far: {expenses_so_far:.2f}â¬; zvE: {zvE:.2f}â¬; ESt total: {ESt:.2f}â¬; needed before Krankenkasse: {needed_income_before_kk:.2f}â¬'] - kk_minimum_income = 1131.67 - if date < '2023-02-01': - kk_minimum_income = decimal.Decimal(1096.67) - kk_factor = decimal.Decimal(0.189) - kk_minimum_tax = decimal.Decimal(207.27).quantize(decimal.Decimal('0.00')) - elif date < '2023-08-01': - kk_factor = decimal.Decimal(0.191) - kk_minimum_tax = decimal.Decimal(216.15).quantize(decimal.Decimal('0.00')) - else: - kk_factor = decimal.Decimal(0.197) + comment = f'estimated zvE: {past_taxed_needs_before_kk}⬠+ {estimate_for_remaining_year:.2f}⬠= {zvE:.2f}⬠â year ESt: {ESt_year:.2f} â needed taxed income before Krankenkasse: {taxed_income_before_kk:.2f}â¬' + self.transfer_lines += [TransferLine(None, acc_ESt, ESt_this_month, 'â¬', comment)] + + kk_factor = decimal.Decimal(1.197) + kk_minimum_income = 1178.33 + kk_minimum_tax = decimal.Decimal(232.13).quantize(decimal.Decimal('0.00')) + if self.date < '2024-02-01': + kk_minimum_income = 1131.67 kk_minimum_tax = decimal.Decimal(222.94).quantize(decimal.Decimal('0.00')) - kk_add_so_far = account_sums[acc_kk_add]['â¬'] if acc_kk_add in account_sums.keys() else 0 - kk_add = needed_income_before_kk / (1 - kk_factor) - needed_income_before_kk - kk_minimum_tax - hit_kk_minimum_income_limit = False - if kk_add_so_far + kk_add < 0: - hit_kk_minimum_income_limit = True - kk_add_uncorrect = kk_add - kk_add = -(kk_add + kk_add_so_far) + comment = f'assumed minimum income of {kk_minimum_income:.2f}⬠* {kk_factor:.3f}' + self.transfer_lines += [TransferLine(None, acc_kk_minimum, kk_minimum_tax, 'â¬', comment)] + kk_add = taxed_income_before_kk * kk_factor - taxed_income_before_kk - kk_minimum_tax kk_add = decimal.Decimal(kk_add).quantize(decimal.Decimal('0.00')) - if finish: - ret += [f' {acc_kk_add} {-last_monthbreak_kk_add}⬠; for old assumption of needed income'] + if past_kk_add + kk_add < 0: # *if* kk_add would actually kill all earlier kk_add ⦠+ kk_add = - past_kk_add # ⦠shrink it so it won't push the kk_add total below 0 + comment = f'local negative as large as possible without moving {acc_kk_add} below zero' else: - ret += [f' {acc_kk_minimum} {kk_minimum_tax}⬠; assumed minimum income {kk_minimum_income:.2f}⬠* {kk_factor:.3f}'] - if hit_kk_minimum_income_limit: - ret += [f' {acc_kk_add} {kk_add}⬠; {needed_income_before_kk:.2f}⬠/ (1 - {kk_factor:.3f}) - {needed_income_before_kk:.2f}⬠- {kk_minimum_tax}⬠= {kk_add_uncorrect:.2f}⬠would reduce current {acc_kk_dd} ({kk_add_so_far:.2f}â¬) below 0'] + comment = f'({taxed_income_before_kk:.2f}⬠* {kk_factor:.3f}) - {taxed_income_before_kk:.2f} - {kk_minimum_tax}' + self.transfer_lines += [TransferLine(None, acc_kk_add, kk_add, 'â¬', comment)] + + diff_through_taxes_and_kk = ESt_this_month + kk_minimum_tax + kk_add + comment = f'{ESt_this_month} + {kk_minimum_tax} + {kk_add}' + self.transfer_lines += [TransferLine(None, acc_assets, -diff_through_taxes_and_kk, 'â¬', comment)] + final_loss = diff_through_taxes_and_kk + needed_netto + comment = f'{needed_netto} + {diff_through_taxes_and_kk}' + self.transfer_lines += [TransferLine(None, acc_assets, final_loss, 'â¬', comment)] + self.transfer_lines += [TransferLine(None, acc_neuanfangspuffer_expenses, -final_loss, 'â¬')] + + +class LedgerDB(PlomDB): + + def __init__(self, prefix, ignore_editable_exceptions=False): + self.prefix = prefix + self.bookings = [] + self.comments = [] + self.text_lines = [] + super().__init__(db_path) + self.bookings = parse_lines_to_bookings(self.text_lines, ignore_editable_exceptions) + + def read_db_file(self, f): + self.text_lines += f.readlines() + + def insert_booking_at_date(self, booking): + place_at = 0 + if len(self.bookings) > 0: + for i, iterated_booking in enumerate(self.bookings): + if booking.date < iterated_booking.date: + break + elif booking.date == iterated_booking.date: + place_at = i + break + else: + place_at = i + 1 + self.bookings.insert(place_at, booking) + + def ledger_as_html(self): + for index, booking in enumerate(self.bookings): + booking.can_up = index > 0 and self.bookings[index - 1].date == booking.date + booking.can_down = index < len(self.bookings) - 1 and self.bookings[index + 1].date == booking.date + return j2env.get_template('ledger.html').render(bookings=self.bookings) + + def balance_as_html(self, until_after=None): + bookings = self.bookings[:(until_after if until_after is None else int(until_after)+1)] + account_trunk = Account('', None) + accounts = {account_trunk.full_name: account_trunk} + for booking in bookings: + for full_account_name, moneys in booking.account_changes.items(): + toks = full_account_name.split(':') + path = [] + for tok in toks: + parent_name = ':'.join(path) + path += [tok] + account_name = ':'.join(path) + if not account_name in accounts.keys(): + accounts[account_name] = Account(own_name=tok, parent=accounts[parent_name]) + accounts[full_account_name].add_wealth(moneys) + class Node: + def __init__(self, indent, name, moneys): + self.indent = indent + self.name = name + self.moneys = moneys.money_dict + nodes = [] + def walk_tree(nodes, indent, account): + nodes += [Node(indent, account.own_name, account.full_moneys)] + for child in account.children: + walk_tree(nodes, indent+1, child) + for acc in account_trunk.children: + walk_tree(nodes, 0, acc) + return j2env.get_template('balance.html').render(nodes=nodes) + + def edit(self, index, sent=None, error_msg=None, edit_mode='table', copy=False): + accounts = set() + if sent or -1 == index: + content = sent if sent else ([] if 'textarea'==edit_mode else None) else: - ret += [f' {acc_kk_add} {kk_add}⬠; {needed_income_before_kk:.2f}⬠/ (1 - {kk_factor:.3f}) - {needed_income_before_kk:.2f}⬠- {kk_minimum_tax}â¬'] - diff = - last_monthbreak_est + ESt_this_month - last_monthbreak_kk_add + kk_add - if not finish: - diff += kk_minimum_tax - final_minus = expenses_so_far - old_needed_income_before_anything + diff - ret += [f' {acc_assets} {-diff} â¬'] - ret += [f' {acc_assets} {final_minus} â¬'] - year_needed = buffer_expenses + final_minus + (12 - months_passed - 1) * final_minus - if finish: - ret += [f' {acc_buffer} {-final_minus} â¬'] + content = self.bookings[index] + date_today = str(datetime.now())[:10] + if copy: + content.date = date_today + index = -1 + elif -1 == index and (content is None or [] == content): + content = Booking(date=date_today, validate=False) + if 'textarea' == edit_mode and content: + content = content.for_writing else: - ret += [f' {acc_buffer} {-final_minus} ⬠; assume as to earn in year: {acc_buffer} + {12 - months_passed - 1} * this = {year_needed}'] - return ret - - -class MyServer(BaseHTTPRequestHandler): - header = """ - - -
-ledger -balance -add free -add structured -{{date}} {{desc}} {{head_comment|e}}
-
-
{{l.acc|e}} | {{l.money|e}} | {{l.comment|e}} |
{{l.comment|e}} |
{content}" - - def ledger_as_html(self, db): - single_c_tmpl = jinja2.Template('{{c|e}}