home · contact · privacy
Improve ledger.py.
[misc] / ledger.py
1 from http.server import BaseHTTPRequestHandler, HTTPServer
2 import sys
3 import os
4 import html
5 from urllib.parse import parse_qs, urlparse
6 hostName = "localhost"
7 serverPort = 8082
8
9
10 class HandledException(Exception):
11     pass
12
13
14 def handled_error_exit(msg):
15     print(f"ERROR: {msg}")
16     sys.exit(1)
17
18
19 def apply_booking_to_account_balances(account_sums, account, currency, amount):
20     if not account in account_sums:
21         account_sums[account] = {currency: amount}
22     elif not currency in account_sums[account].keys():
23         account_sums[account][currency] = amount
24     else:
25         account_sums[account][currency] += amount
26
27
28 def parse_lines(lines):
29     import datetime
30     import decimal
31     inside_booking = False
32     date_string, description = None, None
33     booking_lines = []
34     start_line = 0
35     bookings = []
36     comments = []
37     lines += [''] # to ensure a booking-ending last line
38     for i, line in enumerate(lines):
39         prefix = f"line {i}"
40         # we start with the case of an utterly empty line
41         comments += [""]
42         stripped_line = line.rstrip()
43         if stripped_line == '':
44             if inside_booking:
45                 # assume we finished a booking, finalize, and commit to DB
46                 if len(booking_lines) < 2:
47                     raise HandledException(f"{prefix} booking ends to early")
48                 booking = Booking(date_string, description, booking_lines, start_line)
49                 bookings += [booking]
50             # expect new booking to follow so re-zeroall booking data
51             inside_booking = False
52             date_string, description = None, None
53             booking_lines = []
54             continue
55         # if non-empty line, first get comment if any, and commit to DB
56         split_by_comment = stripped_line.split(sep=";", maxsplit=1)
57         if len(split_by_comment) == 2:
58             comments[i] = split_by_comment[1]
59         # 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
60         non_comment = split_by_comment[0].rstrip()
61         if non_comment.rstrip() == '':
62              if inside_booking:
63                  booking_lines += ['']
64              continue
65         # if we're starting a booking, parse by first-line pattern
66         if not inside_booking:
67             start_line = i
68             toks = non_comment.split(maxsplit=1)
69             date_string = toks[0]
70             try:
71                 datetime.datetime.strptime(date_string, '%Y-%m-%d')
72             except ValueError:
73                 raise HandledException(f"{prefix} bad date string: {date_string}")
74             try:
75                 description = toks[1]
76             except IndexError:
77                 raise HandledException(f"{prefix} bad description: {description}")
78             inside_booking = True
79             booking_lines += [non_comment]
80             continue
81         # otherwise, read as transfer data
82         toks = non_comment.split()  # ignore specification's allowance of single spaces in names
83         if len(toks) > 3:
84             raise HandledException(f"{prefix} too many booking line tokens: {toks}")
85         amount, currency = None, None
86         account_name = toks[0]
87         if account_name[0] == '[' and account_name[-1] == ']':
88             # ignore specification's differentiation of "virtual" accounts
89             account_name = account_name[1:-1]
90         decimal_chars = ".-0123456789"
91         if len(toks) == 3:
92             i_currency = 1
93             try:
94                 amount = decimal.Decimal(toks[1])
95                 i_currency = 2
96             except decimal.InvalidOperation:
97                 try:
98                     amount = decimal.Decimal(toks[2])
99                 except decimal.InvalidOperation:
100                     raise HandledException(f"{prefix} no decimal number in: {toks[1:]}")
101             currency = toks[i_currency]
102             if currency[0] in decimal_chars:
103                 raise HandledException(f"{prefix} currency starts with int, dot, or minus: {currency}")
104         elif len(toks) == 2:
105             value = toks[1]
106             inside_amount = False
107             inside_currency = False
108             amount_string = ""
109             currency = ""
110             dots_counted = 0
111             for i, c in enumerate(value):
112                 if i == 0:
113                     if c in decimal_chars:
114                         inside_amount = True
115                     else:
116                         inside_currency = True
117                 if inside_currency:
118                     if c in decimal_chars and len(amount_string) == 0:
119                         inside_currency = False
120                         inside_amount = True
121                     else:
122                         currency += c
123                         continue
124                 if inside_amount:
125                     if c not in decimal_chars:
126                         if len(currency) > 0:
127                             raise HandledException(f"{prefix} amount has non-decimal chars: {value}")
128                         inside_currency = True
129                         inside_amount = False
130                         currency += c
131                         continue
132                     if c == '-' and len(amount_string) > 1:
133                         raise HandledException(f"{prefix} amount has non-start '-': {value}")
134                     if c == '.':
135                         if dots_counted > 1:
136                             raise HandledException(f"{prefix} amount has multiple dots: {value}")
137                         dots_counted += 1
138                     amount_string += c
139             if len(amount_string) == 0:
140                 raise HandledException(f"{prefix} amount missing: {value}")
141             if len(currency) == 0:
142                 raise HandledException(f"{prefix} currency missing: {value}")
143             amount = decimal.Decimal(amount_string)
144         booking_lines += [(account_name, amount, currency)]
145     if inside_booking:
146         raise HandledException(f"{prefix} last booking unfinished")
147     return bookings, comments
148
149 class Booking:
150
151     def __init__(self, date_string, description, booking_lines, start_line):
152         self.date_string = date_string
153         self.description = description
154         self.lines = booking_lines
155         self.start_line = start_line
156         self.validate_booking_lines()
157         self.account_changes = self.parse_booking_lines_to_account_changes()
158
159     def validate_booking_lines(self):
160         prefix = f"booking at line {self.start_line}"
161         sums = {}
162         empty_values = 0
163         for line in self.lines[1:]:
164             if line == '':
165                 continue
166             _, amount, currency = line
167             if amount is None:
168                 if empty_values > 0:
169                     raise HandledException(f"{prefix} relates more than one empty value of same currency {currency}")
170                 empty_values += 1
171                 continue
172             if currency not in sums:
173                 sums[currency] = 0
174             sums[currency] += amount
175         if empty_values == 0:
176             for k, v in sums.items():
177                 if v != 0:
178                     raise HandledException(f"{prefix} does not sum up to zero")
179         else:
180             sinkable = False
181             for k, v in sums.items():
182                 if v != 0:
183                     sinkable = True
184             if not sinkable:
185                 raise HandledException(f"{prefix} has empty value that cannot be filled")
186
187     def parse_booking_lines_to_account_changes(self):
188         account_changes = {}
189         debt = {}
190         sink_account = None
191         for line in self.lines[1:]:
192             if line == '':
193                 continue
194             account, amount, currency = line
195             if amount is None:
196                 sink_account = account
197                 continue
198             apply_booking_to_account_balances(account_changes, account, currency, amount)
199             if currency not in debt:
200                 debt[currency] = amount
201             else:
202                 debt[currency] += amount
203         if sink_account:
204             for currency, amount in debt.items():
205                 apply_booking_to_account_balances(account_changes, sink_account, currency, -amount)
206         return account_changes
207
208
209
210 class Database:
211
212     def __init__(self):
213         db_name = "_ledger"
214         self.db_file = db_name + ".json"
215         self.lock_file = db_name+ ".lock"
216         self.bookings = []
217         self.comments = []
218         self.real_lines = []
219         if os.path.exists(self.db_file):
220             with open(self.db_file, "r") as f:
221                 self.real_lines += f.readlines()
222         ret = parse_lines(self.real_lines)
223         self.bookings += ret[0]
224         self.comments += ret[1]
225
226     def get_lines(self, start, end):
227         return db.real_lines[start:end]
228
229     def replace(self, start, end, lines):
230         import shutil
231         if os.path.exists(self.lock_file):
232             raise HandledException('Sorry, lock file!')
233         if os.path.exists(self.db_file):
234             shutil.copy(self.db_file, self.db_file + ".bak")
235         f = open(self.lock_file, 'w+')
236         f.close()
237         text = ''.join(self.real_lines[:start]) + '\n'.join(lines) + ''.join(self.real_lines[end:])
238         with open(self.db_file, 'w') as f:
239             f.write(text);
240         os.remove(self.lock_file)
241
242     def append(self, lines):
243         import shutil
244         if os.path.exists(self.lock_file):
245             raise HandledException('Sorry, lock file!')
246         if os.path.exists(self.db_file):
247             shutil.copy(self.db_file, self.db_file + ".bak")
248         f = open(self.lock_file, 'w+')
249         f.close()
250         with open(self.db_file, 'a') as f:
251             f.write('\n' + '\n'.join(lines) + '\n');
252         os.remove(self.lock_file)
253
254
255 class MyServer(BaseHTTPRequestHandler):
256     header = """<html>
257 <meta charset="UTF-8">
258 <body>
259 <a href="/ledger">ledger</a>
260 <a href="/balance">balance</a>
261 <a href="/add_free">add free</a>
262 <a href="/add_structured">add structured</a>
263 <hr />
264 """
265     footer = "</body>\n<html>"
266
267     def do_POST(self):
268         length = int(self.headers['content-length'])
269         postvars = parse_qs(self.rfile.read(length).decode(), keep_blank_values=1)
270         parsed_url = urlparse(self.path)
271         if '/add_structured' == parsed_url.path:
272             n_lines = int(len(postvars) / 4) 
273             date = postvars['date'][0] 
274             description = postvars['description'][0]
275             start_comment = postvars['line_0_comment'][0]
276             lines = [f'{date} {description} ; {start_comment}']
277             for i in range(1, n_lines):
278                 account = postvars[f'line_{i}_account'][0]
279                 amount = postvars[f'line_{i}_amount'][0]
280                 currency = postvars[f'line_{i}_currency'][0]
281                 comment = postvars[f'line_{i}_comment'][0]
282                 new_main = f'{account} {amount} {currency}'
283                 if '' == new_main.rstrip() == comment.rstrip():  # don't write empty lines
284                     continue
285                 new_line = new_main
286                 if comment.rstrip() != '':
287                     new_line += f' ; {comment}'
288                 lines += [new_line] 
289         elif '/add_free' == parsed_url.path:
290             lines = postvars['booking'][0].splitlines()
291         start = int(postvars['start'][0])
292         end = int(postvars['end'][0])
293         try:
294             _, _ = parse_lines(lines)
295             if start == end == 0:
296                 db.append(lines)
297             else:
298                 db.replace(start, end, lines)
299             self.send_response(301)
300             self.send_header('Location', '/')
301             self.end_headers()
302         except HandledException as e:
303             self.send_response(400)
304             self.end_headers()
305             page = f'{self.header}ERROR: {e}{self.footer}'
306             self.wfile.write(bytes(page, "utf-8"))
307
308     def do_GET(self):
309         self.send_response(200)
310         self.send_header("Content-type", "text/html")
311         self.end_headers()
312         db = Database()
313         parsed_url = urlparse(self.path)
314         page = self.header + ''
315         params = parse_qs(parsed_url.query)
316         start = int(params.get('start', ['0'])[0])
317         end = int(params.get('end', ['0'])[0])
318         if parsed_url.path == '/balance':
319             page += self.balance_as_html(db)
320         elif parsed_url.path == '/add_free':
321             page += self.add_free(db, start, end)
322         elif parsed_url.path == '/add_structured':
323             bonus_lines = int(params.get('bonus_lines', ['0'])[0])
324             page += self.add_structured(db, start, end)
325         else:
326             page += self.ledger_as_html(db)
327         page += self.footer
328         self.wfile.write(bytes(page, "utf-8"))
329
330     def balance_as_html(self, db):
331         account_sums = {}
332         for booking in db.bookings:
333             for account, changes in booking.account_changes.items():
334                 for currency, amount in changes.items():
335                     apply_booking_to_account_balances(account_sums, account, currency, amount)
336         account_tree = {}
337         def collect_branches(account_name, path):
338             node = account_tree
339             path_copy = path[:]
340             while len(path_copy) > 0:
341                 step = path_copy.pop(0)
342                 node = node[step]
343             toks = account_name.split(":", maxsplit=1)
344             parent = toks[0]
345             if parent in node.keys():
346                 child = node[parent]
347             else:
348                 child = {}
349                 node[parent] = child
350             if len(toks) == 2:
351                 k, v = collect_branches(toks[1], path + [parent])
352                 if k not in child.keys():
353                     child[k] = v
354                 else:
355                     child[k].update(v)
356             return parent, child
357         for account_name in sorted(account_sums.keys()):
358             k, v = collect_branches(account_name, [])
359             if k not in account_tree.keys():
360                 account_tree[k] = v
361             else:
362                 account_tree[k].update(v)
363         def collect_totals(parent_path, tree_node):
364             for k, v in tree_node.items():
365                 child_path = parent_path + ":" + k
366                 for currency, amount in collect_totals(child_path, v).items():
367                     apply_booking_to_account_balances(account_sums, parent_path, currency, amount)
368             return account_sums[parent_path]
369         for account_name in account_tree.keys():
370             account_sums[account_name] = collect_totals(account_name, account_tree[account_name])
371         lines = []
372         def print_subtree(lines, indent, node, subtree, path):
373             line = f"{indent}{node}"
374             n_tabs = 5 - (len(line) // 8)
375             line += n_tabs * "\t"
376             if "€" in account_sums[path + node].keys():
377                 amount = account_sums[path + node]["€"]
378                 line += f"{amount:9.2f} €\t"
379             else:
380                 line += f"\t\t"
381             for currency, amount in account_sums[path + node].items():
382                 if currency != '€' and amount > 0:
383                     line += f"{amount:5.2f} {currency}\t"
384             lines += [line]
385             indent += "  "
386             for k, v in sorted(subtree.items()):
387                 print_subtree(lines, indent, k, v, path + node + ":")
388         for k, v in sorted(account_tree.items()):
389             print_subtree(lines, "", k, v, "")
390         content = "\n".join(lines)
391         return f"<pre>{content}</pre>"
392
393     def ledger_as_html(self, db):
394         lines = []
395         line_sep = '<br />'
396         for comment in db.comments:
397             line = f' ; {comment}' if comment != '' else ''
398             lines += [line + line_sep]
399         for booking in db.bookings:
400             i = booking.start_line
401             suffix = lines[i]
402             lines[i] = f'<p>{booking.date_string} {booking.description}{suffix}'
403             for booking_line in booking.lines[1:]:
404                 i += 1
405                 if booking_line == '':
406                     continue
407                 suffix = f' {lines[i]}' if len(lines[i]) > 0 else ''
408                 value = f' {booking_line[1]} {booking_line[2]}' if booking_line[1] else ''
409                 lines[i] = f'{booking_line[0]}{value}{suffix}'
410             lines[i] = lines[i][:-len(line_sep)] + f"""</p>
411 edit:
412 <a href="/add_structured?start={booking.start_line}&end={i+1}">structured</a>
413 / <a href="/add_free?start={booking.start_line}&end={i+1}">free</a>
414 <br />"""
415         return '\n'.join(lines)
416
417     def header_add_form(self, action):
418         return f"<form method=\"POST\" action=\"/{action}\">\n"
419
420     def footer_add_form(self, start, end):
421         return f"""
422 <input type="hidden" name="start" value={start} />
423 <input type="hidden" name="end" value={end} />
424 <input type="submit">
425 </form>"""
426
427     def add_free(self, db, start=0, end=0):
428         content = html.escape(''.join(db.get_lines(start, end)))
429         return f'{self.header_add_form("add_free")}<textarea name="booking" rows="8" cols="80">{content}</textarea>{self.footer_add_form(start, end)}'
430
431     def add_structured(self, db, start=0, end=0, bonus_lines=10):
432         import datetime
433         lines = db.get_lines(start, end) 
434         bookings, comments = parse_lines(lines) 
435         if len(bookings) > 1:
436             raise HandledException('can only edit single Booking')
437         input_lines = ''
438         last_line = 0
439         def inpu(name, val=""):
440             val = val if val is not None else "" 
441             safe_val = html.escape(str(val))
442             return f'<input name="{name}" value="{safe_val}" />'
443         if len(bookings) == 0:
444             today = str(datetime.datetime.now())[:10]
445             input_lines += f'{inpu("date", today)} {inpu("description")} ; {inpu("line_0_comment")}<br />' 
446             last_line = 1 
447         else:
448             booking = bookings[0]
449             last_line = len(comments) 
450             input_lines += f'{inpu("date", booking.date_string)} {inpu("description", booking.description)} ; {inpu("line_0_comment", comments[0])}<br />' 
451             for i in range(1, len(comments)):
452                 account = amount = currency = ''
453                 if i < len(booking.lines) and booking.lines[i] != '':
454                     account = booking.lines[i][0]
455                     amount = booking.lines[i][1]
456                     currency = booking.lines[i][2]
457                 input_lines += f'{inpu(f"line_{i}_account", account)} {inpu(f"line_{i}_amount", amount)} {inpu(f"line_{i}_currency", currency)} ; {inpu(f"line_{i}_comment", comments[i])}<br />' 
458         for j in range(bonus_lines):
459             i = j + last_line 
460             input_lines += f'{inpu(f"line_{i}_account")} {inpu(f"line_{i}_amount")} {inpu(f"line_{i}_currency")} ; {inpu(f"line_{i}_comment")}<br />'
461         return f'{self.header_add_form("add_structured")}{input_lines}{self.footer_add_form(start, end)}'
462
463
464 db = Database()
465 if __name__ == "__main__":     
466     webServer = HTTPServer((hostName, serverPort), MyServer)
467     print(f"Server started http://{hostName}:{serverPort}")
468     try:
469         webServer.serve_forever()
470     except KeyboardInterrupt:
471         pass
472     webServer.server_close()
473     print("Server stopped.")