actions.lua (9bd8b32) - memoire

actions.lua

--[[
    gets the score (again/hard/good/easy/correction) from a string by first character
    scores are numbers, higher is easier, -1 is correction
]]
local function succfromstr(s)
    local f = s:sub(1, 1):lower()
    if f == "0" or f == "a" then
        return 0
    elseif f == "1" or f == "h" then
        return 0.5
    elseif f == "2" or f == "g" then
        return 1
    elseif f == "3" or f == "e" then
        return 1.5
    elseif f == "-" or f == "c" then
        return -1
    end
    return 1
end

--[[
    clears the terminal
    implementation may be platform-specific
]]
local function clear()
    -- ANSI
    io.write("\x1b[H\x1b[J")
end

--[[
    display text with images, inserted with `IMG[path]`
    implementation may be platform-specific
    `basepath` points to the base directory of the images
]]
local function imgify(text, basepath, conf, boldable)
    if conf:get("BoldContext") then
        local csi, cei = text:find("^[^:]+:")
        if csi then
            local cpt = text:sub(csi, cei)
            io.write("\x1b[1m")
            io.write(cpt)
            io.write("\x1b[0m")
            text = text:sub(cei + 1)
        end
    end
    -- adapted from https://stackoverflow.com/a/1579673
    local IMG_PATTERN = "IMG%[([^%]]+)%]"
    local PATTERN = "(.-)" .. IMG_PATTERN
    -- Linux/dwm
    local DISPIMG = function(path, st)
        if path and #path > 0 then
            os.execute(string.format(
                "/usr/local/bin/iv -t '%s' %s%s &",
                st:gsub("'", "\""):gsub(IMG_PATTERN, ""), basepath, path
            ))
        end
    end
    local lastend = 1
    local mstart, mend, prevtext, imgpath = text:find(PATTERN)
    io.write(prevtext or "")
    DISPIMG(imgpath, text)
    while mstart do
        lastend = mend + 1
        mstart, mend, prevtext, imgpath = text:find(PATTERN, lastend)
        io.write(prevtext or "")
        DISPIMG(imgpath, text)
    end
    if lastend <= #text then
        io.write(text:sub(lastend))
    end
end

--[[
    rounds `x` to `n` places (default 0) after the radix point
    in base `b` (default 10)
]]
local function round(x, n, b)
    local b = b or 10
    local n = n or 0
    if n == 0 then
        return math.tointeger(math.floor(x * b ^ n) / b ^ n)
    else
        return math.floor(x * b ^ n) / b ^ n
    end
end

--[[
    return human-friendly string to present a duration (input in seconds),
    e.g. "44:37", "4.8h", "11d", "8.3m", "17.4y"
]]
local function disptime(ts)
    local YDAY = 365.24
    local MDAY = YDAY / 12
    local DSEC = 86400
    local HSEC = 3600
    if ts >= 3 * YDAY * DSEC then
        return round(ts / (YDAY * DSEC), 1) .. "y"
    elseif ts >= 4 * MDAY * DSEC then
        return round(ts / (MDAY * DSEC), 1) .. "m"
    elseif ts >= 10 * DSEC then
        return round(ts / DSEC) .. "d"
    elseif ts >= 1.5 * DSEC then
        return round(ts / DSEC, 1) .. "d"
    elseif ts >= 8 * HSEC then
        return round(ts / HSEC) .. "h"
    elseif ts >= HSEC then
        return round(ts / HSEC, 1) .. "h"
    else
        return string.format("%d:%02d", round(ts / 60), round(ts % 60))
    end
end

--[[
    check if standard input is a terminal
]]
local function isatty()
    local succ = os.execute("tty >/dev/null")
    return succ
end

--[[
    return number indicating how much of a leech the prompt is
]]
local function badness(pr)
    return pr.fail / (pr.fail + pr.succ) * math.log(pr.fail)
end

--[[
    show list of selected percentile-samples into a list,
    with each entry modulated by the given function
]]
local function showpctiles(list, pctiles, func, name)
    local s = "%ile"
    for _, v in ipairs(pctiles) do
        s = string.format("%s\t%.1f", s, 100 * v)
    end
    s = s .. "\n" .. name
    for _, v in ipairs(pctiles) do
        s = s .. "\t" .. func(list[math.ceil(v * #list)])
    end
    return s .. "\n"
end

local actions = {
    a = {
        desc = "(a)dd card (from stdin)",
        nd = true,
        fn = function(config, deck)
            if isatty() then
                io.write("Reading prompts; press Ctrl-D to stop\n")
            end
            local rt = io.read("a")
            local cardctr = 0
            local prctr = 0
            for pt in rt:gmatch("(..-)\n\n") do
                local nc = {}
                -- these Prompts will just be converted to Rec, so we don't need to exclude answers from prompt-text
                for _re in pt:gmatch("%{[^%}]+%}") do
                    table.insert(nc, Prompt:new(pt, "", os.time(), 30, 0, 0, os.time(), config:get("StartingEase") or 2.5))
                    prctr = prctr + 1
                end
                table.insert(deck, nc)
                cardctr = cardctr + 1
            end
            io.write(string.format(
                "Added %d cards (%d prompts)\n",
                cardctr,
                prctr
            ))
            if cardctr > 0 then
                return deck
            end
        end,
    },

c = {
        desc = "(c)orrect card (with card:prompt index)",
        nd = true,
        ni = true,
        fn = function(config, deck, _, ip)
            local sp = deck[ip[1]][ip[2]]
            local rt = sp:spt()
            local fname = "memoire_cc.tmp"
            local fh = io.open(fname, "w")
            fh:write(rt)
            fh:close()
            os.execute(string.format(
                "%s %q",
                os.getenv("EDITOR") or "vi",
                fname
            ))
            fh = io.open(fname, "r")
            local nt = fh:read("a"):gsub("%s+$", ""):gsub("^%s+", "")
            fh:close()
            os.remove(fname)
            if nt ~= sp:spt() and nt ~= "" then
                local cardrec = Prompt:torec(deck[ip[1]])
                cardrec.PromptText = { nt }
                deck[ip[1]] = Prompt:fromrecs({ cardrec }, config)[1]
                return deck
            end
        end,
    },

h = {
        desc = "(h)elp",
        nd = false,
        fn = function()
            io.write(string.format("Usage: %s ACTION\n\nACTION may be one of\n", arg[0]))
            local sal = {}
            for _, v in pairs(ACTIONS) do
                table.insert(sal, v.desc)
            end
            table.sort(sal)
            for _, v in ipairs(sal) do
                io.write(string.format("\t%s\n", v))
            end
        end
    },

l = {
        desc = "(l)eech search",
        nd = true,
        fn = function(config, deck)
            local leechqueue = {}
            for i, cg in ipairs(deck) do
                for j, pr in ipairs(cg) do
                    if pr.ease < 2 and pr.delay >= 0 then
                        table.insert(leechqueue, { i, j })
                    end
                end
            end
            table.sort(leechqueue, function(a, b)
                return badness(deck[a[1]][a[2]]) > badness(deck[b[1]][b[2]])
            end)
            io.write(string.format("Detected %d leeches:\n", #leechqueue))
            for _, ij in ipairs(leechqueue) do
                io.write(string.format("%d:%d %s\n", ij[1], ij[2], deck[ij[1]][ij[2]]))
            end
        end,
    },

r = {
        desc = "(r)eview sesion",
        nd = true,
        fn = function(config, deck, deckfname)
            if not isatty() then
                io.write("Review should be done in the terminal\n")
                return nil
            end
            -- collect list of index-pairs for prompts to be reviewed this session
            local ctrt = review.list(deck)
            io.write(string.format(
                "%d prompts are ready for review.\nHow many to review in this session? ", #ctrt
            ))
            io.flush()
            local climt = io.read("l")
            local climn = tonumber(climt)
            if not climn then
                io.write("Input not a number; aborting\n")
                return nil
            end
            local lrc = 0
            local editqueue = {}
            local start = os.time()
            -- review prompts in this session's set
            for ind, ip in ipairs(ctrt) do
                if ind > climn then
                    break
                end
                local pr = deck[ip[1]][ip[2]]
                -- remove braces for display
                local pst = pr.text:gsub("%{([^{}]+)%}", "%1")
                local st = os.time()
                imgify(pst:gsub("%%A", "___"), deckfname:match(".*/") or "", config)
                io.write("\n")
                io.read("l")
                clear()
                imgify(
                    pst:gsub("%%A", "\x1b[1m" .. (pr.ans:gsub("%%", "%%%%")) .. "\x1b[0m"),
                    deckfname:match(".*/") or "",
                    config
                )
                io.write(string.format(
                    "\nAgain / Hard (%s) / Good (%s) / Easy (%s) / Correction ",
                    disptime(review.schedule(pr, st, 0.5, config)),
                    disptime(review.schedule(pr, st, 1, config)),
                    disptime(review.schedule(pr, st, 1.5, config))
                ))
                io.flush()
                local resp = io.read("l")
                local sc = succfromstr(resp)
                if sc == -1 then
                    table.insert(editqueue, ip)
                else
                    if sc == 0 then
                        lrc = lrc + 1
                    end
                    review.update(deck[ip[1]][ip[2]], st, sc, config)
                end
                clear()
                if resp:sub(#resp):lower() == "q" then
                    climn = ind
                    break
                end
            end
            if #ctrt > 0 then
                local endt = os.time()
                io.write(string.format(
                    "Reviewed %d prompts in %d seconds\n",
                    math.min(#ctrt, climn),
                    endt - start
                ))
                local s
                if lrc == 1 then s = "" else s = "s" end
                io.write(string.format(
                    "(%d lapse%s, %f seconds per card)\n",
                    lrc, s, (endt - start) / math.min(#ctrt, climn)
                ))
            end
            if #editqueue > 0 then
                io.write(string.format("The following cards are marked for correction:\n"))
                for _, ip in ipairs(editqueue) do
                    io.write(string.format("%d:%d %s\n", ip[1], ip[2], deck[ip[1]][ip[2]]))
                end
            end
            if climn > 0 then
                return deck
            end
        end,
    },

s = {
        desc = "(s)tatistics (with optional query)",
        nd = true,
        nq = true,
        fn = function(config, deck, deckfname, qs)
            local tcc = 0
            local tsc = 0
            local tfc = 0
            local spc = 0
            local expdeck = {}
            for _, card in ipairs(deck) do
                local rtc
                for _, pr in ipairs(card) do
                    if not qs or (pr.text:find(qs) or pr.ans:find(qs)) then
                        rtc = true
                        table.insert(expdeck, pr)
                        tsc = tsc + pr.succ
                        tfc = tfc + pr.fail
                        if pr.delay < 0 then
                            spc = spc + 1
                        end
                    end
                end
                if rtc then
                    tcc = tcc + 1
                end
            end
            local qfn
            if qs then
                qfn = string.format(" (filtered with query %q)", qs)
            else
                qfn = ""
            end
            io.write(string.format(
                "%s%s has %d cards and %d total prompts\n",
                deckfname, qfn, tcc, #expdeck
            ))
            io.write(string.format(
                "(average %.2f prompts per card, %d/%.1f%% prompts suspended).\n",
                #expdeck / tcc, spc, 100 * spc / #expdeck
            ))
            io.write(string.format(
                "The deck's prompts have been reviewed a total of %d times\n",
                tsc + tfc
            ))
            io.write(string.format(
                "(average %.2f reviews per prompt), overall retention %.2f%%.\n",
                (tsc + tfc) / #expdeck, 100 * tsc / (tsc + tfc)
            ))
            table.sort(expdeck, function(a, b) return a.ease < b.ease end)
            io.write("\n" .. showpctiles(expdeck, { 0.01, 0.05, 0.1, 0.25, 0.5, 0.8, 0.95 }, function(pr)
                return string.format("%.2f", pr.ease)
            end, "Ease"))
            table.sort(expdeck, function(a, b) return a.delay > 0 and a.delay < b.delay end)
            io.write("\n" .. showpctiles(expdeck, { 0.01, 0.05, 0.2, 0.5, 0.8, 0.95, 0.99 }, function(pr)
                return disptime(pr.delay)
            end, "Delay"))
            table.sort(expdeck, function(a, b) return a:retention() < b:retention() end)
            io.write("\n" .. showpctiles(expdeck, { 0.01, 0.05, 0.1, 0.15, 0.2, 0.25, 0.4 }, function(pr)
                return math.floor(100 * pr:retention())
            end, "Ret. %"))
            table.sort(expdeck, function(a, b) return a.succ + a.fail < b.succ + b.fail end)
            io.write("\n" .. showpctiles(expdeck, { 0.25, 0.5, 0.7, 0.85, 0.95, 0.99, 0.998 }, function(pr)
                return pr.succ + pr.fail
            end, "Reviews"))
            table.sort(expdeck, function(a, b) return (a.created or 99^98) > (b.created or 99^99) end)
            io.write("\n" .. showpctiles(expdeck, { 0.1, 0.25, 0.5, 0.75, 0.9, 0.95, 0.99 }, function(pr)
                return disptime(os.time() - pr.created)
            end, "Age"))
            table.sort(deck, function(a, b) return #a < #b end)
            io.write("\n" .. showpctiles(deck, { 0.2, 0.5, 0.8, 0.95, 0.99, 0.998 }, function(card)
                return #card
            end, "Prompts"))
            table.sort(expdeck, function(a, b) return a.time + a.delay < b.time + b.delay end)
            io.write("\nUpcoming due prompts wrt days from now:\n")
            local ppi = 1
            local mpi = 1
            for dc = 1,100 do
                for uc = ppi,#expdeck do
                    if expdeck[uc].time + expdeck[uc].delay - os.time() > dc * 86400 then
                        mpi = uc
                        break
                    end
                end
                if dc <= 10 or dc % 10 == 0 then
                    io.write(string.format("%d\t%s %d\n", dc, ("\u{2588}"):rep(math.ceil((mpi - ppi) / 10)), mpi - ppi))
                end
                ppi = mpi
            end
        end
    },

t = {
        desc = "(t)oggle suspension of prompt (with card:prompt index)",
        nd = true,
        ni = true,
        fn = function(config, deck, _, ip)
            local sp = deck[ip[1]][ip[2]]
            local dir
            if sp.delay < 0 then
                dir = "Restoring"
            else
                dir = "Suspending"
            end
            io.write(string.format("%s %s\n", dir, sp))
            sp.delay = -sp.delay
            return deck
        end,
    },
}

return actions

memoire

More clearly document actions