dktcli 1.0.0__py3-none-any.whl

devkittools/tools/findtool.py

@@ -0,0 +1,119 @@
+"""dkt find (fd) - fast project-wide text search (like grep/ripgrep) and file finder."""
+from __future__ import annotations
+
+import argparse
+import fnmatch
+import re
+
+from ..utils import DktError, c, color_enabled, is_binary_chunk, list_project_files, resolve_folder
+
+META = ("Project & Code", "find", "fd", "search text in a project (respects .gitignore) or find files")
+
+EPILOG = """\
+examples:
+  dkt fd "def main"                  search for text/regex in every file
+  dkt fd TODO -i --ext .py .js       case-insensitive, only some extensions
+  dkt fd "class \\w+Error" -C 2      2 lines of context
+  dkt fd -n "*.test.js"              find files by name (glob)
+  dkt fd foo -l                      only list matching file names
+  dkt fd "old_name" --replace new_name --yes   project-wide find & replace
+"""
+
+
+def run(args) -> int:
+    folder = resolve_folder(args.folder)
+    files = list_project_files(folder)
+    if args.ext:
+        exts = tuple(e if e.startswith(".") else "." + e for e in args.ext)
+        files = [f for f in files if str(f).lower().endswith(exts)]
+    if args.name:
+        pat = args.name.lower()
+        hits = [f for f in files if fnmatch.fnmatch(f.name.lower(), pat) or fnmatch.fnmatch(str(f).replace("\\", "/").lower(), pat)]
+        for f in hits:
+            print(str(f).replace("\\", "/"))
+        print(c("\n  %d file%s" % (len(hits), "" if len(hits) == 1 else "s"), "gray"))
+        return 0 if hits else 1
+    if not args.pattern:
+        raise DktError("Give something to search for, or use -n \"*.py\" to find files by name.")
+    flags = re.I if args.i else 0
+    src = args.pattern
+    if args.fixed:
+        src = re.escape(args.pattern)
+    try:
+        rx = re.compile(src, flags)
+    except re.error as e:
+        raise DktError("Invalid pattern: %s (use -F for plain text)" % e)
+
+    total = 0
+    nfiles = 0
+    changed = 0
+    for rel in files:
+        p = folder / rel
+        try:
+            if p.stat().st_size > 2_000_000:
+                continue
+            raw = p.read_bytes()
+        except OSError:
+            continue
+        if is_binary_chunk(raw[:4096]):
+            continue
+        text = raw.decode("utf-8", errors="replace")
+        lines = text.splitlines()
+        hit_idx = [i for i, ln in enumerate(lines) if rx.search(ln)]
+        if not hit_idx:
+            continue
+        nfiles += 1
+        total += len(hit_idx)
+        name = str(rel).replace("\\", "/")
+        if args.replace is not None:
+            if args.yes:
+                new = rx.sub(args.replace, text)
+                if new != text:
+                    p.write_bytes(new.encode("utf-8"))
+                    changed += 1
+            else:
+                print("  %s  %d match%s" % (c(name, "bcyan"), len(hit_idx), "" if len(hit_idx) == 1 else "es"))
+            continue
+        if args.l:
+            print(name)
+            continue
+        print("\n" + c(name, "bold bmagenta"))
+        shown = set()
+        for i in hit_idx:
+            for j in range(max(0, i - args.C), min(len(lines), i + args.C + 1)):
+                if j in shown:
+                    continue
+                shown.add(j)
+                ln = lines[j]
+                if len(ln) > 220:
+                    ln = ln[:220] + "..."
+                if j == i or rx.search(lines[j]):
+                    if color_enabled():
+                        ln = rx.sub(lambda m: c(m.group(0), "reverse byellow") if m.group(0) else "", ln)
+                    print("  %s:%s" % (c(str(j + 1).rjust(5), "bgreen"), ln))
+                else:
+                    print("  %s %s" % (c(str(j + 1).rjust(5), "gray"), c(ln, "gray")))
+    if args.replace is not None and not args.yes:
+        print(c("\n  dry run - %d match%s in %d files. Add --yes to apply." % (total, "" if total == 1 else "es", nfiles), "yellow"))
+    elif args.replace is not None:
+        print(c("\n  replaced in %d file%s" % (changed, "" if changed == 1 else "s"), "green"))
+    else:
+        print(c("\n  %d match%s in %d file%s" % (total, "" if total == 1 else "es", nfiles, "" if nfiles == 1 else "s"), "gray"))
+    return 0 if total else 1
+
+
+def register(sub, common) -> None:
+    p = sub.add_parser("find", aliases=["fd"], parents=[common], help=META[3],
+                       description="Search file contents or names inside a project.",
+                       epilog=EPILOG, formatter_class=argparse.RawDescriptionHelpFormatter)
+    p.add_argument("pattern", nargs="?", help="regex (or plain text with -F)")
+    p.add_argument("-f", "--folder", metavar="PATH")
+    p.add_argument("-i", action="store_true", help="ignore case")
+    p.add_argument("-F", "--fixed", action="store_true", help="treat pattern as plain text")
+    p.add_argument("-C", type=int, default=0, metavar="N", help="lines of context")
+    p.add_argument("-l", action="store_true", help="only print file names")
+    p.add_argument("-n", "--name", metavar="GLOB", help="find files by name instead")
+    p.add_argument("--ext", nargs="+", metavar="EXT", help="only these extensions")
+    p.add_argument("--replace", metavar="TEXT", help="replace matches (dry run unless --yes)")
+    p.add_argument("--yes", action="store_true", help="apply --replace")
+    p.set_defaults(func=run)

devkittools/tools/gen.py

@@ -0,0 +1,182 @@
+"""dkt gen (g) - generate UUIDs, ULIDs, passwords, tokens, short ids, lorem ipsum, slugs."""
+from __future__ import annotations
+
+import argparse
+import math
+import os
+import re
+import secrets
+import string
+import time
+import unicodedata
+import uuid
+
+from ..utils import DktError, c, info, output_result
+
+META = ("Generate & Convert", "gen", "g", "UUIDs, ULIDs, passwords, tokens, lorem ipsum, slugs")
+
+EPILOG = """\
+examples:
+  dkt gen uuid -n 5            five UUIDv4
+  dkt gen uuid --v7            time-sortable UUIDv7
+  dkt gen ulid
+  dkt gen password -l 24 --copy
+  dkt gen token --bytes 32     64 hex chars, good for secrets / API keys
+  dkt gen id -l 10             short URL-safe id
+  dkt gen lorem -p 2           two paragraphs
+  dkt gen slug "Hello, World! Ünïcode"
+"""
+
+_CROCKFORD = "0123456789ABCDEFGHJKMNPQRSTVWXYZ"
+_LOREM = ("lorem ipsum dolor sit amet consectetur adipiscing elit sed do eiusmod tempor incididunt ut "
+          "labore et dolore magna aliqua enim ad minim veniam quis nostrud exercitation ullamco laboris "
+          "nisi aliquip ex ea commodo consequat duis aute irure in reprehenderit voluptate velit esse "
+          "cillum fugiat nulla pariatur excepteur sint occaecat cupidatat non proident sunt culpa qui "
+          "officia deserunt mollit anim id est laborum").split()
+
+
+def uuid7() -> str:
+    ms = int(time.time() * 1000) & ((1 << 48) - 1)
+    rand_a = secrets.randbits(12)
+    rand_b = secrets.randbits(62)
+    value = (ms << 80) | (0x7 << 76) | (rand_a << 64) | (0b10 << 62) | rand_b
+    return str(uuid.UUID(int=value))
+
+
+def ulid() -> str:
+    ms = int(time.time() * 1000)
+    out = ""
+    for _ in range(10):
+        out = _CROCKFORD[ms & 31] + out
+        ms >>= 5
+    for _ in range(16):
+        out += _CROCKFORD[secrets.randbelow(32)]
+    return out
+
+
+def make_password(length: int, symbols: bool, digits: bool, upper: bool, ambiguous: bool) -> str:
+    pools = [string.ascii_lowercase]
+    if upper:
+        pools.append(string.ascii_uppercase)
+    if digits:
+        pools.append(string.digits)
+    if symbols:
+        pools.append("!@#$%^&*()-_=+[]{};:,.?")
+    if not ambiguous:
+        pools = ["".join(ch for ch in p if ch not in "0O1lI|") for p in pools]
+    if length < len(pools):
+        raise DktError("Password length must be at least %d for these options." % len(pools))
+    chars = [secrets.choice(p) for p in pools]  # guarantee one of each class
+    allchars = "".join(pools)
+    chars += [secrets.choice(allchars) for _ in range(length - len(chars))]
+    secrets.SystemRandom().shuffle(chars)
+    return "".join(chars)
+
+
+def slugify(text: str, sep: str = "-") -> str:
+    text = unicodedata.normalize("NFKD", text).encode("ascii", "ignore").decode("ascii")
+    text = re.sub(r"[^a-zA-Z0-9]+", sep, text.lower()).strip(sep)
+    return text
+
+
+def lorem(paragraphs: int, words: int) -> str:
+    def sentence() -> str:
+        n = 6 + secrets.randbelow(10)
+        s = " ".join(secrets.choice(_LOREM) for _ in range(n))
+        return s.capitalize() + "."
+    if words:
+        out = [secrets.choice(_LOREM) for _ in range(words)]
+        return (" ".join(out)).capitalize() + "."
+    paras = []
+    for i in range(paragraphs):
+        sents = [sentence() for _ in range(3 + secrets.randbelow(4))]
+        if i == 0:
+            sents[0] = "Lorem ipsum dolor sit amet, consectetur adipiscing elit."
+        paras.append(" ".join(sents))
+    return "\n\n".join(paras)
+
+
+def run(args) -> int:
+    kind = args.kind
+    if not kind:
+        raise DktError("Pick what to generate: uuid, ulid, password, token, id, lorem, slug. See 'dkt gen --help'.")
+    lines = []
+    if kind == "uuid":
+        for _ in range(args.n):
+            lines.append(uuid7() if args.v7 else str(uuid.uuid4()))
+        if args.upper:
+            lines = [x.upper() for x in lines]
+        if args.no_dashes:
+            lines = [x.replace("-", "") for x in lines]
+    elif kind == "ulid":
+        lines = [ulid() for _ in range(args.n)]
+    elif kind == "password":
+        for _ in range(args.n):
+            lines.append(make_password(args.length, not args.no_symbols, not args.no_digits,
+                                       not args.no_upper, args.ambiguous))
+        pool = 26 + (26 if not args.no_upper else 0) + (10 if not args.no_digits else 0) + \
+            (23 if not args.no_symbols else 0)
+        bits = args.length * math.log2(pool)
+        info(c("~%d bits of entropy" % bits, "gray"))
+    elif kind == "token":
+        for _ in range(args.n):
+            if args.format == "hex":
+                lines.append(secrets.token_hex(args.bytes))
+            elif args.format == "b64":
+                lines.append(secrets.token_urlsafe(args.bytes))
+            else:
+                lines.append(str(secrets.randbits(args.bytes * 8)))
+    elif kind == "id":
+        alphabet = args.alphabet or (string.ascii_letters + string.digits)
+        lines = ["".join(secrets.choice(alphabet) for _ in range(args.length)) for _ in range(args.n)]
+    elif kind == "lorem":
+        lines = [lorem(args.paragraphs, args.words)]
+    elif kind == "slug":
+        if not args.text:
+            raise DktError("Give some text to slugify.")
+        lines = [slugify(" ".join(args.text), args.sep)]
+    output_result("\n".join(lines), copy=args.copy)
+    return 0
+
+
+def register(sub, common) -> None:
+    p = sub.add_parser("gen", aliases=["g"], parents=[common],
+                       help=META[3], description="Generate common developer values.",
+                       epilog=EPILOG, formatter_class=argparse.RawDescriptionHelpFormatter)
+    p.set_defaults(func=run, kind=None)
+    g = p.add_subparsers(dest="kind_", metavar="<kind>")
+
+    def add(name, help_, **kw):
+        sp = g.add_parser(name, help=help_)
+        sp.set_defaults(func=run, kind=name)
+        sp.add_argument("--copy", action="store_true", help="copy result to the clipboard")
+        return sp
+
+    sp = add("uuid", "UUID v4 (or v7)")
+    sp.add_argument("-n", type=int, default=1, help="how many")
+    sp.add_argument("--v7", action="store_true", help="time-sortable UUIDv7")
+    sp.add_argument("--upper", action="store_true")
+    sp.add_argument("--no-dashes", action="store_true")
+    sp = add("ulid", "sortable ULID")
+    sp.add_argument("-n", type=int, default=1)
+    sp = add("password", "strong random password")
+    sp.add_argument("-n", type=int, default=1)
+    sp.add_argument("-l", "--length", type=int, default=20)
+    sp.add_argument("--no-symbols", action="store_true")
+    sp.add_argument("--no-digits", action="store_true")
+    sp.add_argument("--no-upper", action="store_true")
+    sp.add_argument("--ambiguous", action="store_true", help="allow look-alike chars (0 O 1 l I)")
+    sp = add("token", "random secret / API key")
+    sp.add_argument("-n", type=int, default=1)
+    sp.add_argument("--bytes", type=int, default=32, help="random bytes (default 32)")
+    sp.add_argument("--format", choices=["hex", "b64", "int"], default="hex")
+    sp = add("id", "short random id")
+    sp.add_argument("-n", type=int, default=1)
+    sp.add_argument("-l", "--length", type=int, default=12)
+    sp.add_argument("--alphabet", help="custom alphabet (default a-zA-Z0-9)")
+    sp = add("lorem", "placeholder text")
+    sp.add_argument("-p", "--paragraphs", type=int, default=1)
+    sp.add_argument("-w", "--words", type=int, default=0, help="exact number of words instead")
+    sp = add("slug", "URL slug from text")
+    sp.add_argument("text", nargs="*")
+    sp.add_argument("--sep", default="-")

devkittools/tools/gx.py

@@ -0,0 +1,184 @@
+"""dkt gx - everyday git shortcuts: pretty log, branch cleanup, undo, wip, sync, who."""
+from __future__ import annotations
+
+import argparse
+
+from ..utils import DktError, color_enabled, c, confirm, git, ok, require_git_repo, resolve_folder, run_capture, table, warn, sym, kv
+
+META = ("Git", "gx", "", "git helpers: log, branches (+prune), undo, wip, sync, who, amend")
+
+EPILOG = """\
+examples:
+  dkt gx log                 compact colored graph
+  dkt gx branches            all local branches: last commit, merged?, ahead/behind
+  dkt gx branches --prune    delete branches already merged into main (asks first)
+  dkt gx undo                undo the last commit but keep your changes
+  dkt gx wip                 stage everything + commit as "wip"
+  dkt gx sync                fetch --prune and show where you stand
+  dkt gx who                 who wrote how much
+  dkt gx amend               add staged changes to the last commit (no message edit)
+"""
+
+
+def _repo(args, need_commits: bool = True):
+    folder = resolve_folder(args.folder)
+    require_git_repo(folder)
+    if need_commits and not git(folder, "rev-parse", "--verify", "--quiet", "HEAD", check=False).strip():
+        raise DktError("This repository has no commits yet.")
+    return folder
+
+
+def cmd_log(args) -> int:
+    folder = _repo(args)
+    fmt = "%C(bold yellow)%h%C(reset) %C(green)%ar%C(reset) %C(bold blue)%an%C(reset) %C(auto)%d%C(reset) %s"
+    import subprocess
+    subprocess.call(["git", "-C", str(folder), "log", "--graph", "--color=always" if color_enabled() else "--color=never", "-n", str(args.n),
+                     "--pretty=format:" + fmt, "--all" if args.all else "--branches=*"], stdin=subprocess.DEVNULL)
+    print()
+    return 0
+
+
+def _default_branch(folder) -> str:
+    for cand in ("main", "master", "develop"):
+        if git(folder, "rev-parse", "--verify", "--quiet", cand, check=False).strip():
+            return cand
+    return git(folder, "rev-parse", "--abbrev-ref", "HEAD").strip()
+
+
+def cmd_branches(args) -> int:
+    folder = _repo(args)
+    base = _default_branch(folder)
+    current = git(folder, "rev-parse", "--abbrev-ref", "HEAD").strip()
+    merged = set(b.strip().lstrip("* ") for b in git(folder, "branch", "--merged", base, "--format=%(refname:short)").splitlines())
+    out = git(folder, "for-each-ref", "refs/heads", "--sort=-committerdate",
+              "--format=%(refname:short)|%(committerdate:relative)|%(authorname)|%(upstream:track)|%(subject)")
+    rows, prunable = [], []
+    for line in out.splitlines():
+        name, when, author, track, subj = (line.split("|", 4) + [""] * 5)[:5]
+        flags = []
+        if name == current:
+            flags.append(c("current", "bgreen"))
+        if name in merged and name != base:
+            flags.append(c("merged", "gray"))
+            if name != current:
+                prunable.append(name)
+        if track:
+            flags.append(c(track.strip("[]"), "byellow"))
+        rows.append((c(name, "bold bcyan") if name == current else name, when, author[:16], " ".join(flags), subj[:44]))
+    table(["BRANCH", "LAST COMMIT", "AUTHOR", "STATE", "SUBJECT"], rows)
+    print(c("\n  base branch: %s" % base, "gray"))
+    if args.prune:
+        prunable = [b for b in prunable if b != base]
+        if not prunable:
+            ok("no merged branches to delete")
+            return 0
+        print("\n  will delete: " + ", ".join(prunable))
+        if confirm("Delete %d merged branches?" % len(prunable)):
+            for b in prunable:
+                git(folder, "branch", "-d", b)
+            ok("deleted %d branches" % len(prunable))
+    elif prunable:
+        print(c("  %d merged branch%s can be pruned: dkt gx branches --prune" % (len(prunable), "" if len(prunable) == 1 else "es"), "gray"))
+    return 0
+
+
+def cmd_undo(args) -> int:
+    folder = _repo(args)
+    last = git(folder, "log", "-1", "--pretty=%h %s").strip()
+    if not last:
+        raise DktError("No commits to undo.")
+    print("  last commit: " + c(last, "bold"))
+    if not git(folder, "rev-parse", "--verify", "--quiet", "HEAD~1", check=False).strip():
+        raise DktError("That is the very first commit - nothing earlier to go back to.")
+    if args.yes or confirm("Undo it (changes stay staged)?", default=True):
+        git(folder, "reset", "--soft", "HEAD~1")
+        ok("commit undone - your changes are still staged")
+    return 0
+
+
+def cmd_wip(args) -> int:
+    folder = _repo(args, need_commits=False)
+    git(folder, "add", "-A")
+    if not git(folder, "diff", "--cached", "--name-only").strip():
+        warn("nothing to commit")
+        return 0
+    git(folder, "commit", "-m", args.message, "--no-verify")
+    ok("committed: %s" % args.message)
+    return 0
+
+
+def cmd_amend(args) -> int:
+    folder = _repo(args)
+    git(folder, "add", "-A") if args.all else None
+    git(folder, "commit", "--amend", "--no-edit")
+    ok("amended last commit")
+    return 0
+
+
+def cmd_sync(args) -> int:
+    folder = _repo(args, need_commits=False)
+    code, _, err = run_capture(["git", "-C", str(folder), "fetch", "--all", "--prune"])
+    if code != 0:
+        raise DktError(err.strip() or "git fetch failed")
+    branch = git(folder, "rev-parse", "--abbrev-ref", "HEAD").strip()
+    up = git(folder, "rev-parse", "--abbrev-ref", "@{u}", check=False).strip()
+    dirty = git(folder, "status", "--porcelain").strip().splitlines()
+    rows = [("branch", c(branch, "bold bcyan")), ("upstream", up or c("none", "yellow"))]
+    if up:
+        ahead, behind = git(folder, "rev-list", "--left-right", "--count", "HEAD...@{u}").split()
+        rows += [("ahead", ahead), ("behind", behind)]
+    rows.append(("working tree", c("clean", "green") if not dirty else c("%d changed file(s)" % len(dirty), "yellow")))
+    kv(rows)
+    if up and int(behind) > 0 and not dirty and args.pull:
+        git(folder, "pull", "--ff-only")
+        ok("fast-forwarded")
+    elif up and int(behind) > 0:
+        print(c("\n  tip: dkt gx sync --pull to fast-forward", "gray"))
+    return 0
+
+
+def cmd_who(args) -> int:
+    folder = _repo(args)
+    out = git(folder, "shortlog", "-sne", "HEAD")
+    rows = []
+    mx = 1
+    parsed = []
+    for line in out.splitlines():
+        n, _, who = line.strip().partition("\t")
+        if n.isdigit():
+            parsed.append((int(n), who))
+    if parsed:
+        mx = parsed[0][0]
+    from ..utils import bar
+    for n, who in parsed[:args.top]:
+        rows.append((str(n), c(bar(n, mx, 14), "bcyan"), who))
+    table(["COMMITS", "", "AUTHOR"], rows)
+    return 0
+
+
+def register(sub, common) -> None:
+    p = sub.add_parser("gx", parents=[common], help=META[3], description="Git quality-of-life shortcuts.",
+                       epilog=EPILOG, formatter_class=argparse.RawDescriptionHelpFormatter)
+    p.set_defaults(func=lambda a: (p.print_help() or 0))
+    g = p.add_subparsers(dest="sub", metavar="<action>")
+
+    def add(name, fn, help_):
+        sp = g.add_parser(name, help=help_)
+        sp.add_argument("-f", "--folder", metavar="PATH")
+        sp.set_defaults(func=fn)
+        return sp
+    sp = add("log", cmd_log, "compact colored commit graph")
+    sp.add_argument("-n", type=int, default=25)
+    sp.add_argument("--all", action="store_true", help="include remotes and tags")
+    sp = add("branches", cmd_branches, "branch overview, optional prune")
+    sp.add_argument("--prune", action="store_true", help="delete merged local branches")
+    sp = add("undo", cmd_undo, "undo last commit, keep changes")
+    sp.add_argument("-y", "--yes", action="store_true")
+    sp = add("wip", cmd_wip, "stage all and commit as WIP")
+    sp.add_argument("-m", "--message", default="wip")
+    sp = add("amend", cmd_amend, "amend the last commit without editing its message")
+    sp.add_argument("-a", "--all", action="store_true", help="stage everything first")
+    sp = add("sync", cmd_sync, "fetch + prune and show ahead/behind")
+    sp.add_argument("--pull", action="store_true", help="fast-forward if behind and clean")
+    sp = add("who", cmd_who, "commits per author")
+    sp.add_argument("--top", type=int, default=10)

devkittools/tools/hashtool.py

@@ -0,0 +1,93 @@
+"""dkt hash (h) - hash text or files, and verify checksums."""
+from __future__ import annotations
+
+import argparse
+import hashlib
+import hmac
+from pathlib import Path
+
+from ..utils import DktError, c, human_size, info, read_input, ok, fail, sym
+
+META = ("Generate & Convert", "hash", "h", "hash text/files, verify checksums, HMAC")
+
+ALGOS = ["md5", "sha1", "sha256", "sha512", "sha3_256", "blake2b"]
+LEN_TO_ALGO = {32: "md5", 40: "sha1", 64: "sha256", 128: "sha512"}
+
+EPILOG = """\
+examples:
+  dkt hash "hello world"                  sha256 of text
+  dkt hash -f setup.exe -a md5 sha256     several algorithms for one file
+  dkt hash -f big.iso --verify 3a7bd3e2...   algorithm auto-detected from length
+  dkt hash "msg" --hmac secretkey         HMAC-SHA256
+  echo -n hi | dkt hash -a all
+"""
+
+
+def hash_file(path: Path, algos):
+    hs = {a: hashlib.new(a) for a in algos}
+    with open(str(path), "rb") as f:
+        for chunk in iter(lambda: f.read(1 << 20), b""):
+            for h in hs.values():
+                h.update(chunk)
+    return {a: h.hexdigest() for a, h in hs.items()}
+
+
+def run(args) -> int:
+    algos = ALGOS if "all" in args.algo else args.algo
+    if args.verify:
+        want = args.verify.strip().lower()
+        if len(algos) != 1 or args.algo == ["sha256"] and len(want) in LEN_TO_ALGO:
+            if len(want) in LEN_TO_ALGO:
+                algos = [LEN_TO_ALGO[len(want)]]
+    results = []  # (label, {algo: digest})
+    if args.hmac:
+        if args.file:
+            raise DktError("--hmac works on text, not files.")
+        data = read_input(args.text, None, args.paste, "text").encode("utf-8")
+        a = algos[0]
+        results.append(("text", {"hmac-" + a: hmac.new(args.hmac.encode(), data, a).hexdigest()}))
+    elif args.file:
+        for f in args.file:
+            p = Path(f).expanduser()
+            if not p.is_file():
+                raise DktError("File not found: %s" % p)
+            label = "%s (%s)" % (p.name, human_size(p.stat().st_size))
+            results.append((label, hash_file(p, algos)))
+    else:
+        data = read_input(args.text, None, args.paste, "text").encode("utf-8")
+        d = {}
+        for a in algos:
+            h = hashlib.new(a)
+            h.update(data)
+            d[a] = h.hexdigest()
+        results.append(("text", d))
+
+    multi = len(results) > 1 or sum(len(d) for _, d in results) > 1
+    for label, d in results:
+        if multi:
+            info(c(label, "bold"))
+        for a, digest in d.items():
+            print(("%-12s %s" % (a, digest)) if multi else digest)
+    if args.verify:
+        want = args.verify.strip().lower()
+        hit = [a for _, d in results for a, dig in d.items() if dig == want]
+        if hit:
+            ok("checksum matches (%s)" % hit[0])
+            return 0
+        fail("checksum does NOT match")
+        return 1
+    return 0
+
+
+def register(sub, common) -> None:
+    p = sub.add_parser("hash", aliases=["h"], parents=[common], help=META[3],
+                       description="Hash text, stdin or files with common algorithms.",
+                       epilog=EPILOG, formatter_class=argparse.RawDescriptionHelpFormatter)
+    p.add_argument("text", nargs="?", help="text to hash (or pipe stdin)")
+    p.add_argument("-f", "--file", nargs="+", metavar="FILE", help="hash file(s) instead of text")
+    p.add_argument("-a", "--algo", nargs="+", default=["sha256"],
+                   choices=ALGOS + ["all"], help="algorithm(s), default sha256")
+    p.add_argument("--verify", metavar="HASH", help="compare against an expected hash")
+    p.add_argument("--hmac", metavar="KEY", help="compute an HMAC with this key")
+    p.add_argument("--paste", action="store_true", help="read text from the clipboard")
+    p.set_defaults(func=run)