lint-tool 2026.9.14__tar.gz

lint_tool-2026.9.14/LICENSE

@@ -0,0 +1,15 @@
+Copyright (c) 2025-2026 KhwarizmiAnalytix
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU General Public License for more details.
+
+SPDX-License-Identifier: GPL-3.0-or-later
+
+Full license text: https://www.gnu.org/licenses/gpl-3.0.html

lint_tool-2026.9.14/PKG-INFO

@@ -0,0 +1,76 @@
+Metadata-Version: 2.4
+Name: lint-tool
+Version: 2026.9.14
+Summary: lintrunner adapters for C++/Python/CMake repositories
+Author: KhwarizmiAnalytix
+License-Expression: GPL-3.0-or-later
+Project-URL: Homepage, https://github.com/KhwarizmiAnalytix/lint-tool
+Project-URL: Source, https://github.com/KhwarizmiAnalytix/lint-tool
+Project-URL: Issues, https://github.com/KhwarizmiAnalytix/lint-tool/issues
+Keywords: lintrunner,lint,clang-format,ruff,cmake
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Quality Assurance
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: tomli>=2.0; python_version < "3.11"
+Provides-Extra: test
+Requires-Dist: pytest>=7.0; extra == "test"
+Dynamic: license-file
+
+# lint-tool
+
+lintrunner adapters for C++/Python/CMake repositories. Host repos own
+policy (`.lintrunner.toml`, `.clang-format`, `pyproject.toml`); this
+package owns the adapter implementations.
+
+```bash
+pip install lint-tool
+```
+
+Invoke adapters through lintrunner:
+
+```toml
+[[linter]]
+code = 'CLANGFORMAT'
+include_patterns = ['**/*.cpp', '**/*.h']
+exclude_patterns = ['ThirdParty/**']
+command = [
+    'python3',
+    '-m',
+    'lint_tool.adapters.clangformat_linter',
+    '--binary=clang-format',
+    '--',
+    '@{{PATHSFILE}}',
+]
+init_command = [
+    'python3',
+    '-m',
+    'lint_tool.adapters.pip_init',
+    '--dry-run={{DRYRUN}}',
+    'clang-format==19.1.4',
+]
+```
+
+Adapters find the consumer root by walking up from cwd for
+`.lintrunner.toml` or `.git`, or from `LINTRUNNER_HOST_ROOT`. They do not
+assume an XSigma `Tools/linter/adapters` layout.
+
+A Logging/Parallel-sized menu is typically CLANGFORMAT, CMAKE,
+CMAKEFORMAT, EDITORCONFIG, NEWLINE, and CODESPELL. Do not copy a full
+XSigma `.lintrunner.toml`.
+
+```bash
+python3 -m lint_tool                 # list usage
+python3 -m lint_tool.adapters.ruff_linter --help
+python3 -m pytest tests/             # from a clone, after pip install -e ".[test]"
+```
+
+Source: https://github.com/KhwarizmiAnalytix/lint-tool

lint_tool-2026.9.14/README.md

@@ -0,0 +1,49 @@
+# lint-tool
+
+lintrunner adapters for C++/Python/CMake repositories. Host repos own
+policy (`.lintrunner.toml`, `.clang-format`, `pyproject.toml`); this
+package owns the adapter implementations.
+
+```bash
+pip install lint-tool
+```
+
+Invoke adapters through lintrunner:
+
+```toml
+[[linter]]
+code = 'CLANGFORMAT'
+include_patterns = ['**/*.cpp', '**/*.h']
+exclude_patterns = ['ThirdParty/**']
+command = [
+    'python3',
+    '-m',
+    'lint_tool.adapters.clangformat_linter',
+    '--binary=clang-format',
+    '--',
+    '@{{PATHSFILE}}',
+]
+init_command = [
+    'python3',
+    '-m',
+    'lint_tool.adapters.pip_init',
+    '--dry-run={{DRYRUN}}',
+    'clang-format==19.1.4',
+]
+```
+
+Adapters find the consumer root by walking up from cwd for
+`.lintrunner.toml` or `.git`, or from `LINTRUNNER_HOST_ROOT`. They do not
+assume an XSigma `Tools/linter/adapters` layout.
+
+A Logging/Parallel-sized menu is typically CLANGFORMAT, CMAKE,
+CMAKEFORMAT, EDITORCONFIG, NEWLINE, and CODESPELL. Do not copy a full
+XSigma `.lintrunner.toml`.
+
+```bash
+python3 -m lint_tool                 # list usage
+python3 -m lint_tool.adapters.ruff_linter --help
+python3 -m pytest tests/             # from a clone, after pip install -e ".[test]"
+```
+
+Source: https://github.com/KhwarizmiAnalytix/lint-tool

lint_tool-2026.9.14/pyproject.toml

@@ -0,0 +1,49 @@
+[build-system]
+requires = ["setuptools>=68"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "lint-tool"
+version = "2026.9.14"
+description = "lintrunner adapters for C++/Python/CMake repositories"
+readme = "README.md"
+requires-python = ">=3.9"
+license = "GPL-3.0-or-later"
+authors = [
+    { name = "KhwarizmiAnalytix" },
+]
+keywords = ["lintrunner", "lint", "clang-format", "ruff", "cmake"]
+classifiers = [
+    "Development Status :: 5 - Production/Stable",
+    "Environment :: Console",
+    "Intended Audience :: Developers",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Topic :: Software Development :: Quality Assurance",
+]
+dependencies = [
+    "tomli>=2.0; python_version < '3.11'",
+]
+
+[project.optional-dependencies]
+test = ["pytest>=7.0"]
+
+[project.urls]
+Homepage = "https://github.com/KhwarizmiAnalytix/lint-tool"
+Source = "https://github.com/KhwarizmiAnalytix/lint-tool"
+Issues = "https://github.com/KhwarizmiAnalytix/lint-tool/issues"
+
+[project.scripts]
+lint-tool = "lint_tool.__main__:main"
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.setuptools.package-data]
+"lint_tool.adapters" = ["*.json"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]

lint_tool-2026.9.14/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

lint_tool-2026.9.14/src/lint_tool/__init__.py

@@ -0,0 +1,3 @@
+"""lintrunner adapter suite for KhwarizmiAnalytix repositories."""
+
+__version__ = "2026.9.14"

lint_tool-2026.9.14/src/lint_tool/__main__.py

@@ -0,0 +1,16 @@
+"""``python -m lint_tool`` prints how to invoke adapters."""
+
+from __future__ import annotations
+
+from lint_tool import __version__
+
+
+def main() -> None:
+    print(f"lint-tool {__version__}")
+    print("Run an adapter with:")
+    print("  python3 -m lint_tool.adapters.<name> --help")
+    print("Examples: clangformat_linter, ruff_linter, pip_init, s3_init")
+
+
+if __name__ == "__main__":
+    main()

lint_tool-2026.9.14/src/lint_tool/adapters/_linter/__init__.py

@@ -0,0 +1,45 @@
+from __future__ import annotations
+
+import token
+from typing import TYPE_CHECKING
+
+
+if TYPE_CHECKING:
+    from collections.abc import Sequence
+    from tokenize import TokenInfo
+
+
+__all__ = (
+    "Block",
+    "EMPTY_TOKENS",
+    "FileLinter",
+    "LineWithSets",
+    "LintResult",
+    "ParseError",
+    "PythonFile",
+    "ROOT",
+    "host_root",
+)
+
+NO_TOKEN = -1
+
+# Python 3.12 and up have two new token types, FSTRING_START and FSTRING_END
+_START_OF_LINE_TOKENS = token.DEDENT, token.INDENT, token.NEWLINE
+_IGNORED_TOKENS = token.COMMENT, token.ENDMARKER, token.ENCODING, token.NL
+EMPTY_TOKENS = dict.fromkeys(_START_OF_LINE_TOKENS + _IGNORED_TOKENS)
+
+from .host import host_root
+
+ROOT = host_root()
+
+
+class ParseError(ValueError):
+    def __init__(self, token: TokenInfo, *args: str) -> None:
+        super().__init__(*args)
+        self.token = token
+
+
+from .block import Block
+from .file_linter import FileLinter
+from .messages import LintResult
+from .python_file import PythonFile

lint_tool-2026.9.14/src/lint_tool/adapters/_linter/argument_parser.py

@@ -0,0 +1,47 @@
+from __future__ import annotations
+
+import argparse
+import sys
+from typing import Any
+from typing_extensions import Never
+
+
+class ArgumentParser(argparse.ArgumentParser):
+    """
+    Adds better help formatting and default arguments to argparse.ArgumentParser
+    """
+
+    def __init__(
+        self,
+        prog: str | None = None,
+        usage: str | None = None,
+        description: str | None = None,
+        epilog: str | None = None,
+        is_fixer: bool = False,
+        **kwargs: Any,
+    ) -> None:
+        super().__init__(prog, usage, description, None, **kwargs)
+        self._epilog = epilog
+
+        help = "A list of files or directories to lint"
+        self.add_argument("files", nargs="*", help=help)
+        # TODO(rec): get fromfile_prefix_chars="@", type=argparse.FileType to work
+
+        help = "Fix lint errors if possible" if is_fixer else argparse.SUPPRESS
+        self.add_argument("-f", "--fix", action="store_true", help=help)
+
+        help = "Run for lintrunner and print LintMessages which aren't edits"
+        self.add_argument("-l", "--lintrunner", action="store_true", help=help)
+
+        help = "Print more debug info"
+        self.add_argument("-v", "--verbose", action="store_true", help=help)
+
+    def exit(self, status: int = 0, message: str | None = None) -> Never:
+        """
+        Overriding this method is a workaround for argparse throwing away all
+        line breaks when printing the `epilog` section of the help message.
+        """
+        argv = sys.argv[1:]
+        if self._epilog and not status and "-h" in argv or "--help" in argv:
+            print(self._epilog)
+        super().exit(status, message)

lint_tool-2026.9.14/src/lint_tool/adapters/_linter/block.py

@@ -0,0 +1,179 @@
+from __future__ import annotations
+
+import dataclasses as dc
+import itertools
+import token
+from enum import Enum
+from functools import cached_property, total_ordering
+from typing import TYPE_CHECKING, Any, Optional
+from typing_extensions import Self
+
+
+if TYPE_CHECKING:
+    from collections.abc import Iterator, Sequence
+    from tokenize import TokenInfo
+
+
+_OVERRIDES = {"@override", "@typing_extensions.override", "@typing.override"}
+
+
+@total_ordering
+@dc.dataclass
+class Block:
+    """A block of Python code starting with either `def` or `class`"""
+
+    class Category(str, Enum):
+        CLASS = "class"
+        DEF = "def"
+
+    category: Category
+
+    # The sequence of tokens that contains this Block.
+    # Tokens are represented in `Block` as indexes into `self.tokens`
+    tokens: Sequence[TokenInfo] = dc.field(repr=False)
+
+    # The name of the function or class being defined
+    name: str
+
+    # The index of the very first token in the block (the "class" or "def" keyword)
+    begin: int
+
+    # The index of the first INDENT token for this block
+    indent: int
+
+    # The index of the DEDENT token for this end of this block
+    dedent: int
+
+    # The docstring for the block
+    docstring: str
+
+    # These next members only get filled in after all blocks have been constructed
+    # and figure out family ties
+
+    # The full qualified name of the block within the file.
+    # This is the name of this block and all its parents, joined with `.`.
+    full_name: str = ""
+
+    # The index of this block within the full list of blocks in the file
+    index: int = 0
+
+    # Is this block contained within a function definition?
+    is_local: bool = dc.field(default=False, repr=False)
+
+    # Is this block a function definition in a class definition?
+    is_method: bool = dc.field(default=False, repr=False)
+
+    # A block index to the parent of this block, or None for a top-level block.
+    parent: Optional[int] = None
+
+    # A list of block indexes for the children
+    children: list[int] = dc.field(default_factory=list)
+
+    @property
+    def start_line(self) -> int:
+        """The line number for the def or class statement"""
+        return self.tokens[self.begin].start[0]
+
+    @property
+    def end_line(self) -> int:
+        if 0 <= self.dedent < len(self.tokens):
+            return self.tokens[self.dedent].start[0] - 1
+        else:
+            return self.tokens[-1].start[0]
+            # Only happens in one case so far: a file whose last line was
+            #
+            #    def function(): ...
+            #
+            # and the dedent correctly pointed to one past the end of self.tokens
+
+    @property
+    def line_count(self) -> int:
+        return self.end_line - self.start_line
+
+    @property
+    def is_class(self) -> bool:
+        return self.category == Block.Category.CLASS
+
+    @property
+    def display_name(self) -> str:
+        """A user-friendly name like 'class One' or 'def One.method()'"""
+        ending = "" if self.is_class else "()"
+        return f"{self.category.value} {self.full_name}{ending}"
+
+    @cached_property
+    def decorators(self) -> list[str]:
+        """A list of decorators for this function or method.
+
+        Each decorator both the @ symbol and any arguments to the decorator
+        but no extra whitespace.
+        """
+        return _get_decorators(self.tokens, self.begin)
+
+    @cached_property
+    def is_override(self) -> bool:
+        return not self.is_class and bool(_OVERRIDES.intersection(self.decorators))
+
+    DATA_FIELDS = (
+        "category",
+        "children",
+        "decorators",
+        "display_name",
+        "docstring",
+        "full_name",
+        "index",
+        "is_local",
+        "is_method",
+        "line_count",
+        "parent",
+        "start_line",
+    )
+
+    def as_data(self) -> dict[str, Any]:
+        d = {i: getattr(self, i) for i in self.DATA_FIELDS}
+        d["category"] = d["category"].value
+        return d
+
+    @property
+    def is_init(self) -> bool:
+        return not self.is_class and self.name == "__init__"
+
+    def contains(self, b: Block) -> bool:
+        return self.start_line < b.start_line and self.end_line >= b.end_line
+
+    def __eq__(self, o: object) -> bool:
+        assert isinstance(o, Block)
+        return o.tokens is self.tokens and o.index == self.index
+
+    def __hash__(self) -> int:
+        return super().__hash__()
+
+    def __lt__(self, o: Self) -> bool:
+        assert isinstance(o, Block) and o.tokens is self.tokens
+        return o.index < self.index
+
+
+_IGNORE = {token.COMMENT, token.DEDENT, token.INDENT, token.NL}
+
+
+def _get_decorators(tokens: Sequence[TokenInfo], block_start: int) -> list[str]:
+    def decorators() -> Iterator[str]:
+        rev = reversed(range(block_start))
+        newlines = (i for i in rev if tokens[i].type == token.NEWLINE)
+        it = iter(itertools.chain(newlines, [-1]))
+        # The -1 accounts for the very first line in the file
+
+        end = next(it, -1)  # Like itertools.pairwise in Python 3.10
+        for begin in it:
+            for i in range(begin + 1, end):
+                t = tokens[i]
+                if t.type == token.OP and t.string == "@":
+                    useful = (t for t in tokens[i:end] if t.type not in _IGNORE)
+                    yield "".join(s.string.strip("\n") for s in useful)
+                    break
+                elif t.type not in _IGNORE:
+                    return  # A statement means no more decorators
+            end = begin
+
+    out = list(decorators())
+    out.reverse()
+    return out

lint_tool-2026.9.14/src/lint_tool/adapters/_linter/blocks.py

@@ -0,0 +1,129 @@
+from __future__ import annotations
+
+import token
+from typing import TYPE_CHECKING, NamedTuple
+
+from . import EMPTY_TOKENS, ParseError
+from .block import Block
+
+
+if TYPE_CHECKING:
+    from collections.abc import Sequence
+    from tokenize import TokenInfo
+
+
+class BlocksResult(NamedTuple):
+    blocks: list[Block]
+    errors: dict[str, str]
+
+
+def blocks(tokens: Sequence[TokenInfo]) -> BlocksResult:
+    blocks: list[Block] = []
+    indent_to_dedent = _make_indent_dict(tokens)
+    errors: dict[str, str] = {}
+
+    def starts_block(t: TokenInfo) -> bool:
+        return t.type == token.NAME and t.string in ("class", "def")
+
+    it = (i for i, t in enumerate(tokens) if starts_block(t))
+    blocks = [_make_block(tokens, i, indent_to_dedent, errors) for i in it]
+
+    for i, parent in enumerate(blocks):
+        for j in range(i + 1, len(blocks)):
+            if parent.contains(child := blocks[j]):
+                child.parent = i
+                parent.children.append(j)
+            else:
+                break
+
+    for i, b in enumerate(blocks):
+        b.index = i
+        parents = [b]
+        while (p := parents[-1].parent) is not None:
+            parents.append(blocks[p])
+        parents = parents[1:]
+
+        b.is_local = not all(p.is_class for p in parents)
+        b.is_method = not b.is_class and bool(parents) and parents[0].is_class
+
+    _add_full_names(blocks, [b for b in blocks if b.parent is None])
+    return BlocksResult(blocks, errors)
+
+
+def _make_indent_dict(tokens: Sequence[TokenInfo]) -> dict[int, int]:
+    dedents = dict[int, int]()
+    stack = list[int]()
+
+    for i, t in enumerate(tokens):
+        if t.type == token.INDENT:
+            stack.append(i)
+        elif t.type == token.DEDENT:
+            dedents[stack.pop()] = i
+
+    return dedents
+
+
+def _docstring(tokens: Sequence[TokenInfo], start: int) -> str:
+    for i in range(start + 1, len(tokens)):
+        tk = tokens[i]
+        if tk.type == token.STRING:
+            return tk.string
+        if tk.type not in EMPTY_TOKENS:
+            return ""
+    return ""
+
+
+def _add_full_names(
+    blocks: Sequence[Block], children: Sequence[Block], prefix: str = ""
+) -> None:
+    # Would be trivial except that there can be duplicate names at any level
+    dupes: dict[str, list[Block]] = {}
+    for b in children:
+        dupes.setdefault(b.name, []).append(b)
+
+    for dl in dupes.values():
+        for i, b in enumerate(dl):
+            suffix = f"[{i + 1}]" if len(dl) > 1 else ""
+            b.full_name = prefix + b.name + suffix
+
+    for b in children:
+        if kids := [blocks[i] for i in b.children]:
+            _add_full_names(blocks, kids, b.full_name + ".")
+
+
+def _make_block(
+    tokens: Sequence[TokenInfo],
+    begin: int,
+    indent_to_dedent: dict[int, int],
+    errors: dict[str, str],
+) -> Block:
+    def next_token(start: int, token_type: int, error: str) -> int:
+        for i in range(start, len(tokens)):
+            if tokens[i].type == token_type:
+                return i
+        raise ParseError(tokens[-1], error)
+
+    t = tokens[begin]
+    category = Block.Category[t.string.upper()]
+    indent = -1
+    dedent = -1
+    docstring = ""
+    name = "(not found)"
+    try:
+        ni = next_token(begin + 1, token.NAME, "Definition but no name")
+        name = tokens[ni].string
+        indent = next_token(ni + 1, token.INDENT, "Definition but no indent")
+        dedent = indent_to_dedent[indent]
+        docstring = _docstring(tokens, indent)
+    except ParseError as e:
+        errors[t.line] = " ".join(e.args)
+
+    return Block(
+        begin=begin,
+        category=category,
+        dedent=dedent,
+        docstring=docstring,
+        indent=indent,
+        name=name,
+        tokens=tokens,
+    )

lint_tool-2026.9.14/src/lint_tool/adapters/_linter/bracket_pairs.py

@@ -0,0 +1,45 @@
+import token
+from collections.abc import Sequence
+from tokenize import TokenInfo
+
+from . import NO_TOKEN, ParseError
+
+
+FSTRING_START: int = getattr(token, "FSTRING_START", NO_TOKEN)
+FSTRING_END: int = getattr(token, "FSTRING_END", NO_TOKEN)
+
+BRACKETS = {"{": "}", "(": ")", "[": "]"}
+BRACKETS_INV = {j: i for i, j in BRACKETS.items()}
+
+
+def bracket_pairs(tokens: Sequence[TokenInfo]) -> dict[int, int]:
+    """Returns a dictionary mapping opening to closing brackets"""
+    braces: dict[int, int] = {}
+    stack: list[int] = []
+    in_fstring = False
+
+    for i, t in enumerate(tokens):
+        if t.type == token.OP and not in_fstring:
+            if t.string in BRACKETS:
+                stack.append(i)
+            elif inv := BRACKETS_INV.get(t.string):
+                if not stack:
+                    raise ParseError(t, "Never opened")
+                begin = stack.pop()
+
+                if not (stack and stack[-1] == FSTRING_START):
+                    braces[begin] = i
+
+                b = tokens[begin].string
+                if b != inv:
+                    raise ParseError(t, f"Mismatched braces '{b}' at {begin}")
+        elif t.type == FSTRING_START:
+            stack.append(FSTRING_START)
+            in_fstring = True
+        elif t.type == FSTRING_END:
+            if stack.pop() != FSTRING_START:
+                raise ParseError(t, "Mismatched FSTRING_START/FSTRING_END")
+            in_fstring = False
+    if stack:
+        raise ParseError(t, "Left open")
+    return braces