pyrigor 0.1.1__tar.gz

pyrigor-0.1.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Jarl Hoyem (@jarl-hoyem)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

pyrigor-0.1.1/PKG-INFO

@@ -0,0 +1,107 @@
+Metadata-Version: 2.4
+Name: pyrigor
+Version: 0.1.1
+Summary: A Python coding discipline guideline collection and (eventually) linter.
+Author: Jarl Hoyem (@jarl-hoyem)
+License: MIT
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Provides-Extra: dev
+Requires-Dist: pytest>=8; extra == "dev"
+Requires-Dist: pytest-cov>=5; extra == "dev"
+Requires-Dist: mypy>=1.10; extra == "dev"
+Requires-Dist: pyright>=1.1.411; extra == "dev"
+Requires-Dist: ty>=0.0.69; extra == "dev"
+Requires-Dist: ruff>=0.6; extra == "dev"
+Requires-Dist: mutmut>=3; extra == "dev"
+Dynamic: license-file
+
+# pyrigor
+
+Disciplined Python patterns for catching bugs that type checkers and
+standard linters miss — inspired by safety-critical coding guidelines from
+other languages, adapted for a language and ecosystem they were not written
+for.
+
+## What this is
+
+Python’s failure modes are often silent: implicit type coercion,
+positional-argument swaps between same-typed parameters, mutable default
+arguments, float equality checks, and tuple-unpacking that "type-checks"
+while being semantically wrong are all real, tool-catchable classes of
+bugs that slip past mypy, pylint, and ruff’s default rule sets.
+
+`pyrigor` collects a set of guidelines — and, over time, tooling to enforce
+them — aimed at closing those gaps.
+
+## Status
+
+Early stage. As of 2026-08, a set of documented guidelines. AST-based checks are
+in progress. Plugin integration (pylint, possibly ruff) is a future goal,
+not a current feature.
+
+- [x] Guideline documentation
+- [x] Standalone AST-based checkers (pre-commit local hooks) — PYR402 implemented.
+  PYR201, PYR202, PYR401, PYR403 documented but not yet enforced.
+- [ ] pylint plugin
+- [ ] ruff plugin (stretch goal — contingent on learning Rust)
+
+## Usage
+
+```bash
+pip install pyrigor
+pyrigor path/to/file.py [path/to/another.py ...]
+```
+
+Only PYR402 is enforced today. A violation exits non-zero and prints
+`path:line:col: PYR402 message (keyword-only-arguments)`.
+
+To suppress a specific violation, add a same-line comment with a
+reason:
+
+```python
+def f(weight, bias):  # pyrigor: PYR402 # matches a fixed external API
+    ...
+```
+
+Codes may be given as the full code (`PYR402`), the bare number
+(`402`), or the rule’s symbolic name (`keyword-only-arguments`).
+Multiple codes: `# pyrigor: 402,403 # reason`. A suppression comment
+without a reason is ignored, and a warning is printed.
+
+## Guidelines
+
+See [`guidelines/`](./guidelines) for the full list. Each guideline has a
+rule ID, rationale, example, and — once implemented — a link to its
+enforcing check.
+
+Guidelines documented so far:
+
+| ID     | Rule                                                                  | Enforced by                     |
+|--------|-----------------------------------------------------------------------|---------------------------------|
+| PYR401 | Use `NamedTuple` for any function returning more than one value       | Not yet implemented             |
+| PYR201 | Use `NewType` for same-typed values at risk of being swapped          | Not yet implemented             |
+| PYR202 | Use `Enum` instead of magic strings, ints, or bools for closed states | Not yet implemented             |
+| PYR402 | Force keyword-only arguments for 2+ function parameters (bare `*`)    | `pyrigor` CLI (pre-commit hook) |
+| PYR403 | Force keyword-only arguments for single-parameter functions           | Not yet implemented             |
+
+## Philosophy
+
+Prefer explicit over implicit. Make illegal states unrepresentable. Do not
+rely on convention or code review where a tool can enforce correctness
+instead.
+
+## Contributing
+
+See [`CONTRIBUTING.md`](./CONTRIBUTING.md) for the setup and workflow.
+
+
+## License
+
+MIT

pyrigor-0.1.1/README.md

@@ -0,0 +1,83 @@
+# pyrigor
+
+Disciplined Python patterns for catching bugs that type checkers and
+standard linters miss — inspired by safety-critical coding guidelines from
+other languages, adapted for a language and ecosystem they were not written
+for.
+
+## What this is
+
+Python’s failure modes are often silent: implicit type coercion,
+positional-argument swaps between same-typed parameters, mutable default
+arguments, float equality checks, and tuple-unpacking that "type-checks"
+while being semantically wrong are all real, tool-catchable classes of
+bugs that slip past mypy, pylint, and ruff’s default rule sets.
+
+`pyrigor` collects a set of guidelines — and, over time, tooling to enforce
+them — aimed at closing those gaps.
+
+## Status
+
+Early stage. As of 2026-08, a set of documented guidelines. AST-based checks are
+in progress. Plugin integration (pylint, possibly ruff) is a future goal,
+not a current feature.
+
+- [x] Guideline documentation
+- [x] Standalone AST-based checkers (pre-commit local hooks) — PYR402 implemented.
+  PYR201, PYR202, PYR401, PYR403 documented but not yet enforced.
+- [ ] pylint plugin
+- [ ] ruff plugin (stretch goal — contingent on learning Rust)
+
+## Usage
+
+```bash
+pip install pyrigor
+pyrigor path/to/file.py [path/to/another.py ...]
+```
+
+Only PYR402 is enforced today. A violation exits non-zero and prints
+`path:line:col: PYR402 message (keyword-only-arguments)`.
+
+To suppress a specific violation, add a same-line comment with a
+reason:
+
+```python
+def f(weight, bias):  # pyrigor: PYR402 # matches a fixed external API
+    ...
+```
+
+Codes may be given as the full code (`PYR402`), the bare number
+(`402`), or the rule’s symbolic name (`keyword-only-arguments`).
+Multiple codes: `# pyrigor: 402,403 # reason`. A suppression comment
+without a reason is ignored, and a warning is printed.
+
+## Guidelines
+
+See [`guidelines/`](./guidelines) for the full list. Each guideline has a
+rule ID, rationale, example, and — once implemented — a link to its
+enforcing check.
+
+Guidelines documented so far:
+
+| ID     | Rule                                                                  | Enforced by                     |
+|--------|-----------------------------------------------------------------------|---------------------------------|
+| PYR401 | Use `NamedTuple` for any function returning more than one value       | Not yet implemented             |
+| PYR201 | Use `NewType` for same-typed values at risk of being swapped          | Not yet implemented             |
+| PYR202 | Use `Enum` instead of magic strings, ints, or bools for closed states | Not yet implemented             |
+| PYR402 | Force keyword-only arguments for 2+ function parameters (bare `*`)    | `pyrigor` CLI (pre-commit hook) |
+| PYR403 | Force keyword-only arguments for single-parameter functions           | Not yet implemented             |
+
+## Philosophy
+
+Prefer explicit over implicit. Make illegal states unrepresentable. Do not
+rely on convention or code review where a tool can enforce correctness
+instead.
+
+## Contributing
+
+See [`CONTRIBUTING.md`](./CONTRIBUTING.md) for the setup and workflow.
+
+
+## License
+
+MIT

pyrigor-0.1.1/pyproject.toml

@@ -0,0 +1,75 @@
+[build-system]
+requires = ["setuptools>=68", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "pyrigor"
+version = "0.1.1"
+description = "A Python coding discipline guideline collection and (eventually) linter."
+readme = "README.md"
+requires-python = ">=3.11"
+license = { text = "MIT" }
+authors = [
+  { name = "Jarl Hoyem (@jarl-hoyem)" }
+]
+classifiers = [
+  "Programming Language :: Python :: 3",
+  "Programming Language :: Python :: 3.11",
+  "Programming Language :: Python :: 3.12",
+  "Programming Language :: Python :: 3.13",
+  "Programming Language :: Python :: 3.14",
+]
+dependencies = []
+
+[project.scripts]
+pyrigor = "pyrigor.checkers.cli:run"
+
+[project.optional-dependencies]
+dev = [
+  "pytest>=8",
+  "pytest-cov>=5",
+  "mypy>=1.10",
+  "pyright>=1.1.411",
+  "ty>=0.0.69",
+  "ruff>=0.6",
+  "mutmut>=3",
+]
+
+[tool.setuptools.packages.find]
+where = ["."]
+include = ["pyrigor*"]
+
+[tool.mypy]
+python_version = "3.11"
+strict = true
+
+[tool.ruff]
+target-version = "py311"
+line-length = 120
+
+[tool.pytest.ini_options]
+markers = [
+  "slow: marks tests as slow (deselect with '-m \"not slow\"')",
+]
+addopts = [
+  "-m", "not slow",
+  "--cov=pyrigor",
+  "--cov-branch",
+  "--cov-report=html",
+  "--cov-report=term-missing",
+  "--cov-fail-under=100",
+  "--strict-markers",
+  "-W", "error",
+]
+
+[tool.coverage.run]
+source = ["pyrigor"]
+
+[tool.pydocstyle]
+convention = "google"
+
+[tool.mutmut]
+source_paths = "pyrigor/"
+
+[tool.pylint.format]
+max-line-length = 120

pyrigor-0.1.1/pyrigor/__init__.py

@@ -0,0 +1 @@
+"""pyrigor: a Python coding-discipline guideline collection (and eventually a linter)."""

pyrigor-0.1.1/pyrigor/checkers/__init__.py

@@ -0,0 +1,6 @@
+"""AST-based checkers for pyrigor's guidelines."""
+
+# pyrigor/checkers/__init__.py
+from pyrigor.checkers.pyr402_keyword_only_arguments import find_violations as find_pyr402_violations
+
+__all__ = ["find_pyr402_violations"]

pyrigor-0.1.1/pyrigor/checkers/cli.py

@@ -0,0 +1,40 @@
+"""Command-line entry point for pyrigor's checkers."""
+
+import sys
+from pathlib import Path
+
+from pyrigor.checkers import find_pyr402_violations
+from pyrigor.suppression import filter_suppressed
+
+
+def main(paths: list[str]) -> int:
+    """Run all checkers against the given file paths.
+
+    Args:
+        paths: File paths to check.
+
+    Returns:
+        0 if no violations were found, 1 otherwise.
+    """
+    exit_code = 0
+
+    for path in paths:
+        source = Path(path).read_text(encoding="utf-8")
+        violations = find_pyr402_violations(source)
+        violations = filter_suppressed(violations=violations, source=source)
+
+        for violation in violations:
+            location = f"{path}:{violation.line}:{violation.column}"
+            print(f"{location}: {violation.rule.name} {violation.message} ({violation.rule.value})")
+            exit_code = 1
+
+    return exit_code
+
+
+def run() -> None:
+    """Console-script entry point: parse argv and run main()."""
+    sys.exit(main(paths=sys.argv[1:]))
+
+
+if __name__ == "__main__":  # pragma: no cover
+    run()

pyrigor-0.1.1/pyrigor/checkers/pyr402_keyword_only_arguments.py

@@ -0,0 +1,68 @@
+"""PYR402 checker: flag functions with parameters before a bare `*`."""
+
+import ast
+from typing import NamedTuple
+
+from pyrigor.rules import Rule
+
+
+class Violation(NamedTuple):
+    """A single rule violation found by one of pyrigor's checkers."""
+
+    line: int
+    column: int
+    function_name: str
+    rule: Rule
+    message: str
+
+
+def _has_violation(node: ast.FunctionDef | ast.AsyncFunctionDef) -> bool:
+    """Check whether a function definition violates PYR402.
+
+    Args:
+        node: The function definition to check.
+
+    Returns:
+        True if the function has two or more parameters with at least
+        one positional (beyond an optional leading `self`/`cls`).
+        Single-parameter functions are exempt — see PYR403.
+    """
+    positional_args = list(node.args.posonlyargs) + list(node.args.args)
+    if positional_args and positional_args[0].arg in ("self", "cls"):
+        positional_args = positional_args[1:]
+
+    total_params = len(positional_args) + len(node.args.kwonlyargs)
+    if total_params < 2:
+        return False
+
+    return bool(positional_args)
+
+
+def find_violations(source: str) -> list[Violation]:
+    """Find PYR402 violations in a source string.
+
+    PYR402: all parameters should be keyword-only.
+
+    Args:
+        source: Python source code to check.
+
+    Returns:
+        A list of violations found, one per offending function.
+    """
+    tree = ast.parse(source)
+    violations = []
+
+    for node in ast.walk(tree):
+        if isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef)) and _has_violation(node):
+            violations.append(
+                Violation(
+                    line=node.lineno,
+                    column=node.col_offset + 1,
+                    function_name=node.name,
+                    rule=Rule.PYR402,
+                    message=f"Function '{node.name}' has positional parameters; "
+                    f"all parameters should be keyword-only (PYR402).",
+                )
+            )
+
+    return violations

pyrigor-0.1.1/pyrigor/rules.py

@@ -0,0 +1,15 @@
+"""Registry of all pyrigor rules.
+
+Each Rule member's name is the rule's code (for example, PYR402), and its
+value is the rule's symbolic name (for example, "keyword-only-arguments") —
+matching the pylint-style dual-identifier convention pyrigor's own
+output and suppression comments use.
+"""
+
+from enum import Enum
+
+
+class Rule(Enum):
+    """All pyrigor rules implemented or planned."""
+
+    PYR402 = "keyword-only-arguments"

pyrigor-0.1.1/pyrigor/suppression.py

@@ -0,0 +1,108 @@
+"""Suppression-comment mechanism for pyrigor's checkers.
+
+Recognizes `# pyrigor: CODE[, CODE...]` comments on the same line as a
+violation, where CODE may be a rule's full code ("PYR402"), its
+numeric shorthand ("402"), or its symbolic name
+("keyword-only-arguments"). Whitespace around the colon and commas is
+tolerated.
+"""
+
+import re
+import sys
+from typing import NamedTuple
+
+from pyrigor.checkers.pyr402_keyword_only_arguments import Violation
+
+
+class _SuppressionInfo(NamedTuple):
+    """Parsed contents of a `# pyrigor:` suppression comment."""
+
+    tokens: set[str]
+    reason: str | None
+
+
+_SUPPRESSION_PATTERN = re.compile(r"#\s*pyrigor\s*:\s*(?P<tokens>.+)$")
+_NEAR_MISS_PATTERN = re.compile(r"#.*pyrigor", re.IGNORECASE)
+
+
+def _suppressed_tokens(*, line: str) -> _SuppressionInfo:
+    """Get the suppression tokens and optional reason from a source line.
+
+    Args:
+        line: One line of source code.
+
+    Returns:
+        The suppression information is found on this line, or an empty
+        _SuppressionInfo if there is no suppression comment. If a
+        comment mentions "pyrigor" but doesn't match the expected
+        pattern, a warning is printed.
+    """
+    match = _SUPPRESSION_PATTERN.search(line)
+    if match is None:
+        if _NEAR_MISS_PATTERN.search(line):
+            print(
+                f"Warning: comment mentions 'pyrigor' but doesn't match "
+                f"'# pyrigor: CODE[,CODE] # reason' -- ignoring: {line.strip()}",
+                file=sys.stderr,
+            )
+        return _SuppressionInfo(tokens=set(), reason=None)
+
+    body = match.group("tokens")
+    codes_part, _, reason_part = body.partition("#")
+
+    tokens = {token.strip() for token in codes_part.split(",")}
+    reason = reason_part.strip() or None
+
+    return _SuppressionInfo(tokens=tokens, reason=reason)
+
+
+def _matches_suppression(*, violation: Violation, suppression: _SuppressionInfo) -> bool:
+    """Check whether a violation is suppressed by the given suppression information.
+
+    Args:
+        violation: The violation to check.
+        suppression: Suppression information parsed from the violation's line.
+
+    Returns:
+        True if the violation's rule code, numeric shorthand, or
+        symbolic name is present in suppression tokens, and a reason
+        is present. Suppression with codes but no reason does not
+        suppress. Instead, a warning is printed.
+    """
+    code = violation.rule.name
+    shorthand = code.removeprefix("PYR")
+    name = violation.rule.value
+
+    code_matches = bool(suppression.tokens & {code, shorthand, name})
+
+    if code_matches and suppression.reason is None:
+        print(
+            f"Warning: suppression on line {violation.line} for {code} is missing required reason, ignoring.",
+            file=sys.stderr,
+        )
+        return False
+
+    return code_matches
+
+
+def filter_suppressed(*, violations: list[Violation], source: str) -> list[Violation]:
+    """Remove violations suppressed by a same-line `# pyrigor:` comment.
+
+    Args:
+        violations: Violations to filter.
+        source: The source code the violations were found in.
+
+    Returns:
+        Violations that are not suppressed.
+    """
+    lines = source.splitlines()
+
+    result = []
+    for violation in violations:
+        line_text = lines[violation.line - 1] if 0 < violation.line <= len(lines) else ""
+        suppression = _suppressed_tokens(line=line_text)
+
+        if not _matches_suppression(violation=violation, suppression=suppression):
+            result.append(violation)
+
+    return result

pyrigor-0.1.1/pyrigor.egg-info/PKG-INFO

@@ -0,0 +1,107 @@
+Metadata-Version: 2.4
+Name: pyrigor
+Version: 0.1.1
+Summary: A Python coding discipline guideline collection and (eventually) linter.
+Author: Jarl Hoyem (@jarl-hoyem)
+License: MIT
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Provides-Extra: dev
+Requires-Dist: pytest>=8; extra == "dev"
+Requires-Dist: pytest-cov>=5; extra == "dev"
+Requires-Dist: mypy>=1.10; extra == "dev"
+Requires-Dist: pyright>=1.1.411; extra == "dev"
+Requires-Dist: ty>=0.0.69; extra == "dev"
+Requires-Dist: ruff>=0.6; extra == "dev"
+Requires-Dist: mutmut>=3; extra == "dev"
+Dynamic: license-file
+
+# pyrigor
+
+Disciplined Python patterns for catching bugs that type checkers and
+standard linters miss — inspired by safety-critical coding guidelines from
+other languages, adapted for a language and ecosystem they were not written
+for.
+
+## What this is
+
+Python’s failure modes are often silent: implicit type coercion,
+positional-argument swaps between same-typed parameters, mutable default
+arguments, float equality checks, and tuple-unpacking that "type-checks"
+while being semantically wrong are all real, tool-catchable classes of
+bugs that slip past mypy, pylint, and ruff’s default rule sets.
+
+`pyrigor` collects a set of guidelines — and, over time, tooling to enforce
+them — aimed at closing those gaps.
+
+## Status
+
+Early stage. As of 2026-08, a set of documented guidelines. AST-based checks are
+in progress. Plugin integration (pylint, possibly ruff) is a future goal,
+not a current feature.
+
+- [x] Guideline documentation
+- [x] Standalone AST-based checkers (pre-commit local hooks) — PYR402 implemented.
+  PYR201, PYR202, PYR401, PYR403 documented but not yet enforced.
+- [ ] pylint plugin
+- [ ] ruff plugin (stretch goal — contingent on learning Rust)
+
+## Usage
+
+```bash
+pip install pyrigor
+pyrigor path/to/file.py [path/to/another.py ...]
+```
+
+Only PYR402 is enforced today. A violation exits non-zero and prints
+`path:line:col: PYR402 message (keyword-only-arguments)`.
+
+To suppress a specific violation, add a same-line comment with a
+reason:
+
+```python
+def f(weight, bias):  # pyrigor: PYR402 # matches a fixed external API
+    ...
+```
+
+Codes may be given as the full code (`PYR402`), the bare number
+(`402`), or the rule’s symbolic name (`keyword-only-arguments`).
+Multiple codes: `# pyrigor: 402,403 # reason`. A suppression comment
+without a reason is ignored, and a warning is printed.
+
+## Guidelines
+
+See [`guidelines/`](./guidelines) for the full list. Each guideline has a
+rule ID, rationale, example, and — once implemented — a link to its
+enforcing check.
+
+Guidelines documented so far:
+
+| ID     | Rule                                                                  | Enforced by                     |
+|--------|-----------------------------------------------------------------------|---------------------------------|
+| PYR401 | Use `NamedTuple` for any function returning more than one value       | Not yet implemented             |
+| PYR201 | Use `NewType` for same-typed values at risk of being swapped          | Not yet implemented             |
+| PYR202 | Use `Enum` instead of magic strings, ints, or bools for closed states | Not yet implemented             |
+| PYR402 | Force keyword-only arguments for 2+ function parameters (bare `*`)    | `pyrigor` CLI (pre-commit hook) |
+| PYR403 | Force keyword-only arguments for single-parameter functions           | Not yet implemented             |
+
+## Philosophy
+
+Prefer explicit over implicit. Make illegal states unrepresentable. Do not
+rely on convention or code review where a tool can enforce correctness
+instead.
+
+## Contributing
+
+See [`CONTRIBUTING.md`](./CONTRIBUTING.md) for the setup and workflow.
+
+
+## License
+
+MIT

pyrigor-0.1.1/pyrigor.egg-info/SOURCES.txt

@@ -0,0 +1,18 @@
+LICENSE
+README.md
+pyproject.toml
+pyrigor/__init__.py
+pyrigor/py.typed
+pyrigor/rules.py
+pyrigor/suppression.py
+pyrigor.egg-info/PKG-INFO
+pyrigor.egg-info/SOURCES.txt
+pyrigor.egg-info/dependency_links.txt
+pyrigor.egg-info/entry_points.txt
+pyrigor.egg-info/requires.txt
+pyrigor.egg-info/top_level.txt
+pyrigor/checkers/__init__.py
+pyrigor/checkers/cli.py
+pyrigor/checkers/pyr402_keyword_only_arguments.py
+tests/test_rules.py
+tests/test_suppression.py

pyrigor-0.1.1/pyrigor.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

pyrigor-0.1.1/pyrigor.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+pyrigor = pyrigor.checkers.cli:run

pyrigor-0.1.1/pyrigor.egg-info/requires.txt

@@ -0,0 +1,9 @@
+
+[dev]
+pytest>=8
+pytest-cov>=5
+mypy>=1.10
+pyright>=1.1.411
+ty>=0.0.69
+ruff>=0.6
+mutmut>=3

pyrigor-0.1.1/pyrigor.egg-info/top_level.txt

@@ -0,0 +1 @@
+pyrigor

pyrigor-0.1.1/setup.cfg

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

pyrigor-0.1.1/tests/test_rules.py

@@ -0,0 +1,9 @@
+"""Tests for pyrigor's Rule registry."""
+
+from pyrigor.rules import Rule
+
+
+def test_pyr402_rule_has_correct_code_and_name() -> None:
+    """Rule PYR402's enum name/value should match the expected code and symbolic name."""
+    assert Rule.PYR402.name == "PYR402"
+    assert Rule.PYR402.value == "keyword-only-arguments"

pyrigor-0.1.1/tests/test_suppression.py

@@ -0,0 +1,120 @@
+"""Tests for pyrigor's suppression-comment mechanism."""
+
+from pytest import CaptureFixture
+
+from pyrigor.checkers.pyr402_keyword_only_arguments import Violation
+from pyrigor.rules import Rule
+
+# noinspection PyProtectedMember
+from pyrigor.suppression import (
+    _suppressed_tokens,  # pylint: disable=protected-access
+    filter_suppressed,
+)
+
+
+def test_suppressed_violation_is_filtered_out() -> None:
+    """A violation on a line with a matching # pyrigor: CODE # reason comment should be removed."""
+    source = "def apply_correction(weight, bias):  # pyrigor: PYR402 # positional swap risk\n    ...\n"
+    violations = [Violation(line=1, column=1, function_name="apply_correction", rule=Rule.PYR402, message="...")]
+
+    result = filter_suppressed(violations=violations, source=source)
+
+    assert not result
+
+
+def test_unsuppressed_violation_is_kept() -> None:
+    """A violation on a line with no suppression comment should be kept."""
+    source = "def apply_correction(weight, bias):\n    ...\n"
+    violations = [Violation(line=1, column=1, function_name="apply_correction", rule=Rule.PYR402, message="...")]
+
+    result = filter_suppressed(violations=violations, source=source)
+
+    assert result == violations
+
+
+def test_multiple_suppressed_codes_on_one_line() -> None:
+    """Multiple codes in one # pyrigor: comment should each suppress their matching violation."""
+    source = "def apply_correction(weight, bias):  # pyrigor: 402,201 # some reason\n    ...\n"
+    violations = [
+        Violation(line=1, column=1, function_name="apply_correction", rule=Rule.PYR402, message="..."),
+    ]
+
+    result = filter_suppressed(violations=violations, source=source)
+
+    assert not result
+
+
+def test_symbolic_name_suppresses_violation() -> None:
+    """A suppression comment using the symbolic name should work, as well as the code."""
+    source = "def apply_correction(weight, bias):  # pyrigor: keyword-only-arguments # some reason\n    ...\n"
+    violations = [
+        Violation(line=1, column=1, function_name="apply_correction", rule=Rule.PYR402, message="..."),
+    ]
+
+    result = filter_suppressed(violations=violations, source=source)
+
+    assert not result
+
+
+def test_whitespace_around_colon_and_commas_is_tolerated() -> None:
+    """Irregular spacing around the colon and commas should still parse correctly."""
+    source = "def apply_correction(weight, bias):  #pyrigor:  402 , 201 # some reason\n    ...\n"
+    violations = [
+        Violation(line=1, column=1, function_name="apply_correction", rule=Rule.PYR402, message="..."),
+    ]
+
+    result = filter_suppressed(violations=violations, source=source)
+
+    assert not result
+
+
+def test_suppression_comment_with_reason_is_parsed() -> None:
+    """A # pyrigor: CODE # reason comment should suppress and capture the reason text."""
+    source = (
+        "def apply_correction(weight, bias):  # pyrigor: 402 # pytest fixture injection is positional-only\n    ...\n"
+    )
+    violations = [
+        Violation(line=1, column=1, function_name="apply_correction", rule=Rule.PYR402, message="..."),
+    ]
+
+    result = filter_suppressed(violations=violations, source=source)
+
+    assert not result
+
+
+def test_suppression_comment_reason_is_parsed_correctly() -> None:
+    """The free-text reason after the second # should be captured verbatim."""
+    line = "def apply_correction(weight, bias):  # pyrigor: 402 # positional injection required by pytest"
+
+    info = _suppressed_tokens(line=line)
+
+    assert info.tokens == {"402"}
+    assert info.reason == "positional injection required by pytest"
+
+
+def test_suppression_without_reason_does_not_suppress(capsys: CaptureFixture[str]) -> None:
+    """A suppression comment with no reason should not suppress and should warn."""
+    source = "def apply_correction(weight, bias):  # pyrigor: 402\n    ...\n"
+    violations = [
+        Violation(line=1, column=1, function_name="apply_correction", rule=Rule.PYR402, message="..."),
+    ]
+
+    result = filter_suppressed(violations=violations, source=source)
+
+    captured = capsys.readouterr()
+    assert result == violations
+    assert "missing required reason" in captured.err
+
+
+def test_near_miss_comment_warns(capsys: CaptureFixture[str]) -> None:
+    """A comment mentioning 'pyrigor' that doesn't match the suppression pattern should warn."""
+    source = "def apply_correction(weight, bias):  # pyrigor 402 missing colon\n    ...\n"
+    violations = [
+        Violation(line=1, column=1, function_name="apply_correction", rule=Rule.PYR402, message="..."),
+    ]
+
+    result = filter_suppressed(violations=violations, source=source)
+
+    captured = capsys.readouterr()
+    assert result == violations
+    assert "doesn't match" in captured.err