gitmole 0.12.0__tar.gz → 0.13.1__tar.gz

{gitmole-0.12.0 → gitmole-0.13.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gitmole
-Version: 0.12.0
+Version: 0.13.1
 Summary: Offline git repository analysis with a terminal report: hotspots, coupling, ownership, code age, secrets, repo health.
 License: MIT
 Project-URL: Homepage, https://github.com/antvinni/gitmole

{gitmole-0.12.0 → gitmole-0.13.1}/gitmole/__init__.py

@@ -1,3 +1,3 @@
 """gitmole: offline git repository analysis with a terminal report."""
 
-__version__ = "0.12.0"
+__version__ = "0.13.1"

{gitmole-0.12.0 → gitmole-0.13.1}/gitmole/evaluate.py

@@ -20,7 +20,7 @@ import os
 import subprocess
 import sys
 
-from . import backtest, filetypes, identity, load, maat, trend, watch
+from . import backtest, filetypes, identity, load, maat, szz, trend, watch
 
 
 def cutoffs(last_date: str, windows: int, horizon: int) -> list:
@@ -44,6 +44,32 @@ def fixed_between(commits: list, start: str, end: str) -> set:
             for p, _, _ in c["files"] if not filetypes.is_test_path(p)}
 
 
+def induced_between(repo: str, commits: list, start: str, end: str, exclude=None) -> set:
+    """Source files a commit before `start` made buggy, by R-SZZ over the fixes landing on or after
+    `start` and before `end`: the outcome is defect insertion the list could have known about, not
+    fix locality. A fix whose bug-inducing commit is inside the horizon is not counted, since no
+    list drawn before `start` could have named it."""
+    out = set()
+    for c in maat.in_window(maat.fix_commits(commits), start, end):
+        found = szz.bug_inducing(repo, c["hash"], exclude)
+        if found and found["date"] < start:
+            out.update(p for p in found["files"] if not filetypes.is_test_path(p))
+    return out
+
+
+def labelled_between(commits: list, labels: dict, start: str, end: str) -> set:
+    """Source files an independently labelled bug-inducing commit touched on or after `start` and
+    before `end` (ApacheJIT, Defectors: see szz.read_labels): the paths the label names, or every
+    source file the commit touched. Either side may be abbreviated."""
+    out = set()
+    for c in maat.in_window(commits, start, end):
+        paths = next((v for k, v in labels.items() if k.startswith(c["hash"]) or c["hash"].startswith(k)), "none")
+        if paths == "none":
+            continue
+        out.update(p for p in (paths if paths is not None else [p for p, _, _ in c["files"]]) if not filetypes.is_test_path(p))
+    return out
+
+
 def report_at(commits: list, t: str, size: dict, meta: dict, generated: list, vendored: list, ignored: set = frozenset()) -> dict:
     """The report watch.risks reads, from the commits before `t` (less the sweeps and the declared, as
     the pipeline leaves them out), scc's listing of the tree at `t`, and that tree's own generated and
@@ -122,10 +148,11 @@ def score(report: dict, fixed: set, top: int) -> dict:
     return out
 
 
-def table(results: list) -> str:
-    """results: [(t, files fixed that were in the pool, pool size, {variant: hits})], oldest first -> Markdown."""
+def table(results: list, noun: str = "fixed") -> str:
+    """results: [(t, files fixed that were in the pool, pool size, {variant: hits})], oldest first -> Markdown.
+    `noun` says what the outcome is: fixed, bug-inducing (R-SZZ) or labelled."""
     names = list(results[0][3]) if results else []
-    head = "| variant | " + " | ".join(f"{t} ({fixed} of {pool} fixed)" for t, fixed, pool, _ in results) + " | total |"
+    head = "| variant | " + " | ".join(f"{t} ({fixed} of {pool} {noun})" for t, fixed, pool, _ in results) + " | total |"
     rule = "|---|" + "---:|" * (len(results) + 1)
     rows = []
     for name in names:
@@ -152,6 +179,8 @@ def main(argv=None) -> int:
     p.add_argument("--windows", type=int, default=6)
     p.add_argument("--horizon", type=int, default=6, metavar="MONTHS")
     p.add_argument("--top", type=int, default=watch.WATCH_TOP)
+    p.add_argument("--szz", action="store_true", help="also score against R-SZZ bug-inducing commits (one git blame per fix and file: minutes)")
+    p.add_argument("--labels", metavar="CSV", help="also score against independent bug-inducing labels (ApacheJIT's CSV, Defectors' file rows, or one hash per line)")
     args = p.parse_args(argv)
     meta = load._read_json(args.out, "meta.json", {})
     log_path = os.path.join(args.out, "log.txt")
@@ -165,7 +194,11 @@ def main(argv=None) -> int:
     from . import run
     declared = maat.read_ignore_revs(run.ignore_revs_files(args.repo))
     ignored = {c["hash"] for c in commits if declared and maat.is_ignored(c["hash"], declared)}
-    results = []
+    labels = szz.read_labels(args.labels) if args.labels else None
+    if args.labels and not labels:
+        print(f"evaluate: no bug-inducing commits read from {args.labels}", file=sys.stderr)
+        return 2
+    results, induced_results, labelled_results = [], [], []
     for t in cutoffs(meta["last_date"], args.windows, args.horizon):
         rev = trend.rev_before(args.repo, t, end_of_day=False)
         if not rev:
@@ -173,9 +206,17 @@ def main(argv=None) -> int:
         size_json, generated, vendored = backtest.snapshot_at(args.repo, rev, args.out)
         size = load.parse_scc(size_json, types)
         report = report_at(commits, t, size, meta, generated, vendored, ignored)
-        fixed = fixed_between(commits, t, months_after(t, args.horizon))
+        end = months_after(t, args.horizon)
+        fixed = fixed_between(commits, t, end)
         pool = set(variants(report)["churn"])
         results.append((t, len(fixed & pool), len(pool), score(report, fixed, args.top)))
+        if args.szz:
+            vendor = tuple(vendored)
+            induced = induced_between(args.repo, commits, t, end, exclude=lambda p: p in generated or filetypes.is_vendored(p, vendor) or filetypes.is_sample_path(p))
+            induced_results.append((t, len(induced & pool), len(pool), score(report, induced, args.top)))
+        if labels:
+            marked = labelled_between(commits, labels, t, end)
+            labelled_results.append((t, len(marked & pool), len(pool), score(report, marked, args.top)))
         print(f"evaluate: {t} done", file=sys.stderr)
     if not results:
         print("evaluate: no cut-off falls inside the history", file=sys.stderr)
@@ -183,6 +224,12 @@ def main(argv=None) -> int:
     spread = ref_spread(args.repo)
     print(f"### {meta.get('name', args.repo)}, top {args.top}, {args.horizon}-month horizon\n")
     print(table(results))
+    if induced_results:
+        print(f"\nAgainst the files a commit before the cut-off made buggy, by R-SZZ over the fixes that followed (the most recent commit each fix's removed lines blame to):\n")
+        print(table(induced_results, noun="bug-inducing"))
+    if labelled_results:
+        print(f"\nAgainst the files the bug-inducing commits labelled in {os.path.basename(args.labels)} touched inside each window:\n")
+        print(table(labelled_results, noun="labelled"))
     print(f"\n`--all` exports {spread['all']:,} commits ({spread['fix_all']:,} fixes); HEAD reaches {spread['head']:,} ({spread['fix_head']:,} fixes).")
     return 0
 

gitmole-0.13.1/gitmole/szz.py

@@ -0,0 +1,135 @@
+"""Bug-inducing commits by R-SZZ, from git alone, for the backtest's second outcome.
+
+The watch list's backtest scores "a fix-labelled commit touched the file in the six months after
+the cut-off": fix locality, which a changelog or a config file scores without ever being wrong.
+The SZZ family gives the other label, defect insertion: the commit that wrote the lines a fix
+removed. Rosa et al. (ICSE 2021, JSS 2023) measured the git-only variants against a
+developer-informed oracle and found R-SZZ, which keeps only the most recent candidate per fix,
+the best of them at precision 0.66 against 0.39 for keeping every candidate. This is that variant:
+
+1. the lines a fix removed or changed, per modified file, from `git diff -U0 fix^ fix`;
+2. `git blame -w -C -C` of the parent at those lines, so whitespace and moved code do not mislead;
+3. files the caller excludes (tests, vendored, generated) are not candidates;
+4. of the commits blamed, the most recent by author date is the bug-inducing one, with the files
+   whose blamed lines it wrote.
+
+An insert-only fix blames nothing and R-SZZ finds nothing for it; that is the known blind spot.
+A development tool behind `python -m gitmole.evaluate --szz`, not a pipeline step: one blame per
+(fix, file) is minutes over a large history, and the report's own backtest stays the cheap one."""
+from __future__ import annotations
+
+import csv
+import datetime as dt
+import re
+import subprocess
+
+from . import filetypes
+
+_HUNK = re.compile(r"^@@ -(\d+)(?:,(\d+))? \+\d+(?:,\d+)? @@")
+_HEADER = re.compile(r"^([0-9a-f]{40,64}) \d+ \d+(?: \d+)?$")
+_HASH = re.compile(r"^[0-9a-f]{7,64}$")
+
+
+def _git(repo: str, *args) -> str:
+    return subprocess.run([*filetypes.GIT, *args], cwd=repo, capture_output=True, check=True).stdout.decode("utf-8", "replace")
+
+
+def deleted_ranges(repo: str, fix: str) -> dict:
+    """{path: [(start, count)]} of the parent-side lines a fix removed or changed, for every file it
+    modified (added and deleted files have no parent version to blame). An empty list is a file
+    that only gained lines."""
+    out, path = {}, None
+    text = _git(repo, "diff", "-U0", "--diff-filter=M", "--no-color", f"{fix}^", fix)
+    for line in text.split("\n"):
+        if line.startswith("diff --git "):
+            path = None
+        elif line.startswith("+++ b/"):
+            path = filetypes.unquote(line[6:])
+            out.setdefault(path, [])
+        elif path is not None and line.startswith("@@"):
+            m = _HUNK.match(line)
+            if not m:
+                continue
+            start, count = int(m.group(1)), int(m.group(2)) if m.group(2) is not None else 1
+            if count:
+                out[path].append((start, count))
+    return out
+
+
+def blame_lines(repo: str, rev: str, path: str, ranges: list) -> dict:
+    """{commit: {"time": author epoch, "lines": n}} for the given parent-side line ranges, blamed
+    with whitespace ignored and moves followed (-w -C -C: AG-SZZ's robustness for free)."""
+    if not ranges:
+        return {}
+    argv = ["blame", "-w", "-C", "-C", "--line-porcelain"]
+    for start, count in ranges:
+        argv += ["-L", f"{start},{start + count - 1}"]
+    try:
+        text = _git(repo, *argv, rev, "--", path)
+    except subprocess.CalledProcessError:
+        return {}
+    out, current = {}, None
+    for line in text.split("\n"):
+        m = _HEADER.match(line)
+        if m:
+            current = out.setdefault(m.group(1), {"time": 0, "lines": 0})
+            current["lines"] += 1
+        elif current is not None and line.startswith("author-time "):
+            current["time"] = int(line[12:])
+    return out
+
+
+def bug_inducing(repo: str, fix: str, exclude=None):
+    """{"commit", "date", "files"} for the R-SZZ pick of a fix: the most recent commit its deleted
+    lines blame to, and the files whose lines it wrote; None when nothing blames (an insert-only
+    fix, or every touched file excluded). `exclude(path)` says which files are not candidates; test
+    files never are."""
+    candidates = {}
+    for path, ranges in deleted_ranges(repo, fix).items():
+        if filetypes.is_test_path(path) or (exclude and exclude(path)):
+            continue
+        for commit, info in blame_lines(repo, f"{fix}^", path, ranges).items():
+            c = candidates.setdefault(commit, {"time": info["time"], "files": set()})
+            c["time"] = max(c["time"], info["time"])
+            c["files"].add(path)
+    if not candidates:
+        return None
+    commit = max(candidates, key=lambda c: (candidates[c]["time"], c))
+    when = dt.datetime.fromtimestamp(candidates[commit]["time"], dt.timezone.utc).date().isoformat()
+    return {"commit": commit, "date": when, "files": sorted(candidates[commit]["files"])}
+
+
+_TRUE = {"true", "1", "yes", "buggy"}
+_COMMIT_COLUMNS = ("commit_id", "commit", "hash", "sha", "bug_commit", "bic")
+_PATH_COLUMNS = ("path", "file", "filepath", "file_path", "filename")
+
+
+def read_labels(path: str) -> dict:
+    """Independent bug-inducing labels: {commit: [paths] or None}. Three shapes: ApacheJIT's CSV
+    (a `commit_id` column and a `buggy` flag; only the buggy rows count), Defectors' file-level
+    rows (a commit column and a path column), or a bare list of hashes, one per line."""
+    out = {}
+    with open(path, encoding="utf-8", errors="replace", newline="") as fh:
+        rows = list(csv.reader(fh))
+    if not rows:
+        return out
+    head = [h.strip().lower() for h in rows[0]]
+    commit_col = next((i for i, h in enumerate(head) if h in _COMMIT_COLUMNS), None)
+    if commit_col is None:
+        for row in rows:
+            if row and _HASH.match(row[0].strip()):
+                out[row[0].strip()] = None
+        return out
+    buggy_col = next((i for i, h in enumerate(head) if h == "buggy"), None)
+    path_col = next((i for i, h in enumerate(head) if h in _PATH_COLUMNS), None)
+    for row in rows[1:]:
+        if len(row) <= commit_col or not row[commit_col].strip():
+            continue
+        if buggy_col is not None and (len(row) <= buggy_col or row[buggy_col].strip().lower() not in _TRUE):
+            continue
+        commit = row[commit_col].strip()
+        if path_col is not None and len(row) > path_col and row[path_col].strip():
+            out[commit] = (out.get(commit) or []) + [row[path_col].strip()]
+        else:
+            out.setdefault(commit, None)
+    return out

{gitmole-0.12.0 → gitmole-0.13.1}/gitmole.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gitmole
-Version: 0.12.0
+Version: 0.13.1
 Summary: Offline git repository analysis with a terminal report: hotspots, coupling, ownership, code age, secrets, repo health.
 License: MIT
 Project-URL: Homepage, https://github.com/antvinni/gitmole

{gitmole-0.12.0 → gitmole-0.13.1}/gitmole.egg-info/SOURCES.txt

@@ -26,6 +26,7 @@ gitmole/loss.py
 gitmole/maat.py
 gitmole/render.py
 gitmole/run.py
+gitmole/szz.py
 gitmole/textfmt.py
 gitmole/trend.py
 gitmole/watch.py
@@ -61,6 +62,7 @@ tests/test_packaging.py
 tests/test_render.py
 tests/test_render_examples.py
 tests/test_run.py
+tests/test_szz.py
 tests/test_textfmt.py
 tests/test_trend.py
 tests/test_watch.py

{gitmole-0.12.0 → gitmole-0.13.1}/tests/test_evaluate.py

@@ -1,6 +1,10 @@
+import os
+import subprocess
+import tempfile
 import unittest
 
-from gitmole import evaluate
+from gitmole import evaluate, maat
+from tests.test_szz import make_repo
 
 
 def commit(date, subject, *files):
@@ -39,6 +43,32 @@ class Outcome(unittest.TestCase):
         self.assertEqual(evaluate.fixed_between(commits, "2025-07-01", "2025-09-01"), {"core/b.py"}, "2,000 lines over the 99th percentile: tangled by size, credits nothing")
 
 
+class Induced(unittest.TestCase):
+    def _log(self, d):
+        text = subprocess.run(["git", "log", "HEAD", "--numstat", "--date=iso-strict", "-M", "--pretty=format:--%h--%ad--%aN--%s"],
+                              cwd=d, capture_output=True, text=True, check=True).stdout
+        return maat.parse_log(text)
+
+    def test_files_a_commit_before_the_cut_off_made_buggy_as_a_fix_inside_the_horizon_shows(self):
+        with tempfile.TemporaryDirectory() as d:
+            make_repo(d)
+            commits = self._log(d)
+            self.assertEqual(evaluate.induced_between(d, commits, "2025-03-15", "2025-09-15"), {"core/f.py"},
+                             "the April fix blames the February commit, which is before the cut-off")
+            self.assertEqual(evaluate.induced_between(d, commits, "2025-01-15", "2025-09-15"), set(),
+                             "the same fix, but the bug was planted after this cut-off: not something the list could have known")
+            self.assertEqual(evaluate.induced_between(d, commits, "2025-04-15", "2025-09-15"), set(), "the May fix only adds lines: R-SZZ finds nothing")
+
+    def test_labelled_commits_inside_the_horizon_name_their_source_files_or_the_paths_given(self):
+        with tempfile.TemporaryDirectory() as d:
+            by = make_repo(d)
+            commits = self._log(d)
+            labels = {by["plant it"][:9]: None, by["change d, add f, touch g"]: ["core/g.py", "docs/x.md"], by["fix: add z"]: None}
+            self.assertEqual(evaluate.labelled_between(commits, labels, "2025-01-15", "2025-02-15"), {"core/f.py"}, "an abbreviated label still matches")
+            self.assertEqual(evaluate.labelled_between(commits, labels, "2025-02-15", "2025-03-15"), {"core/g.py", "docs/x.md"}, "the paths the label names")
+            self.assertEqual(evaluate.labelled_between(commits, labels, "2025-04-15", "2025-06-15"), {"core/g.py"})
+
+
 class Score(unittest.TestCase):
     def test_the_report_at_t_knows_nothing_after_t(self):
         r = evaluate.report_at(COMMITS, "2025-06-01", SIZE, {"bots": []}, [], [])
@@ -103,6 +133,7 @@ class Table(unittest.TestCase):
             "| churn | 1 | 2 | 3 |",
             "| random (expected) | 0.4 | 0.6 | 1.0 |",
         ])
+        self.assertIn("(3 of 40 bug-inducing)", evaluate.table([("2025-02-28", 3, 40, {"churn": 1})], noun="bug-inducing"))
 
 
 if __name__ == "__main__":

gitmole-0.13.1/tests/test_szz.py

@@ -0,0 +1,99 @@
+import os
+import subprocess
+import tempfile
+import unittest
+
+from gitmole import szz
+
+
+def make_repo(d):
+    """A file with a bug planted in February, an unrelated edit in March, the fix in April; a test
+    file the fix also touches; and an insert-only fix in May."""
+    def git(*args, date):
+        env = dict(os.environ, GIT_CONFIG_GLOBAL="/dev/null", GIT_CONFIG_SYSTEM="/dev/null", GIT_AUTHOR_NAME="Ann", GIT_AUTHOR_EMAIL="a@x",
+                   GIT_COMMITTER_NAME="Ann", GIT_COMMITTER_EMAIL="a@x", GIT_AUTHOR_DATE=f"{date}T00:00:00", GIT_COMMITTER_DATE=f"{date}T00:00:00")
+        subprocess.run(["git", *args], cwd=d, check=True, capture_output=True, env=env)
+
+    def write(path, text):
+        os.makedirs(os.path.dirname(os.path.join(d, path)) or d, exist_ok=True)
+        with open(os.path.join(d, path), "w") as fh:
+            fh.write(text)
+    git("init", "-q", "-b", "main", date="2025-01-01")
+    write("core/f.py", "a\nb\nc\nd\ne\n")
+    write("core/g.py", "x\ny\n")
+    write("tests/test_f.py", "t\n")
+    git("add", "-A", date="2025-01-01")
+    git("commit", "-q", "-m", "one", date="2025-01-01")
+    write("core/f.py", "a\nB\nc\nd\ne\n")
+    git("commit", "-q", "-am", "plant it", date="2025-02-01")
+    write("core/f.py", "a\nB\nc\nD\ne\nf\n")
+    write("core/g.py", "x\nY\n")
+    git("commit", "-q", "-am", "change d, add f, touch g", date="2025-03-01")
+    write("core/f.py", "a\nb\nc\nD\ne\nf\n")
+    write("tests/test_f.py", "t\nu\n")
+    git("commit", "-q", "-am", "fix: b", date="2025-04-01")
+    write("core/g.py", "x\nY\nz\n")
+    git("commit", "-q", "-am", "fix: add z", date="2025-05-01")
+    return {line.split(" ", 1)[1]: line.split(" ", 1)[0] for line in
+            subprocess.run(["git", "log", "--format=%H %s", "HEAD"], cwd=d, capture_output=True, text=True, check=True).stdout.splitlines()
+            if " " in line}
+
+
+class DeletedRanges(unittest.TestCase):
+    def test_the_parent_side_lines_a_fix_removed_or_changed_per_modified_file(self):
+        with tempfile.TemporaryDirectory() as d:
+            by = make_repo(d)
+            self.assertEqual(szz.deleted_ranges(d, by["fix: b"]), {"core/f.py": [(2, 1)], "tests/test_f.py": []},
+                             "line 2 of the parent's f.py was changed; the test file only gained a line")
+            self.assertEqual(szz.deleted_ranges(d, by["plant it"]), {"core/f.py": [(2, 1)]})
+            self.assertEqual(szz.deleted_ranges(d, by["change d, add f, touch g"]), {"core/f.py": [(4, 1)], "core/g.py": [(2, 1)]}, "an added line has no parent side")
+
+
+class BugInducing(unittest.TestCase):
+    def test_the_most_recent_commit_blamed_for_a_fixs_deleted_lines_with_its_files(self):
+        with tempfile.TemporaryDirectory() as d:
+            by = make_repo(d)
+            found = szz.bug_inducing(d, by["fix: b"])
+            self.assertEqual(found, {"commit": by["plant it"], "date": "2025-02-01", "files": ["core/f.py"]},
+                             "the fix removed line 2, which the February commit wrote; the March commit is not blamed")
+            self.assertIsNone(szz.bug_inducing(d, by["fix: add z"]), "an insert-only fix blames nothing: R-SZZ finds nothing for it")
+
+    def test_files_the_caller_excludes_are_not_candidates(self):
+        with tempfile.TemporaryDirectory() as d:
+            by = make_repo(d)
+            self.assertIsNone(szz.bug_inducing(d, by["fix: b"], exclude=lambda p: p.startswith("core/")))
+
+    def test_the_most_recent_of_several_candidates_wins(self):
+        # R-SZZ: of the commits a fix's deleted lines blame to, only the latest is kept; Rosa et al. measured
+        # that rule at precision 0.66 against 0.39 for keeping them all
+        with tempfile.TemporaryDirectory() as d:
+            by = make_repo(d)
+            def git(*args, date):
+                env = dict(os.environ, GIT_CONFIG_GLOBAL="/dev/null", GIT_CONFIG_SYSTEM="/dev/null", GIT_AUTHOR_NAME="Ann", GIT_AUTHOR_EMAIL="a@x",
+                           GIT_COMMITTER_NAME="Ann", GIT_COMMITTER_EMAIL="a@x", GIT_AUTHOR_DATE=f"{date}T00:00:00", GIT_COMMITTER_DATE=f"{date}T00:00:00")
+                subprocess.run(["git", *args], cwd=d, check=True, capture_output=True, env=env)
+            with open(os.path.join(d, "core/f.py"), "w") as fh:
+                fh.write("a\nb\nc\nd\ne\nF\n")   # rewrites line 4 (March's D) and line 6 (March's f) and line 1 (January's a)... only b and F
+            git("commit", "-q", "-am", "fix: d and f", date="2025-06-01")
+            fix = subprocess.run(["git", "rev-parse", "HEAD"], cwd=d, capture_output=True, text=True).stdout.strip()
+            found = szz.bug_inducing(d, fix)
+            self.assertEqual((found["commit"], found["date"], found["files"]), (by["change d, add f, touch g"], "2025-03-01", ["core/f.py"]))
+
+
+class Labels(unittest.TestCase):
+    def test_a_csv_of_buggy_commits_with_or_without_paths(self):
+        with tempfile.TemporaryDirectory() as d:
+            path = os.path.join(d, "labels.csv")
+            with open(path, "w") as fh:
+                fh.write("commit_id,project,buggy\nabc1234,x,True\ndef5678,x,False\n0123abc,x,1\n")
+            self.assertEqual(szz.read_labels(path), {"abc1234": None, "0123abc": None}, "ApacheJIT's shape: a buggy flag per commit")
+            with open(path, "w") as fh:
+                fh.write("commit,path\nabc1234,src/a.py\nabc1234,src/b.py\n")
+            self.assertEqual(szz.read_labels(path), {"abc1234": ["src/a.py", "src/b.py"]}, "Defectors' shape: the files a buggy commit made buggy")
+            with open(path, "w") as fh:
+                fh.write("abc1234\n0123abc\n")
+            self.assertEqual(szz.read_labels(path), {"abc1234": None, "0123abc": None}, "a bare list of hashes")
+
+
+if __name__ == "__main__":
+    unittest.main()