Stegrapporter med ledger

Det känns lite barockt att använda ett bokföringsverktyg för just bokföring. Att använda det för att hålla koll på sin stegräkning känns givetvis helt rimligt.

Jag har en fil som definierar olika aktiviteter och hur många steg dessa motsvarar. Dessa data har jag lånat från en godkänd sida. Filen kallar jag aktiviteter.prices, och innehåller aktiviteter jag ibland gör och vad dessa motsvarar, nedan ett litet utdrag:

P 2000-01-01 00:00:00 kilo_steg 1000 steg
P 2000-01-01 00:00:00 h_stå 2400 steg
P 2000-01-01 00:00:00 h_gym_latt 4800 steg

Denna fil läser jag sedan in i min huvudfil, steg.ledger.

include aktiviteter.prices

2019-04-01 * Måndag
    Totalt
    Stå                                           -2 h_stå
    Steg                                        -9.4 kilo_steg

2019-04-02 * Tisdag
    Totalt
    Stå                                           -2 h_stå
    Steg                                        -7.5 kilo_steg

2019-04-03 * Onsdag
    Totalt
    Stå                                           -3 h_stå
    Steg                                      -13556 steg

Notera precis hur många dagar jag använde enheten ”kilo_steg”!

När jag varje månad kollar in hur många steg det har blivit summerar jag med ett anrop till ledger som nedan:

ledger -f steg.ledger --period "this month" --value --monthly reg Totalt

Om jag inte tar med ”Totalt” på slutet får jag en summering av de olika posterna och hur de har bidragit. Sätter jag perioden till ”this year” får jag summerat hur varje månad har blivit totalt, hur många steg/motsvarande steg jag har tagit och så vidare. Det är ingen avancerad funktionalitet direkt, men det är genomtänkt implementerat och enkelt att använda.

Tidrapporter med ledger

Jag har ju en förkärlek till att göra saker dels krångliga, men även att göra dem krångligare med hjälp av Emacs. Nu har jag äntligen hittat ett sätt att blanda in ytterligare ett steg i kedjan, nämligen ledger!

Jag för min tiddagbok för jobbet med hjälp av en textfil som tolkas av programmet ledger, som i sin tur rapporterar på lite olika sätt. Formatet är jätteenkelt, i princip:

i 2019-08-23 08:00:00 Agio:InternTid
o 2019-08-23 12:00:00

Ovan är också en ren lögn – jag är aldrig på jobbet så tidigt! Men ovan är att jag kom in vid 08:00:00 och startade med något internt för jobbet, och gick på lunch vid 12. Jag behöver inte fördefiniera några kunder eller kostnadsställen, utan jag fyller bara på. Formatet är tekniskt sett inte ett rent ledger-format, men ledger har arbetat in stöd för det ändå.

Men, för att göra livet lite lättare skrev jag lite elisp, se nedan. Står jag i en buffer där major-mode är satt till ledger-mode så kallar jag bara på den interaktiva funktionen monotux/check-in och svarar på frågorna, så infogas svaren längst ner i filen. Koden är inte vacker, Men Den Funkar Bra Nog(tm) så vi kör på den!

;; https://emacs.stackexchange.com/a/7150
(defun monotux/re-seq (regexp string)
  "Get a list of all REGEXP matches in a STRING."
  (save-match-data
    (let ((pos 0)
          matches)
      (while (string-match regexp string pos)
        (let ((payee (match-string 1 string)))
          (unless (member payee matches)
            (push (match-string 1 string) matches)))
        (setq pos (match-end 0)))
      matches)))

(defun monotux/get-timeclock-candidates (buffer)
  "Extracts available payee candidates from provided BUFFER."
  (let ((regex-payee "^i [0-9]\\{4\\}-[0-9]\\{2\\}-[0-9]\\{2\\} [0-9]\\{2\\}:[0-9]\\{2\\}:[0-9]\\{2\\} \\(.*\\)$"))
    (monotux/re-seq regex-payee buffer)))

(defun monotux/check-in ()
  "Checka in på jobbet!"
  (interactive)
  (when (derived-mode-p 'ledger-mode)
    (let* ((pbuf (current-buffer))
           (clock-in-time (concat (read-string "När kom du till jobbet? (HH:MM) ") ":00"))
           (current-date (format-time-string "%Y-%m-%d"))
           complete-line)
      (dolist (e `("i" ,current-date ,clock-in-time))
        (add-to-list 'complete-line e t))
      (let* ((payee-candidates (monotux/get-timeclock-candidates (buffer-string)))
             (payee-chosen (completing-read "Vilket konto? " payee-candidates)))
        (add-to-list 'complete-line payee-chosen t))
      (goto-char (point-max))
      (insert (concat "\n" (string-join complete-line " ") "\n")))))

(defun monotux/check-out ()
  "Checka ut också."
  (interactive)
  (when (derived-mode-p 'ledger-mode)
    (let ((clock-out-time (concat (read-string "När checkade du ut? (HH:MM) ") ":00"))
          (current-date (format-time-string "%Y-%m-%d"))
          complete-line)
      (dolist (e `("o" ,current-date ,clock-out-time))
        (add-to-list 'complete-line e t))
      (goto-char (point-max))
      (insert (concat (string-join complete-line " ") "\n")))))

För att sammanställa en veckorapport av min tid kan en använda en kommandorad som nedan:

$ ledger -f time.ledger --daily --period "this week" reg
19-Aug-23 - 19-Aug-23    (Agio:InternTid)       4.00h     4.00h

Det roliga kommer givetvis när en har fler rapporter över fler dagar. Men det lämnas som en övning för läsaren att sammanställa själv! 🙂

ortholife

Iris till vänster, XD75re till höger

Ortolinjära (ortholinear) tangentbord har blivit lite utav en grej i tangentbordssfären sista åren. Idén är att bygga bort en teknisk rest från skrivmaskinernas tid och sätta alla tangenter i ett rutnät, vilket då ska göra det mer naturligt att skriva på. Fingrarna ska då röra sig uppåt och neråt i respektive kolumn (vänsterlillfinger hanterar då q, a och z då de sitter rakt i en kolumn) snarare än i sidled plus uppåt och neråt, som på ett vanligt tangentbord. Det ska bli mer ergonomiskt.

Hela idén om att det skulle vara mer ergonomiskt är givetvis trams. De ergonomiska problemen med ett tangentbord är många och helt andra än huruvida fingrarna rör sig vertikalt eller lite hur som.

Den gissningsvis enskilt mest populära modellen av denna typ av tangentbord är Planck, döpt efter någon gammal fysiker. En Planck har 12 tangenter per rad, fyra rader och totalt 48 tangenter. Ett normalstort tangentbord har 108 tangenter. Ditt laptoptangentbord har gissningsvis ca 80 tangenter. Planck har 48. Tangentbordet till vänster i bild, mitt Iris, har 54. Tangentbordet till höger har 75.

Antalet tangenter blir intressant för den som vill göra allt det där vanliga med sitt tangentbord. Har du 48 tangenter har du det vanliga alfabetet plus några knappar till för det mest nödvändiga – men ingen sifferrad, inga funktionstangenter, inga piltangenter. Nästan inget mer alls, faktiskt.

Här är även tjusningen – få allt att fungera på ett rimligt vis! Nyckeln är egentligen inte särskilt konstig, det är som hur det fungerar på en laptop – trycker jag på F1 stängs ljudet av på min dator. Trycker jag på F1 med FN-knappen nertryckt blir det ett vanligt F1 som trycks ner. Trycker jag på alt gr och 7 får jag en måsvinge ({). Principen kallas inom tangentbordsvärlden för lager, att vi ”byter” lager när vi trycker in FN-knappen.

Men, på en Planck kan vi programmera tangentbordet och har en väldigt stor frihet att utforma vad som händer. Vi kan ha nästan hur många lager som helst. Tryck in FN1 och vänstra sidan av ditt tangentbord förvandlas till sifferdelen av ett normalt tangentbord. Tryck in FN2 och samma del är istället en samling programmeringstecken. Tryck in både FN1 och FN2 och du tas till ett tredje lager, där ditt tangentbord plötsligt låtsas vara en mus och styrs av tangenttryckningar. Tryck på Q-knappen i detta kombinerade lager och din epost-signatur skrivs ut automagiskt (den här sista är väldigt användbar för mig!).

Problemen kommer när det ska tryckas in control, alt eller shift och ett tecken till, som kanske lever på sifferlagret. Då behöver alla lager planeras, implementeras och testas. Ofta blir det fel, men det är ju här det roliga bor!

24/5 – Utdraget

Ytterligare en dagboksbild. Här står jag på uppfarten till en (numera) riven bro nära gropen.

Gropen visade sig dock vara hungrig, och numera har stängslet ätit upp hela området upp till vägkanten på E10:an. Stora delar av min promenadväg till jobbet har fått läggas om.