mlmm-toolkit 0.2.7__tar.gz → 0.3.0__tar.gz

mlmm_toolkit-0.3.0/.github/scripts/check_all_scan_contract.py

@@ -0,0 +1,133 @@
+#!/usr/bin/env python3
+"""Verify that options forwarded from `mlmm all` to `mlmm scan` exist on scan CLI."""
+
+from __future__ import annotations
+
+import ast
+from pathlib import Path
+from typing import Set
+
+
+REPO_ROOT = Path(__file__).resolve().parents[2]
+ALL_PY = REPO_ROOT / "mlmm" / "workflows" / "all.py"
+SCAN_PY = REPO_ROOT / "mlmm" / "workflows" / "scan.py"
+# Shared option decorators (e.g. ``add_ml_layer_detection_options``) inject
+# Click flags onto ``scan.cli`` from here, so they count as declared too.
+COMMON_OPTIONS_PY = REPO_ROOT / "mlmm" / "cli" / "common_options.py"
+
+
+def _is_click_option_call(node: ast.Call) -> bool:
+    func = node.func
+    return (
+        isinstance(func, ast.Attribute)
+        and func.attr == "option"
+        and isinstance(func.value, ast.Name)
+        and func.value.id == "click"
+    )
+
+
+def _const_flag(node: ast.AST) -> str | None:
+    if isinstance(node, ast.Constant) and isinstance(node.value, str):
+        value = node.value.strip()
+        if value.startswith("--"):
+            return value
+    return None
+
+
+def _expand_flag_spec(spec: str) -> Set[str]:
+    # click toggle declarations may appear as "--a/--b".
+    parts = [p.strip() for p in spec.split("/") if p.strip()]
+    flags = {p for p in parts if p.startswith("--")}
+    if flags:
+        return flags
+    return {spec}
+
+
+def _collect_scan_declared_flags(scan_tree: ast.AST) -> Set[str]:
+    flags: Set[str] = set()
+    for node in ast.walk(scan_tree):
+        if not isinstance(node, ast.Call) or not _is_click_option_call(node):
+            continue
+        for arg in node.args:
+            flag = _const_flag(arg)
+            if flag is not None:
+                flags.update(_expand_flag_spec(flag))
+    return flags
+
+
+class _ForwardedScanFlags(ast.NodeVisitor):
+    def __init__(self) -> None:
+        self.in_cli = False
+        self.flags: Set[str] = set()
+
+    def visit_FunctionDef(self, node: ast.FunctionDef) -> None:
+        was_in_cli = self.in_cli
+        if node.name == "cli":
+            self.in_cli = True
+        self.generic_visit(node)
+        self.in_cli = was_in_cli
+
+    def visit_Assign(self, node: ast.Assign) -> None:
+        if self.in_cli:
+            for target in node.targets:
+                if isinstance(target, ast.Name) and target.id == "scan_args":
+                    if isinstance(node.value, ast.List):
+                        for elt in node.value.elts:
+                            flag = _const_flag(elt)
+                            if flag is not None:
+                                self.flags.add(flag)
+        self.generic_visit(node)
+
+    def visit_Call(self, node: ast.Call) -> None:
+        if self.in_cli:
+            if isinstance(node.func, ast.Name) and node.func.id == "_append_cli_arg":
+                if len(node.args) >= 2 and isinstance(node.args[0], ast.Name) and node.args[0].id == "scan_args":
+                    flag = _const_flag(node.args[1])
+                    if flag is not None:
+                        self.flags.add(flag)
+
+            if isinstance(node.func, ast.Attribute) and node.func.attr == "append":
+                if isinstance(node.func.value, ast.Name) and node.func.value.id == "scan_args" and node.args:
+                    value = node.args[0]
+                    flag = _const_flag(value)
+                    if flag is not None:
+                        self.flags.add(flag)
+                    elif isinstance(value, ast.IfExp):
+                        body_flag = _const_flag(value.body)
+                        else_flag = _const_flag(value.orelse)
+                        if body_flag is not None:
+                            self.flags.add(body_flag)
+                        if else_flag is not None:
+                            self.flags.add(else_flag)
+        self.generic_visit(node)
+
+
+def main() -> int:
+    all_tree = ast.parse(ALL_PY.read_text(encoding="utf-8"), filename=str(ALL_PY))
+    scan_tree = ast.parse(SCAN_PY.read_text(encoding="utf-8"), filename=str(SCAN_PY))
+
+    declared = _collect_scan_declared_flags(scan_tree)
+    # scan.cli also pulls in flags from shared option decorators defined in
+    # mlmm/cli/common_options.py (--detect-layer, --precision, ...).
+    if COMMON_OPTIONS_PY.exists():
+        common_tree = ast.parse(
+            COMMON_OPTIONS_PY.read_text(encoding="utf-8"), filename=str(COMMON_OPTIONS_PY)
+        )
+        declared |= _collect_scan_declared_flags(common_tree)
+    collector = _ForwardedScanFlags()
+    collector.visit(all_tree)
+    forwarded = collector.flags
+
+    missing = sorted(flag for flag in forwarded if flag not in declared)
+    if missing:
+        print("Detected all->scan option contract drift.")
+        for flag in missing:
+            print(f"  missing in scan CLI: {flag}")
+        return 1
+
+    print(f"[scan-contract] all forwards {len(forwarded)} scan options; all are declared.")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

mlmm_toolkit-0.3.0/.github/scripts/check_engineering_markers.py

@@ -0,0 +1,89 @@
+#!/usr/bin/env python3
+"""Engineering-marker coverage check.
+
+Three static gates ported from the retired ``tests/test_fingerprint.py``:
+
+* ``# CHEMISTRY-RULE:N`` coverage — every rule this repo is responsible for
+  must be annotated somewhere in the package source.
+* ``# DOMAIN_PURE`` coverage — the modules that must stay backend-agnostic
+  carry this marker.
+* External-library import scope — MLIP-only SDKs (``fairchem`` / ``orb_models``
+  / ``mace`` / ``aimnet``) may only be imported under ``backends/`` so the
+  rest of the package keeps a stable, lightweight import graph.
+
+Run from the repository root::
+
+    python .github/scripts/check_engineering_markers.py
+
+Exit code 0 = all gates pass, 1 = at least one violation (printed to stderr).
+"""
+from __future__ import annotations
+
+import re
+import sys
+from pathlib import Path
+
+PKG = "mlmm"
+
+REQUIRED_CHEMISTRY_RULES: set[int] = {1, 2, 3, 4, 5, 6, 7, 8, 9}
+
+REQUIRED_DOMAIN_PURE: tuple[str, ...] = (
+    "mlmm/backends/mlmm_calc.py",
+    "mlmm/workflows/tsopt.py",
+    "mlmm/workflows/freq.py",
+)
+
+EXTERNAL_LIBS_DENY: set[str] = {"fairchem", "orb_models", "mace", "aimnet"}
+
+REPO_ROOT = Path(__file__).resolve().parents[2]
+PKG_ROOT = REPO_ROOT / PKG
+
+
+def _check_chemistry_rules() -> list[str]:
+    found: set[int] = set()
+    for py in PKG_ROOT.rglob("*.py"):
+        for m in re.finditer(r"CHEMISTRY-RULE:(\d+)", py.read_text(errors="ignore")):
+            found.add(int(m.group(1)))
+    missing = sorted(REQUIRED_CHEMISTRY_RULES - found)
+    return [f"missing CHEMISTRY-RULE markers in {PKG}: {missing}"] if missing else []
+
+
+def _check_domain_pure() -> list[str]:
+    missing = [
+        rel for rel in REQUIRED_DOMAIN_PURE
+        if "# DOMAIN_PURE" not in (REPO_ROOT / rel).read_text(errors="ignore")
+    ]
+    return [f"missing # DOMAIN_PURE marker in: {missing}"] if missing else []
+
+
+def _check_external_library_scope() -> list[str]:
+    backends_dir = PKG_ROOT / "backends"
+    violations: list[str] = []
+    for py in PKG_ROOT.rglob("*.py"):
+        if backends_dir in py.parents or py == backends_dir:
+            continue
+        text = py.read_text(errors="ignore")
+        for mod in EXTERNAL_LIBS_DENY:
+            if re.search(
+                rf"^(?:import\s+{re.escape(mod)}\b|from\s+{re.escape(mod)})",
+                text, re.M,
+            ):
+                violations.append(f"{py.relative_to(REPO_ROOT)}: imports {mod}")
+    return ["external library import outside backends/:", *violations] if violations else []
+
+
+def main() -> int:
+    failures: list[str] = []
+    failures += _check_chemistry_rules()
+    failures += _check_domain_pure()
+    failures += _check_external_library_scope()
+    if failures:
+        for line in failures:
+            print(line, file=sys.stderr)
+        return 1
+    print("engineering markers OK")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

mlmm_toolkit-0.3.0/.github/scripts/check_help_registry.py

@@ -0,0 +1,98 @@
+#!/usr/bin/env python3
+"""Static drift check for the primary `--help` option registry.
+
+Validates ``mlmm.cli.app._SUBCOMMAND_PRIMARY_HELP_OPTIONS`` against the actual
+Click commands that back each subcommand:
+
+* Every entry must include ``"--help-advanced"`` so the discoverability flag
+  itself is not hidden when the registry filters non-primary options.
+* Every other token in each frozenset must correspond to an actual
+  ``@click.option`` opt string on the resolved Click command — long opts via
+  ``Option.opts`` and short opts via ``Option.opts`` / ``Option.secondary_opts``.
+  Orphan entries (dead aliases / removed flags) fail this check.
+
+Run from the repository root::
+
+    python .github/scripts/check_help_registry.py
+
+Exit 0 = registry consistent, 1 = drift (printed to stderr).
+"""
+from __future__ import annotations
+
+import importlib
+import sys
+from pathlib import Path
+
+REPO_ROOT = Path(__file__).resolve().parents[2]
+sys.path.insert(0, str(REPO_ROOT))
+
+# ``--help-advanced`` is injected by ``cli.help_pages._ensure_help_advanced_option``
+# so it is NOT declared on the lazy Click commands themselves. Treat it as the
+# single allow-listed token that need not resolve to a ``command.params`` opt.
+_INJECTED_OPTS: frozenset[str] = frozenset({"--help-advanced"})
+
+from mlmm.cli.app import (  # noqa: E402
+    _LAZY_SUBCOMMANDS,
+    _SUBCOMMAND_PRIMARY_HELP_OPTIONS,
+)
+
+
+def _resolve_command(spec: tuple[str, str, str]):
+    module_name, attr, _help = spec
+    mod = importlib.import_module(module_name)
+    return getattr(mod, attr)
+
+
+def _declared_opts(command) -> set[str]:
+    opts: set[str] = set()
+    for param in getattr(command, "params", ()):  # click.Option / click.Argument
+        opts.update(getattr(param, "opts", ()) or ())
+        opts.update(getattr(param, "secondary_opts", ()) or ())
+    return opts
+
+
+def main() -> int:
+    errors: list[str] = []
+
+    for subcmd, primary in _SUBCOMMAND_PRIMARY_HELP_OPTIONS.items():
+        if "--help-advanced" not in primary:
+            errors.append(
+                f"[{subcmd}] missing '--help-advanced' in primary set "
+                f"(would self-hide the discoverability flag)"
+            )
+
+        spec = _LAZY_SUBCOMMANDS.get(subcmd)
+        if spec is None:
+            errors.append(
+                f"[{subcmd}] registry entry has no corresponding "
+                f"_LAZY_SUBCOMMANDS spec"
+            )
+            continue
+
+        try:
+            command = _resolve_command(spec)
+        except Exception as exc:  # pragma: no cover - import failure surfaces here
+            errors.append(f"[{subcmd}] could not import {spec[0]}.{spec[1]}: {exc}")
+            continue
+
+        declared = _declared_opts(command)
+        for token in sorted(primary - _INJECTED_OPTS):
+            if token not in declared:
+                errors.append(
+                    f"[{subcmd}] primary token {token!r} is not declared by "
+                    f"any @click.option on {spec[0]}.{spec[1]} "
+                    f"(orphan / dead registry entry)"
+                )
+
+    if errors:
+        print("help registry drift detected:", file=sys.stderr)
+        for line in errors:
+            print(f"  - {line}", file=sys.stderr)
+        return 1
+
+    print("help registry OK")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

mlmm_toolkit-0.3.0/.github/scripts/check_intro_template.py

@@ -0,0 +1,118 @@
+#!/usr/bin/env python3
+"""Validate the command-page heading template (EN/JA).
+
+EN canonical template: a one-paragraph intro (the "when to use" guidance is
+folded into the opening sentence — no separate heading), then ``## Examples``
+before the ``## Workflow`` body, and none of the legacy ``When to use`` /
+``Quick examples`` / ``Inputs`` headings.
+
+JA pages follow the same canonical template (## 実行例 before ## 処理の流れ,
+with the legacy 使いどころ / 入力 headings removed).
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+
+REPO_ROOT = Path(__file__).resolve().parents[2]
+DOCS_ROOT = REPO_ROOT / "docs"
+
+TARGETS = (
+    "all",
+    "scan",
+    "scan2d",
+    "scan3d",
+    "tsopt",
+    "freq",
+    "opt",
+    "path-opt",
+    "path-search",
+    "irc",
+    "dft",
+)
+
+# EN canonical template.
+EN_REQUIRED = ("## Examples",)
+EN_BODY = "## Workflow"
+EN_FORBIDDEN = (
+    "## When to use",
+    "## Quick examples",
+    "## Common examples",
+    "## Minimal example",
+    "## Usage",
+    "## Inputs",
+)
+
+# JA canonical template (mirrors the EN template).
+JA_REQUIRED = ("## 実行例",)
+JA_BODY = "## 処理の流れ"
+JA_FORBIDDEN = (
+    "## 使いどころ",
+    "## クイック例",
+    "## 使用例",
+    "## 例",
+    "## 最小例",
+    "## 入力",
+)
+
+
+def _heading_positions(path: Path) -> dict[str, int]:
+    positions: dict[str, int] = {}
+    for i, line in enumerate(path.read_text(encoding="utf-8").splitlines(), start=1):
+        if line.startswith("## "):
+            positions.setdefault(line.strip(), i)
+    return positions
+
+
+def _check(
+    path: Path,
+    required: tuple[str, ...],
+    body_heading: str,
+    forbidden: tuple[str, ...],
+    errors: list[str],
+) -> None:
+    if not path.exists():
+        errors.append(f"{path}: missing file")
+        return
+
+    positions = _heading_positions(path)
+
+    missing = [h for h in required if h not in positions]
+    if missing:
+        errors.append(f"{path}: missing headings: {', '.join(missing)}")
+
+    present_forbidden = [h for h in forbidden if h in positions]
+    if present_forbidden:
+        errors.append(
+            f"{path}: legacy headings must be removed: {', '.join(present_forbidden)}"
+        )
+
+    body_line = positions.get(body_heading)
+    if body_line is not None:
+        late = [h for h in required if h in positions and positions[h] > body_line]
+        if late:
+            errors.append(
+                f"{path}: heading(s) must precede '{body_heading}': {', '.join(late)}"
+            )
+
+
+def main() -> int:
+    errors: list[str] = []
+
+    for name in TARGETS:
+        _check(DOCS_ROOT / f"{name}.md", EN_REQUIRED, EN_BODY, EN_FORBIDDEN, errors)
+        _check(DOCS_ROOT / "ja" / f"{name}.md", JA_REQUIRED, JA_BODY, JA_FORBIDDEN, errors)
+
+    if errors:
+        print("[intro-check] failed:")
+        for e in errors:
+            print(f"- {e}")
+        return 1
+
+    print(f"[intro-check] validated {len(TARGETS) * 2} pages.")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

mlmm_toolkit-0.3.0/.github/scripts/check_markdown_links.py

@@ -0,0 +1,122 @@
+#!/usr/bin/env python3
+"""Validate local markdown links under docs/."""
+
+from __future__ import annotations
+
+import re
+from pathlib import Path
+
+
+REPO_ROOT = Path(__file__).resolve().parents[2]
+DOCS_ROOT = REPO_ROOT / "docs"
+LINK_RE = re.compile(r"(?<!\!)\[[^\]]+\]\(([^)]+)\)")
+EXTERNAL_PREFIXES = ("http://", "https://", "mailto:", "tel:")
+
+
+def _normalize_target(raw: str) -> str:
+    target = raw.strip()
+    if target.startswith("<") and target.endswith(">"):
+        target = target[1:-1].strip()
+    if " " in target:
+        target = target.split(" ", 1)[0]
+    return target
+
+
+def _iter_links(path: Path) -> list[tuple[int, str]]:
+    links: list[tuple[int, str]] = []
+    in_fence = False
+    for lineno, line in enumerate(path.read_text(encoding="utf-8").splitlines(), start=1):
+        stripped = line.strip()
+        if stripped.startswith("```"):
+            in_fence = not in_fence
+            continue
+        if in_fence:
+            continue
+        for match in LINK_RE.finditer(line):
+            links.append((lineno, _normalize_target(match.group(1))))
+    return links
+
+
+def _iter_toctree_targets(path: Path) -> list[tuple[int, str]]:
+    targets: list[tuple[int, str]] = []
+    in_toctree = False
+    for lineno, line in enumerate(path.read_text(encoding="utf-8").splitlines(), start=1):
+        stripped = line.strip()
+        if stripped.startswith("```"):
+            marker = stripped[3:].strip().lower()
+            if not in_toctree and marker.startswith("{toctree}"):
+                in_toctree = True
+                continue
+            if in_toctree:
+                in_toctree = False
+            continue
+        if not in_toctree:
+            continue
+        if not stripped or stripped.startswith(":"):
+            continue
+        # Handle MyST toctree "Title <target>" syntax
+        angle = re.match(r".*<([^>]+)>\s*$", stripped)
+        if angle:
+            targets.append((lineno, angle.group(1).strip()))
+        else:
+            targets.append((lineno, stripped.split()[0]))
+    return targets
+
+
+def _resolve_doc_target(path: Path, target: str) -> Path | None:
+    if not target or target.startswith(EXTERNAL_PREFIXES) or target.startswith("#"):
+        return None
+    if "*" in target:
+        return None
+    base = (path.parent / target).resolve()
+    if base.suffix:
+        return base
+    for candidate in (base.with_suffix(".md"), base.with_suffix(".rst"), base):
+        if candidate.exists():
+            return candidate
+    return base.with_suffix(".md")
+
+
+def _check_path(path: Path, errors: list[str]) -> None:
+    for lineno, target in _iter_links(path):
+        if not target or target.startswith(EXTERNAL_PREFIXES):
+            continue
+        if target.startswith("#"):
+            continue
+        target_path = target.split("#", 1)[0]
+        if not target_path:
+            continue
+        resolved = (path.parent / target_path).resolve()
+        if not resolved.exists():
+            errors.append(
+                f"{path.relative_to(REPO_ROOT)}:{lineno}: broken local link -> {target}"
+            )
+
+    for lineno, target in _iter_toctree_targets(path):
+        resolved = _resolve_doc_target(path, target)
+        if resolved is None:
+            continue
+        if not resolved.exists():
+            errors.append(
+                f"{path.relative_to(REPO_ROOT)}:{lineno}: broken toctree target -> {target}"
+            )
+
+
+def main() -> int:
+    errors: list[str] = []
+    pages = sorted(DOCS_ROOT.rglob("*.md"))
+    for md in pages:
+        _check_path(md, errors)
+
+    if errors:
+        print("[link-check] failed:")
+        for e in errors:
+            print(f"- {e}")
+        return 1
+
+    print(f"[link-check] validated local links in {len(pages)} pages.")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

mlmm_toolkit-0.3.0/.github/scripts/check_skill_commands.py

@@ -0,0 +1,140 @@
+#!/usr/bin/env python3
+"""Audit fenced ``bash`` blocks in skills/**/*.md.
+
+For every line that starts with ``mlmm <subcommand>``, parse out flag
+tokens (``--foo`` and ``-f``) and verify each one is registered on that
+subcommand via Click introspection. Stale flags from past edits are
+reported with file:line.
+
+This is intentionally conservative:
+* shell line continuations (\\) are joined.
+* placeholders / templates (``<arg>``, ``{xyz,pdb,gjf}``) are skipped.
+* values for known boolean flags (``--tsopt true``, ``--no-tsopt``) are
+  accepted as flag-only.
+* free-form prose example fragments inside backticks (single-line
+  ``mlmm extract --foo``) are also checked.
+
+Exits non-zero on any unknown flag.
+"""
+
+from __future__ import annotations
+
+import re
+import shlex
+import sys
+from pathlib import Path
+
+import click
+
+REPO_ROOT = Path(__file__).resolve().parents[2]
+SKILLS_DIR = REPO_ROOT / "skills"
+
+sys.path.insert(0, str(REPO_ROOT))
+from mlmm.cli import cli as root_cli  # noqa: E402
+
+
+def _collect_subcommand_flags() -> dict[str, set[str]]:
+    flags_per_cmd: dict[str, set[str]] = {}
+    ctx = click.Context(root_cli)
+    for name in root_cli.list_commands(ctx):
+        cmd = root_cli.get_command(ctx, name)
+        if cmd is None:
+            continue
+        flags: set[str] = set()
+        for p in cmd.params:
+            for opt in getattr(p, "opts", []) or []:
+                flags.add(opt)
+            for opt in getattr(p, "secondary_opts", []) or []:
+                flags.add(opt)
+        # universal flags every subcommand inherits in our setup
+        flags.update({"--help", "--help-advanced"})
+        flags_per_cmd[name] = flags
+    return flags_per_cmd
+
+
+_FENCE_RE = re.compile(r"^```(?:bash|console|sh)?\s*$")
+_FENCE_END_RE = re.compile(r"^```\s*$")
+_INLINE_RE = re.compile(r"`(mlmm\s+[^`]+)`")
+_FLAG_RE = re.compile(r"^-{1,2}[A-Za-z][\w-]*$")
+
+
+def _iter_command_lines(text: str):
+    in_fence = False
+    pending: list[str] = []
+    pending_lineno = 0
+    for lineno, line in enumerate(text.splitlines(), start=1):
+        if not in_fence and _FENCE_RE.match(line):
+            in_fence = True
+            continue
+        if in_fence and _FENCE_END_RE.match(line):
+            in_fence = False
+            if pending and "mlmm" in " ".join(pending):
+                yield pending_lineno, " ".join(pending)
+            pending = []
+            continue
+        if in_fence:
+            stripped = line.rstrip()
+            if stripped.endswith("\\"):
+                if not pending:
+                    pending_lineno = lineno
+                pending.append(stripped[:-1].strip())
+                continue
+            # End of a logical command
+            if pending:
+                pending.append(stripped.strip())
+                if "mlmm" in " ".join(pending):
+                    yield pending_lineno, " ".join(pending)
+                pending = []
+            else:
+                # standalone single-line command
+                if "mlmm" in stripped:
+                    yield lineno, stripped.strip()
+            continue
+        for m in _INLINE_RE.finditer(line):
+            yield lineno, m.group(1)
+
+
+def _check_command(cmd_text: str, flags_per_cmd: dict[str, set[str]]):
+    try:
+        tokens = shlex.split(cmd_text, posix=True)
+    except ValueError:
+        return []
+    if len(tokens) < 2 or tokens[0] != "mlmm":
+        return []
+    sub = tokens[1]
+    if sub not in flags_per_cmd:
+        return []
+    valid = flags_per_cmd[sub]
+    bad: list[str] = []
+    for tok in tokens[2:]:
+        if tok.startswith("<") or tok.startswith("{") or tok.startswith("["):
+            continue
+        if not tok.startswith("-"):
+            continue
+        # split --foo=bar
+        flag = tok.split("=", 1)[0]
+        if not _FLAG_RE.match(flag):
+            continue
+        if flag not in valid:
+            bad.append(flag)
+    return bad
+
+
+def main() -> int:
+    flags_per_cmd = _collect_subcommand_flags()
+    n_files = 0
+    n_errors = 0
+    for path in sorted(SKILLS_DIR.rglob("*.md")):
+        text = path.read_text()
+        for lineno, cmd in _iter_command_lines(text):
+            bad = _check_command(cmd, flags_per_cmd)
+            if bad:
+                n_errors += 1
+                print(f"{path.relative_to(REPO_ROOT)}:{lineno}: unknown flag(s) {bad} in: {cmd[:120]}")
+        n_files += 1
+    print(f"\nChecked {n_files} skill files; {n_errors} stale flag occurrences.")
+    return 1 if n_errors else 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())