anti-slop-python 0.1.0__py3-none-any.whl

anti_slop_python/__init__.py

@@ -0,0 +1,6 @@
+"""Opinionated checks for Python patterns that weaken code evidence."""
+
+from anti_slop_python.checker import check_file, check_source
+from anti_slop_python.diagnostics import Diagnostic
+
+__all__ = ["Diagnostic", "check_file", "check_source"]

anti_slop_python/__main__.py

@@ -0,0 +1,3 @@
+from anti_slop_python.cli import main
+
+raise SystemExit(main())

anti_slop_python/checker.py

@@ -0,0 +1,53 @@
+from __future__ import annotations
+
+import ast
+import tokenize
+from pathlib import Path
+
+from anti_slop_python.diagnostics import Diagnostic
+from anti_slop_python.rules import RULES
+from anti_slop_python.rules.base import RuleContext
+
+
+def check_source(source: str, path: str | Path = "<unknown>") -> list[Diagnostic]:
+    """Check source text and return diagnostics in source order."""
+
+    source_path = Path(path)
+    try:
+        tree = ast.parse(source, filename=str(source_path))
+    except SyntaxError as error:
+        return [_syntax_error(source_path, error)]
+
+    context = RuleContext(path=source_path, tree=tree)
+    diagnostics = [diagnostic for rule in RULES for diagnostic in rule.check(context)]
+    return sorted(diagnostics)
+
+
+def check_file(path: str | Path) -> list[Diagnostic]:
+    """Read and check one Python source file."""
+
+    source_path = Path(path)
+    try:
+        with tokenize.open(source_path) as source_file:
+            source = source_file.read()
+    except (OSError, SyntaxError) as error:
+        return [
+            Diagnostic(
+                path=source_path,
+                line=1,
+                column=1,
+                code="IOError",
+                message=str(error),
+            )
+        ]
+    return check_source(source, source_path)
+
+
+def _syntax_error(path: Path, error: SyntaxError) -> Diagnostic:
+    return Diagnostic(
+        path=path,
+        line=error.lineno or 1,
+        column=error.offset or 1,
+        code="SyntaxError",
+        message=error.msg,
+    )

anti_slop_python/cli.py

@@ -0,0 +1,86 @@
+from __future__ import annotations
+
+import argparse
+import os
+import sys
+from collections.abc import Iterable, Sequence
+from pathlib import Path
+
+from anti_slop_python.checker import check_file
+from anti_slop_python.ruff_integration import RuffFailure, check_with_ruff
+
+_IGNORED_DIRECTORIES = {
+    ".git",
+    ".venv",
+    "__pycache__",
+    "build",
+    "dist",
+    "venv",
+}
+
+
+def main(argv: Sequence[str] | None = None) -> int:
+    parser = _parser()
+    arguments = parser.parse_args(argv)
+
+    try:
+        files = list(_python_files(arguments.paths))
+    except ValueError as error:
+        parser.error(str(error))
+
+    try:
+        ruff_result = check_with_ruff(arguments.paths, files)
+    except RuffFailure as error:
+        print(f"anti-slop-python: {error}", file=sys.stderr)
+        return 2
+
+    for warning in ruff_result.warnings:
+        print(warning, file=sys.stderr)
+    for notice in ruff_result.notices:
+        print(f"anti-slop-python policy notice: {notice}", file=sys.stderr)
+
+    diagnostics = [diagnostic for path in files for diagnostic in check_file(path)]
+    diagnostics.extend(ruff_result.diagnostics)
+    for diagnostic in sorted(diagnostics):
+        print(diagnostic)
+    return 1 if diagnostics else 0
+
+
+def _parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        prog="anti-slop-python",
+        description="Reject Python patterns that weaken architectural evidence.",
+    )
+    parser.add_argument(
+        "paths",
+        nargs="*",
+        type=Path,
+        default=[Path(".")],
+        help="Python files or directories to check (default: current directory)",
+    )
+    return parser
+
+
+def _python_files(paths: Iterable[Path]) -> Iterable[Path]:
+    seen: set[Path] = set()
+    for path in paths:
+        if not path.exists():
+            raise ValueError(f"path does not exist: {path}")
+        candidates = [path] if path.is_file() else _walk_python_files(path)
+        for candidate in candidates:
+            if candidate.suffix != ".py":
+                continue
+            identity = candidate.resolve()
+            if identity not in seen:
+                seen.add(identity)
+                yield candidate
+
+
+def _walk_python_files(root: Path) -> Iterable[Path]:
+    for directory, subdirectories, filenames in os.walk(root):
+        subdirectories[:] = sorted(
+            name for name in subdirectories if name not in _IGNORED_DIRECTORIES
+        )
+        for filename in sorted(filenames):
+            if filename.endswith(".py"):
+                yield Path(directory, filename)

anti_slop_python/diagnostics.py

@@ -0,0 +1,18 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from pathlib import Path
+
+
+@dataclass(frozen=True, order=True)
+class Diagnostic:
+    """A source location and the check that failed there."""
+
+    path: Path
+    line: int
+    column: int
+    code: str
+    message: str
+
+    def __str__(self) -> str:
+        return f"{self.path}:{self.line}:{self.column} {self.code} {self.message}"

anti_slop_python/ruff_integration.py

@@ -0,0 +1,203 @@
+from __future__ import annotations
+
+import json
+import os
+import subprocess
+import sys
+from collections.abc import Sequence
+from dataclasses import dataclass
+from pathlib import Path
+
+from anti_slop_python.diagnostics import Diagnostic
+from anti_slop_python.ruff_policy import (
+    _RECOMMENDED_RULES,
+    RuffFailure,
+    RuffSettings,
+    configuration_arguments,
+    default_arguments,
+    parse_settings,
+    policy_notices_for_scopes,
+    settings_scopes,
+)
+
+
+@dataclass(frozen=True)
+class RuffCheckResult:
+    """Ruff diagnostics and advisory policy output for one invocation."""
+
+    diagnostics: tuple[Diagnostic, ...]
+    notices: tuple[str, ...]
+    warnings: tuple[str, ...]
+
+
+def check_with_ruff(
+    _paths: Sequence[Path], python_files: Sequence[Path]
+) -> RuffCheckResult:
+    """Run Ruff with anti-slop-python defaults and project-configured overrides."""
+
+    diagnostics: list[Diagnostic] = []
+    warnings: list[str] = []
+    noqa_notices: list[str] = []
+    scopes = settings_scopes(python_files)
+    effective_settings: list[RuffSettings] = []
+    for configuration, files in scopes:
+        config_arguments = configuration_arguments(configuration)
+        included_files = _included_files(files, config_arguments)
+        if not included_files:
+            continue
+        baseline = _resolved_settings(included_files[0], config_arguments)
+        arguments = (*config_arguments, *default_arguments(baseline))
+        for targets in _path_batches(included_files):
+            normal = _ruff_diagnostics(targets, arguments, python_files)
+            diagnostics.extend(normal.diagnostics)
+            warnings.extend(normal.warnings)
+            audit = _ruff_diagnostics(
+                targets, ("--ignore-noqa", *arguments), python_files
+            )
+            noqa_notices.extend(_noqa_notices(normal.diagnostics, audit.diagnostics))
+        effective_settings.append(_resolved_settings(included_files[0], arguments))
+
+    notices = (*policy_notices_for_scopes(effective_settings), *noqa_notices)
+    return RuffCheckResult(
+        tuple(sorted(set(diagnostics))),
+        notices,
+        tuple(dict.fromkeys(warnings)),
+    )
+
+
+@dataclass(frozen=True)
+class _RuffDiagnostics:
+    diagnostics: tuple[Diagnostic, ...]
+    warnings: tuple[str, ...]
+
+
+def _ruff_diagnostics(
+    targets: Sequence[Path],
+    arguments: Sequence[str],
+    python_files: Sequence[Path],
+) -> _RuffDiagnostics:
+    completed = _run_ruff(
+        "check",
+        "--output-format",
+        "json",
+        "--no-fix",
+        "--no-fix-only",
+        "--exit-zero",
+        "--force-exclude",
+        *arguments,
+        "--",
+        *(str(path) for path in targets),
+    )
+    return _RuffDiagnostics(
+        diagnostics=_parse_diagnostics(completed.stdout, python_files),
+        warnings=tuple(line for line in completed.stderr.splitlines() if line),
+    )
+
+
+def _noqa_notices(
+    normal: Sequence[Diagnostic], audit: Sequence[Diagnostic]
+) -> tuple[str, ...]:
+    normal_keys = {(item.path, item.line, item.column, item.code) for item in normal}
+    return tuple(
+        f"{item.code} is suppressed by noqa at {item.path}:{item.line}; "
+        "recommended for checked files"
+        for item in audit
+        if item.code in _RECOMMENDED_RULES
+        and (item.path, item.line, item.column, item.code) not in normal_keys
+    )
+
+
+def _run_ruff(*arguments: str) -> subprocess.CompletedProcess[str]:
+    environment = os.environ.copy()
+    for name in ("RUFF_FIX", "RUFF_FIX_ONLY", "RUFF_OUTPUT_FILE", "RUFF_OUTPUT_FORMAT"):
+        environment.pop(name, None)
+
+    try:
+        completed = subprocess.run(
+            [sys.executable, "-m", "ruff", *arguments],
+            capture_output=True,
+            check=False,
+            env=environment,
+            text=True,
+        )
+    except OSError as error:
+        raise RuffFailure(f"Ruff failed: {error}") from error
+
+    if completed.returncode != 0:
+        detail = completed.stderr.strip() or completed.stdout.strip()
+        raise RuffFailure(f"Ruff failed: {detail or 'unknown error'}")
+    return completed
+
+
+def _parse_diagnostics(
+    output: str, python_files: Sequence[Path]
+) -> tuple[Diagnostic, ...]:
+    try:
+        items = json.loads(output)
+    except json.JSONDecodeError as error:
+        raise RuffFailure(f"Ruff returned invalid JSON: {error.msg}") from error
+    if not isinstance(items, list):
+        raise RuffFailure("Ruff returned invalid JSON: expected a diagnostic list")
+
+    display_paths = {path.resolve(): path for path in python_files}
+    diagnostics: list[Diagnostic] = []
+    for item in items:
+        if not isinstance(item, dict):
+            continue
+        filename = Path(str(item.get("filename", "<unknown>")))
+        if item.get("code") == "invalid-syntax" and filename.resolve() in display_paths:
+            continue
+        location = item.get("location")
+        if not isinstance(location, dict):
+            raise RuffFailure("Ruff returned a diagnostic without a source location")
+        path = display_paths.get(filename.resolve(), _display_path(filename))
+        diagnostics.append(
+            Diagnostic(
+                path=path,
+                line=int(location["row"]),
+                column=int(location["column"]),
+                code=str(item.get("code") or "Ruff"),
+                message=str(item.get("message") or "Ruff violation"),
+            )
+        )
+    return tuple(sorted(diagnostics))
+
+
+def _display_path(path: Path) -> Path:
+    try:
+        return path.relative_to(Path.cwd())
+    except ValueError:
+        return path
+
+
+def _included_files(
+    files: Sequence[Path], configuration_arguments: Sequence[str]
+) -> tuple[Path, ...]:
+    included_paths: set[Path] = set()
+    for targets in _path_batches(files):
+        completed = _run_ruff(
+            "check",
+            "--show-files",
+            "--force-exclude",
+            *configuration_arguments,
+            "--",
+            *(str(path) for path in targets),
+        )
+        included_paths.update(
+            Path(line).resolve() for line in completed.stdout.splitlines()
+        )
+    return tuple(path for path in files if path.resolve() in included_paths)
+
+
+def _path_batches(
+    files: Sequence[Path], batch_size: int = 500
+) -> tuple[tuple[Path, ...], ...]:
+    return tuple(
+        tuple(files[index : index + batch_size])
+        for index in range(0, len(files), batch_size)
+    )
+
+
+def _resolved_settings(file: Path, extra_arguments: Sequence[str] = ()) -> RuffSettings:
+    completed = _run_ruff("check", "--show-settings", *extra_arguments, "--", str(file))
+    return parse_settings(completed.stdout)

anti_slop_python/ruff_policy.py

@@ -0,0 +1,398 @@
+from __future__ import annotations
+
+import json
+import re
+import tomllib
+from collections.abc import Sequence
+from dataclasses import dataclass
+from pathlib import Path
+
+_RECOMMENDED_RULES = ("C901", "PLR0915", "TID251", "E722", "BLE001")
+_RECOMMENDED_BANNED_APIS = {
+    "mock.patch": "Avoid patching state. Pass the dependency explicitly instead.",
+    "unittest.mock.patch": (
+        "Avoid patching state. Pass the dependency explicitly instead."
+    ),
+}
+_MAX_COMPLEXITY = 10
+_MAX_STATEMENTS = 40
+_RULE_CODE = re.compile(r"\(([A-Z][A-Z0-9]*\d+)\),?$")
+
+
+class RuffFailure(RuntimeError):
+    """Raised when Ruff cannot complete a check or expose its settings."""
+
+
+@dataclass(frozen=True)
+class RuffSettings:
+    enabled_rules: frozenset[str]
+    max_complexity: int
+    max_statements: int
+    banned_apis: frozenset[str]
+    banned_api_messages: tuple[tuple[str, str], ...]
+    per_file_ignores: tuple[tuple[str, frozenset[str]], ...]
+    path: Path | None
+
+
+def settings_scopes(
+    files: Sequence[Path],
+) -> tuple[tuple[Path | None, tuple[Path, ...]], ...]:
+    scopes: dict[Path | None, list[Path]] = {}
+    config_cache: dict[Path, Path | None] = {}
+    for file in files:
+        scopes.setdefault(ruff_config_for(file, config_cache), []).append(file)
+    return tuple(
+        (configuration, tuple(scope)) for configuration, scope in scopes.items()
+    )
+
+
+def configuration_arguments(path: Path | None) -> tuple[str, ...]:
+    if path is None:
+        return ("--isolated",)
+    return ("--config", str(path))
+
+
+def ruff_config_for(file: Path, cache: dict[Path, Path | None]) -> Path | None:
+    return ruff_config_for_directory(file.resolve().parent, cache)
+
+
+def ruff_config_for_directory(
+    directory: Path, cache: dict[Path, Path | None]
+) -> Path | None:
+    if directory in cache:
+        return cache[directory]
+
+    for filename in (".ruff.toml", "ruff.toml"):
+        candidate = directory / filename
+        if candidate.is_file():
+            cache[directory] = candidate
+            return candidate
+
+    pyproject = directory / "pyproject.toml"
+    if pyproject.is_file():
+        try:
+            configuration = tomllib.loads(pyproject.read_text())
+        except (OSError, tomllib.TOMLDecodeError):
+            cache[directory] = pyproject
+            return pyproject
+        tool = configuration.get("tool")
+        if isinstance(tool, dict) and isinstance(tool.get("ruff"), dict):
+            cache[directory] = pyproject
+            return pyproject
+    parent = directory.parent
+    resolved = None if parent == directory else ruff_config_for_directory(parent, cache)
+    cache[directory] = resolved
+    return resolved
+
+
+def parse_settings(output: str) -> RuffSettings:
+    enabled_rules = _rule_codes(
+        _setting_block(output, "linter.rules.enabled", "[", "]")
+    )
+    banned_api_block = _setting_block(
+        output, "linter.flake8_tidy_imports.banned_api", "{", "}"
+    )
+    banned_api_messages = _parse_banned_apis(banned_api_block)
+    per_file_block = _setting_block(output, "linter.per_file_ignores", "{", "}")
+    raw_path = _optional_setting_value(output, "Settings path:")
+    return RuffSettings(
+        enabled_rules=enabled_rules,
+        max_complexity=int(_setting_value(output, "linter.mccabe.max_complexity")),
+        max_statements=int(_setting_value(output, "linter.pylint.max_statements")),
+        banned_apis=frozenset(api for api, _ in banned_api_messages),
+        banned_api_messages=banned_api_messages,
+        per_file_ignores=_parse_per_file_ignores(per_file_block),
+        path=Path(_quoted_value(raw_path)) if raw_path is not None else None,
+    )
+
+
+def default_arguments(settings: RuffSettings) -> tuple[str, ...]:
+    ignored_selectors = _configured_ignore_selectors(settings.path)
+    default_rules = [
+        code
+        for code in _RECOMMENDED_RULES
+        if not any(_selector_matches(code, selector) for selector in ignored_selectors)
+    ]
+    arguments: list[str] = []
+    if default_rules:
+        arguments.extend(["--extend-select", ",".join(default_rules)])
+    if not _configuration_defines_any(
+        settings.path,
+        (("lint", "mccabe", "max-complexity"), ("mccabe", "max-complexity")),
+    ):
+        arguments.extend(
+            ["--config", f"lint.mccabe.max-complexity = {_MAX_COMPLEXITY}"]
+        )
+    if not _configuration_defines_any(
+        settings.path,
+        (("lint", "pylint", "max-statements"), ("pylint", "max-statements")),
+    ):
+        arguments.extend(
+            ["--config", f"lint.pylint.max-statements = {_MAX_STATEMENTS}"]
+        )
+
+    if not _configuration_defines_any(
+        settings.path,
+        (
+            ("lint", "flake8-tidy-imports", "banned-api"),
+            ("flake8-tidy-imports", "banned-api"),
+        ),
+    ):
+        entries = ", ".join(
+            f"{json.dumps(api)} = {{ msg = {json.dumps(message)} }}"
+            for api, message in sorted(_RECOMMENDED_BANNED_APIS.items())
+        )
+        arguments.extend(
+            ["--config", f"lint.flake8-tidy-imports.banned-api = {{{entries}}}"]
+        )
+    return tuple(arguments)
+
+
+def policy_notices_for_scopes(
+    settings: Sequence[RuffSettings],
+) -> tuple[str, ...]:
+    multiple_scopes = len(settings) > 1
+    notices: list[str] = []
+    for resolved in settings:
+        suffix = ""
+        if multiple_scopes and resolved.path is not None:
+            suffix = f" [Ruff settings: {resolved.path}]"
+        notices.extend(f"{notice}{suffix}" for notice in _policy_notices(resolved))
+    return tuple(notices)
+
+
+def _configured_ignore_selectors(path: Path | None) -> tuple[str, ...]:
+    selectors: list[str] = []
+    for configuration in _configuration_chain(path):
+        replacement = _lint_setting(configuration, "ignore")
+        if isinstance(replacement, list):
+            selectors = [str(value) for value in replacement]
+        additions = _lint_setting(configuration, "extend-ignore")
+        if isinstance(additions, list):
+            selectors.extend(str(value) for value in additions)
+    return tuple(selectors)
+
+
+def _selector_matches(code: str, selector: str) -> bool:
+    return selector == "ALL" or code.startswith(selector)
+
+
+def _lint_setting(configuration: dict[str, object], name: str) -> object:
+    lint = configuration.get("lint")
+    hyphenated = name.replace("_", "-")
+    underscored = name.replace("-", "_")
+    if isinstance(lint, dict):
+        if hyphenated in lint:
+            return lint[hyphenated]
+        if underscored in lint:
+            return lint[underscored]
+    if hyphenated in configuration:
+        return configuration[hyphenated]
+    if underscored in configuration:
+        return configuration[underscored]
+    return None
+
+
+def _configuration_chain(
+    path: Path | None, seen: frozenset[Path] = frozenset()
+) -> tuple[dict[str, object], ...]:
+    if path is None:
+        return ()
+    resolved_path = path.resolve()
+    if resolved_path in seen:
+        return ()
+    try:
+        document = tomllib.loads(resolved_path.read_text())
+    except (OSError, tomllib.TOMLDecodeError):
+        return ()
+
+    configuration: object = document
+    if resolved_path.name == "pyproject.toml":
+        configuration = document.get("tool", {}).get("ruff", {})
+    if not isinstance(configuration, dict):
+        return ()
+
+    base: tuple[dict[str, object], ...] = ()
+    extended = configuration.get("extend")
+    if isinstance(extended, str):
+        extended_path = Path(extended)
+        if not extended_path.is_absolute():
+            extended_path = resolved_path.parent / extended_path
+        base = _configuration_chain(extended_path, seen | {resolved_path})
+    return (*base, configuration)
+
+
+def _configuration_defines_any(
+    path: Path | None, setting_paths: Sequence[tuple[str, ...]]
+) -> bool:
+    return any(
+        _configuration_defines(path, setting_path) for setting_path in setting_paths
+    )
+
+
+def _configuration_defines(
+    path: Path | None,
+    setting_path: tuple[str, ...],
+) -> bool:
+    return any(
+        _mapping_has_path(configuration, setting_path)
+        for configuration in _configuration_chain(path)
+    )
+
+
+def _mapping_has_path(mapping: dict[str, object], path: tuple[str, ...]) -> bool:
+    current: object = mapping
+    for part in path:
+        if not isinstance(current, dict):
+            return False
+        hyphenated = part.replace("_", "-")
+        underscored = part.replace("-", "_")
+        if hyphenated in current:
+            current = current[hyphenated]
+        elif underscored in current:
+            current = current[underscored]
+        else:
+            return False
+    return True
+
+
+def _setting_block(output: str, name: str, opener: str, closer: str) -> str:
+    lines = output.splitlines()
+    marker = f"{name} = {opener}"
+    empty_marker = f"{marker}{closer}"
+    for index, line in enumerate(lines):
+        if line.strip() == empty_marker:
+            return ""
+        if line.strip() != marker:
+            continue
+        block: list[str] = []
+        for candidate in lines[index + 1 :]:
+            if candidate.strip() == closer:
+                return "\n".join(block)
+            block.append(candidate)
+    raise RuffFailure("Ruff returned an unsupported resolved-settings format")
+
+
+def _setting_value(output: str, name: str) -> str:
+    value = _optional_setting_value(output, f"{name} =")
+    if value is None:
+        raise RuffFailure("Ruff returned an unsupported resolved-settings format")
+    return value
+
+
+def _optional_setting_value(output: str, marker: str) -> str | None:
+    for line in output.splitlines():
+        if line.strip().startswith(marker):
+            return line.strip().removeprefix(marker).strip()
+    return None
+
+
+def _rule_codes(block: str) -> frozenset[str]:
+    rules: set[str] = set()
+    for line in block.splitlines():
+        _add_rule_code(line.strip(), rules)
+    return frozenset(rules)
+
+
+def _parse_banned_apis(block: str) -> tuple[tuple[str, str], ...]:
+    banned_apis: list[tuple[str, str]] = []
+    for line in block.splitlines():
+        api, separator, message = line.strip().removesuffix(",").partition(" = ")
+        if separator:
+            banned_apis.append((api, message))
+    return tuple(banned_apis)
+
+
+def _parse_per_file_ignores(
+    block: str,
+) -> tuple[tuple[str, frozenset[str]], ...]:
+    ignores: list[tuple[str, frozenset[str]]] = []
+    current_pattern: str | None = None
+    current_rules: set[str] = set()
+    for line in block.splitlines():
+        stripped = line.strip()
+        if stripped.startswith("basename_matcher = "):
+            if current_pattern is not None:
+                ignores.append((current_pattern, frozenset(current_rules)))
+            current_pattern = _quoted_value(stripped.partition(" = ")[2])
+            current_rules = set()
+        else:
+            _add_rule_code(stripped, current_rules)
+    if current_pattern is not None:
+        ignores.append((current_pattern, frozenset(current_rules)))
+    return tuple(ignores)
+
+
+def _quoted_value(value: str) -> str:
+    try:
+        parsed = json.loads(value)
+    except json.JSONDecodeError:
+        return value
+    return str(parsed)
+
+
+def _add_rule_code(line: str, destination: set[str]) -> None:
+    match = _RULE_CODE.search(line)
+    if match is not None:
+        destination.add(match.group(1))
+
+
+def _policy_notices(settings: RuffSettings) -> tuple[str, ...]:
+    notices = _disabled_rule_notices(settings)
+    notices.extend(_limit_notices(settings))
+    notices.extend(_banned_api_notices(settings))
+    notices.extend(_per_file_ignore_notices(settings))
+    return tuple(notices)
+
+
+def _disabled_rule_notices(settings: RuffSettings) -> list[str]:
+    return [
+        f"{code} is disabled; recommended: enabled"
+        for code in _RECOMMENDED_RULES
+        if code not in settings.enabled_rules
+    ]
+
+
+def _limit_notices(settings: RuffSettings) -> list[str]:
+    notices: list[str] = []
+    if "C901" in settings.enabled_rules and settings.max_complexity > _MAX_COMPLEXITY:
+        notices.append(
+            f"C901 allows complexity {settings.max_complexity}; "
+            f"recommended maximum: {_MAX_COMPLEXITY}"
+        )
+    if (
+        "PLR0915" in settings.enabled_rules
+        and settings.max_statements > _MAX_STATEMENTS
+    ):
+        notices.append(
+            f"PLR0915 allows {settings.max_statements} statements; "
+            f"recommended maximum: {_MAX_STATEMENTS}"
+        )
+    return notices
+
+
+def _banned_api_notices(settings: RuffSettings) -> list[str]:
+    if "TID251" not in settings.enabled_rules:
+        return []
+    return [
+        f"TID251 does not ban {api}; recommended: ban this API"
+        for api in _RECOMMENDED_BANNED_APIS
+        if not _api_is_banned(api, settings.banned_apis)
+    ]
+
+
+def _api_is_banned(api: str, banned_apis: frozenset[str]) -> bool:
+    return any(api == banned or api.startswith(f"{banned}.") for banned in banned_apis)
+
+
+def _per_file_ignore_notices(settings: RuffSettings) -> list[str]:
+    notices: list[str] = []
+    enabled_recommendations = settings.enabled_rules.intersection(_RECOMMENDED_RULES)
+    for pattern, ignored_rules in settings.per_file_ignores:
+        for code in _RECOMMENDED_RULES:
+            if code in enabled_recommendations and code in ignored_rules:
+                notices.append(
+                    f"{code} is ignored for {pattern}; "
+                    "recommended for all checked files"
+                )
+    return notices

anti_slop_python/rules/__init__.py

@@ -0,0 +1,12 @@
+from anti_slop_python.rules.base import Rule
+from anti_slop_python.rules.no_any_containers import RULE as NO_ANY_CONTAINERS
+from anti_slop_python.rules.no_dynamic_attribute_access import (
+    RULE as NO_DYNAMIC_ATTRIBUTE_ACCESS,
+)
+
+RULES: tuple[Rule, ...] = (
+    NO_ANY_CONTAINERS,
+    NO_DYNAMIC_ATTRIBUTE_ACCESS,
+)
+
+__all__ = ["RULES", "Rule"]

anti_slop_python/rules/base.py

@@ -0,0 +1,86 @@
+from __future__ import annotations
+
+import ast
+from collections.abc import Callable, Iterable
+from dataclasses import dataclass, field
+from pathlib import Path
+
+from anti_slop_python.diagnostics import Diagnostic
+
+
+@dataclass(frozen=True)
+class Rule:
+    """Metadata and checker function for one rule."""
+
+    code: str
+    name: str
+    message: str
+    check: Callable[[RuleContext], Iterable[Diagnostic]]
+
+
+@dataclass
+class RuleContext:
+    """Parsed source and the shared import analysis used by rules."""
+
+    path: Path
+    tree: ast.AST
+    imports: dict[str, str] = field(init=False)
+
+    def __post_init__(self) -> None:
+        self.imports = _collect_imports(self.tree)
+
+    def qualified_name(self, node: ast.AST) -> str | None:
+        """Resolve a simple imported name without full semantic analysis."""
+
+        name = _dotted_name(node)
+        if name is None:
+            return None
+
+        first, separator, remainder = name.partition(".")
+        resolved = self.imports.get(first, first)
+        if separator:
+            return f"{resolved}.{remainder}"
+        return resolved
+
+    def diagnostic(self, rule: Rule, node: ast.AST) -> Diagnostic:
+        return Diagnostic(
+            path=self.path,
+            line=node.lineno,
+            column=node.col_offset + 1,
+            code=rule.code,
+            message=rule.message,
+        )
+
+
+def _collect_imports(tree: ast.AST) -> dict[str, str]:
+    imports: dict[str, str] = {}
+    for node in ast.walk(tree):
+        if isinstance(node, ast.Import):
+            for alias in node.names:
+                local_name = alias.asname or alias.name.split(".", 1)[0]
+                target = alias.name if alias.asname else local_name
+                imports[local_name] = target
+        elif isinstance(node, ast.ImportFrom):
+            dots = "." * (node.level or 0)
+            if node.module:
+                module_prefix = f"{dots}{node.module}."
+            elif dots:
+                module_prefix = f"{dots}"
+            else:
+                module_prefix = ""
+            for alias in node.names:
+                if alias.name == "*":
+                    continue
+                local_name = alias.asname or alias.name
+                imports[local_name] = f"{module_prefix}{alias.name}"
+    return imports
+
+
+def _dotted_name(node: ast.AST) -> str | None:
+    if isinstance(node, ast.Name):
+        return node.id
+    if isinstance(node, ast.Attribute):
+        parent = _dotted_name(node.value)
+        if parent is not None:
+            return f"{parent}.{node.attr}"
+    return None

anti_slop_python/rules/no_any_containers.py

@@ -0,0 +1,55 @@
+from __future__ import annotations
+
+import ast
+from collections.abc import Iterable
+
+from anti_slop_python.diagnostics import Diagnostic
+from anti_slop_python.rules.base import Rule, RuleContext
+
+_CONTAINERS = {
+    "dict",
+    "list",
+    "set",
+    "tuple",
+    "typing.Dict",
+    "typing.List",
+    "typing.Set",
+    "typing.Tuple",
+    "typing_extensions.Dict",
+    "typing_extensions.List",
+    "typing_extensions.Set",
+    "typing_extensions.Tuple",
+}
+_ANY_NAMES = {"Any", "typing.Any", "typing_extensions.Any"}
+
+
+def _check(context: RuleContext) -> Iterable[Diagnostic]:
+    for node in ast.walk(context.tree):
+        if not isinstance(node, ast.Subscript):
+            continue
+        if context.qualified_name(node.value) not in _CONTAINERS:
+            continue
+        if _contains_any(context, node.slice):
+            yield context.diagnostic(RULE, node)
+
+
+def _contains_any(context: RuleContext, node: ast.AST) -> bool:
+    if (
+        isinstance(node, ast.Subscript)
+        and context.qualified_name(node.value) in _CONTAINERS
+    ):
+        return False
+    if (
+        isinstance(node, (ast.Name, ast.Attribute))
+        and context.qualified_name(node) in _ANY_NAMES
+    ):
+        return True
+    return any(_contains_any(context, child) for child in ast.iter_child_nodes(node))
+
+
+RULE = Rule(
+    code="SPY001",
+    name="no-any-containers",
+    message="Avoid containers parameterized with Any",
+    check=_check,
+)

anti_slop_python/rules/no_dynamic_attribute_access.py

@@ -0,0 +1,32 @@
+from __future__ import annotations
+
+import ast
+from collections.abc import Iterable
+
+from anti_slop_python.diagnostics import Diagnostic
+from anti_slop_python.rules.base import Rule, RuleContext
+
+_DYNAMIC_ATTRIBUTE_FUNCTIONS = {
+    "builtins.delattr",
+    "builtins.getattr",
+    "builtins.setattr",
+    "delattr",
+    "getattr",
+    "setattr",
+}
+
+
+def _check(context: RuleContext) -> Iterable[Diagnostic]:
+    for node in ast.walk(context.tree):
+        if not isinstance(node, ast.Call):
+            continue
+        if context.qualified_name(node.func) in _DYNAMIC_ATTRIBUTE_FUNCTIONS:
+            yield context.diagnostic(RULE, node)
+
+
+RULE = Rule(
+    code="SPY002",
+    name="no-dynamic-attribute-access",
+    message="Avoid dynamic attribute access",
+    check=_check,
+)

anti_slop_python-0.1.0.dist-info/METADATA

@@ -0,0 +1,349 @@
+Metadata-Version: 2.5
+Name: anti-slop-python
+Version: 0.1.0
+Summary: An opinionated architectural linter for Python
+Project-URL: Homepage, https://github.com/ruarfff/anti-slop-python
+Project-URL: Repository, https://github.com/ruarfff/anti-slop-python
+Project-URL: Issues, https://github.com/ruarfff/anti-slop-python/issues
+Author: Ruairí O'Brien
+License-Expression: MIT
+License-File: LICENSE
+Keywords: anti-slop,architecture,code-quality,linter,pre-commit,ruff
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Console
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Topic :: Software Development :: Quality Assurance
+Requires-Python: >=3.11
+Requires-Dist: ruff<0.17,>=0.16.5
+Description-Content-Type: text/markdown
+
+# anti-slop-python
+
+[![skills.sh](https://skills.sh/b/ruarfff/anti-slop-python)](https://skills.sh/ruarfff/anti-slop-python)
+
+`anti-slop-python` is a small, opinionated architectural
+linter for Python inspired by and largely copied from
+[dmmulroy/anti-slop](https://github.com/dmmulroy/anti-slop).
+
+It requires [ruff](https://github.com/astral-sh/ruff) so it is not a standalone linter.
+
+`anti-slop-python` does not attempt to determine whether code was written by a human
+or an agent. It rejects patterns that weaken evidence about types, invariants,
+boundaries, and dependencies.
+
+It also catches very common issues when using LLMs to generate Python code like functions
+and files getting way too big.
+
+## Setup
+
+### Install it using the agent skill
+
+The repository includes `install-anti-slop-python`, an Agent Skill that
+installs and configures anti-slop-python in a target Python repository.
+
+The [`skills` CLI](https://github.com/vercel-labs/skills) supports project and
+global installs for many coding agents.
+
+```bash
+# Install interactively for the current project
+npx skills add ruarfff/anti-slop-python --skill install-anti-slop-python
+```
+
+Make the skill available everywhere on your system:
+
+```bash
+npx skills add ruarfff/anti-slop-python --skill install-anti-slop-python --agent '*' --global --yes
+```
+
+See the [`skills` CLI documentation](https://github.com/vercel-labs/skills#supported-agents).
+
+### Install it with pre-commit
+
+This repository applies `anti-slop-python` to itself through the local hook in
+`.pre-commit-config.yaml`.
+
+The repository includes hook metadata. Add this entry to
+`.pre-commit-config.yaml` and replace the revision with the release to use:
+
+```yaml
+repos:
+  - repo: https://github.com/ruarfff/anti-slop-python
+    rev: v0.1.0
+    hooks:
+      - id: anti-slop-python
+```
+
+Run against an entire project:
+
+```bash
+uv run pre-commit run anti-slop-python --all-files
+```
+
+#### Adopt it for selected directories
+
+Use pre-commit's `files` regular expression to limit the hook to selected
+parts of a project:
+
+```yaml
+repos:
+  - repo: https://github.com/ruarfff/anti-slop-python
+    rev: v0.1.0
+    hooks:
+      - id: anti-slop-python
+        files: ^(?:src/a-specific-module/|tests/tests-for-that-module/)
+```
+
+Useful if you want to gradually introduce `anti-slop-python` to a project.
+
+Expand the `files` expression as more directories adopt the policy.
+This does not override the project's Ruff configuration for files outside the selected directories.
+
+## Rules
+
+Native `anti-slop-python` rules cover some checks that Ruff does not provide:
+
+| Rule | Name | Rejected pattern |
+| --- | --- | --- |
+| SPY001 | `no-any-containers` | `dict`, `list`, `set`, or `tuple` parameterized with `Any` (including their `typing` aliases) |
+| SPY002 | `no-dynamic-attribute-access` | Calls to `getattr()`, `setattr()`, or `delattr()` |
+
+### Ruff-backed policy
+
+`anti-slop-python` uses Ruff for checks that Ruff already provides. It enables this
+policy by default:
+
+| Rule | Default policy |
+| --- | --- |
+| [`C901`](https://docs.astral.sh/ruff/rules/complex-structure/) | Cyclomatic complexity of at most 10 |
+| [`PLR0915`](https://docs.astral.sh/ruff/rules/too-many-statements/) | At most 40 statements per function or method |
+| [`TID251`](https://docs.astral.sh/ruff/rules/banned-api/) | Ban `unittest.mock.patch` and `mock.patch` |
+| [`E722`](https://docs.astral.sh/ruff/rules/bare-except/) | Reject bare exception handlers |
+| [`BLE001`](https://docs.astral.sh/ruff/rules/blind-except/) | Reject broad exception handlers |
+
+No Ruff configuration is required when you run `anti-slop-python`. Its defaults are
+equivalent to:
+
+```toml
+[tool.ruff.lint]
+extend-select = ["BLE001", "C901", "E722", "PLR0915", "TID251"]
+
+[tool.ruff.lint.mccabe]
+max-complexity = 10
+
+[tool.ruff.lint.pylint]
+max-statements = 40
+
+[tool.ruff.lint.flake8-tidy-imports.banned-api]
+"mock.patch".msg = "Avoid patching state. Pass the dependency explicitly instead."
+"unittest.mock.patch".msg = "Avoid patching state. Pass the dependency explicitly instead."
+```
+
+Project Ruff settings remain authoritative. Use them only when the project
+must change or extend the defaults. For example:
+
+```toml
+[tool.ruff.lint]
+extend-ignore = ["C901"]
+
+[tool.ruff.lint.pylint]
+max-statements = 50
+```
+
+`ignore` and `extend-ignore` disable default rules. Explicit thresholds,
+exclusions, per-file ignores, and `noqa` comments also apply.
+
+If the project defines the `TID251` banned-API table, it replaces the default
+provided by `anti-slop-python`.
+
+Inline `noqa` comments can suppress a recommended Ruff diagnostic, so
+`anti-slop-python` audits them and prints a non-failing policy notice with the
+source location. Ruff exclusions apply to Ruff-backed checks. Native SPY rules
+still check every Python file in the paths passed to `anti-slop-python`; use the
+command paths or pre-commit `files`/`exclude` settings to control that scope.
+
+When an override is weaker than the default policy, `anti-slop-python` prints a
+non-failing policy notice. Stricter settings do not produce a notice. The
+defaults apply only to Ruff runs started by `anti-slop-python`; add the equivalent
+configuration above if a separate `ruff check` command must enforce the same
+policy.
+
+## Why these rules exist
+
+These rules do not identify whether an LLM wrote the code. Humans produce the
+same patterns.
+
+The rules here are an opinionated set of guidelines that cover common issues
+with LLM generated code and are an attempt to reduce the review burden.
+
+An agent can add a large amount of locally plausible code without first "learning" the
+project's types, boundaries, or dependency design. The rules help against some common
+shortcuts LLMs use to make code fulfill an immediate goal while making later changes
+harder to reason about.
+
+The rules also try to encourage better design by pushing back on the most annoying
+things LLMs tend to do like writing massive functions, files with thousands of lines,
+tests that patch and mock everything, etc.
+
+The following are some example rules and why they were added:
+
+### SPY001 — Do not put `Any` in containers
+
+`SPY001` rejects `dict`, `list`, `set`, and `tuple` types parameterized with
+`Any`, including the equivalent aliases from `typing`. A container usually
+carries data across several lines, functions, or layers. Once its element type
+becomes `Any`, every value taken from it escapes useful static checking and can
+spread uncertainty through the rest of the program.
+
+An agent often introduces this pattern when it can see that a value is a list
+or dictionary but has not established the shape of the contents. `Any` makes
+the immediate type error disappear without resolving that missing knowledge.
+The rule forces the implementation to name the real type. A burden you probably
+wouldn't always want for yourself but an LLM can deal with it and maybe produce
+better code because of it.
+
+Ruff's [`ANN401`](https://docs.astral.sh/ruff/rules/any-type/) rule is related
+but does not replace `SPY001`: `ANN401` checks function parameters annotated
+directly with `Any`, while `SPY001` checks for `Any` inside container types such
+as `list[Any]` and `dict[str, Any]`.
+
+### SPY002 — Do not hide attributes behind strings
+
+`SPY002` rejects calls to `getattr()`, `setattr()`, and `delattr()`. Dynamic
+attribute access turns an interface into a runtime string convention. Type
+checkers and refactoring tools have less evidence, misspelled names fail late,
+and a default passed to `getattr()` can hide a missing invariant.
+
+Generated code often uses `getattr(value, "name", None)` to support several
+assumed object shapes without checking which shapes the application actually
+allows. The rule requires direct attribute access for a known interface.
+
+Ruff has related [`B009`](https://docs.astral.sh/ruff/rules/get-attr-with-constant/),
+[`B010`](https://docs.astral.sh/ruff/rules/set-attr-with-constant/), and
+preview-only [`B043`](https://docs.astral.sh/ruff/rules/del-attr-with-constant/)
+rules. They flag `getattr()`, `setattr()`, and `delattr()` only when the
+attribute name is a constant string. They therefore allow calls such as
+`getattr(value, name)`, which may be intentional but still make an interface
+depend on runtime strings. `SPY002` rejects
+the built-ins regardless of whether the name is constant.
+
+### [`C901`](https://docs.astral.sh/ruff/rules/complex-structure/) — Limit decision complexity
+
+`C901` measures the number of paths through a function. Anti-slop-python uses a
+maximum McCabe complexity of 10. A function can be short and still be complex
+when it contains many branches, loops, or exception paths. Each added path
+increases the number of states that a reader and a test suite must consider.
+
+Coding agents tend to tack on more complexity to achieve a goal like making tests pass.
+
+### [`PLR0915`](https://docs.astral.sh/ruff/rules/too-many-statements/) — Limit function size
+
+`PLR0915` rejects functions or methods with more than 40 statements. This
+complements `C901`: a long function can have simple control flow and still do
+too much. 
+
+Generated implementations tend to keep the full requested workflow in one
+function because that is the easiest shape to produce in one pass. The
+statement limit makes things like mixed responsibilities more visible. 
+
+### [`TID251`](https://docs.astral.sh/ruff/rules/banned-api/) — Do not patch dependencies
+
+Ruff's `TID251` rule can ban project-selected APIs. Anti-slop-python uses it to ban
+`unittest.mock.patch` and `mock.patch`. Patching replaces module or object
+state at runtime, so a test depends on where a symbol happens to be imported
+rather than on an explicit interface. Refactoring an import can then break the
+test even when behavior has not changed.
+
+Agents frequently reach for `patch()` because it can isolate almost any call
+without changing production design. There's a tendency to test implementation rather than behavior
+when trying to improve test coverage.
+
+This setting helps a little with directing a clearer interface-based design, although it is generally 
+not enough by itself and LLMs need a lot of direction to get to this kind of design.
+
+### [`E722`](https://docs.astral.sh/ruff/rules/bare-except/) — Do not use bare exception handlers
+
+`E722` rejects a bare `except:` handler. A bare handler catches
+`BaseException`, including `KeyboardInterrupt` and `SystemExit`. It can prevent
+a process from stopping and can disguise failures that the code cannot
+actually recover from.
+
+LLMs tend to be good at building exception handling but occasionally they take shortcuts and 
+this helps avoid that. 
+
+### [`BLE001`](https://docs.astral.sh/ruff/rules/blind-except/) — Do not catch broad exceptions
+
+`BLE001` flags broad named handlers such as `except Exception` and
+`except BaseException` when they handle or swallow the error. 
+
+Ruff permits broad handlers that re-raise and recognized logging patterns 
+that retain the exception trace.
+
+A coding agent may wrap a large generated block in `except Exception` because it
+does not know the operation's failure contract. This setting forces the agent to 
+work through the possible errors and make them clear.
+
+## Usage
+
+Run Ruff and the native checker together on directories or individual Python
+files:
+
+```console
+uvx anti-slop-python .
+uvx anti-slop-python src/
+uvx anti-slop-python src/anti_slop_python/cli.py
+```
+
+Diagnostics use a conventional source format, and any diagnostic makes the
+command exit with status 1:
+
+```text
+src/api/parser.py:41:12 SPY001 Avoid containers parameterized with Any
+src/api/parser.py:45:8 SPY002 Avoid dynamic attribute access
+src/orders/service.py:18:5 C901 `create_order` is too complex (14 > 10)
+```
+
+Policy notices are written to standard error and do not change the exit code:
+
+```text
+anti-slop-python policy notice: C901 is disabled; recommended: enabled
+```
+
+Ruff runs in check-only mode even if the project has `fix = true`.
+
+For local development:
+
+```console
+uv sync --dev
+uv run pre-commit install
+uv run anti-slop-python src tests
+uv run pre-commit run --all-files
+uv run pytest
+uv run ruff format --check .
+uv run ruff check .
+```
+
+## Examples
+
+[`examples/basic_project`](examples/basic_project) is a small Python project
+with intentional native and Ruff-backed violations, plus preferred
+alternatives. This repository's Ruff and pre-commit checks exclude `examples/`;
+its direct self-check targets `src` and `tests`.
+
+Run the example explicitly to see its diagnostics:
+
+```console
+uv run anti-slop-python examples/basic_project
+```
+
+## Scope and limitations
+
+Native checks use Python's built-in `ast` and a pragmatic import alias map.
+They do not perform scope-aware name resolution, type checking, cross-file
+analysis, configuration, suppressions, or autofixes. Ruff-backed checks use
+the project's effective Ruff configuration and suppression behavior.
+
+## License
+
+[MIT](LICENSE)

anti_slop_python-0.1.0.dist-info/RECORD

@@ -0,0 +1,16 @@
+anti_slop_python/__init__.py,sha256=oSNUe5E1IfvjdHknDmnTbQRwHhJhDFM1YhWM2s7ZnEM,243
+anti_slop_python/__main__.py,sha256=yv0XL1KDDfArsZW2K7WnRsrd3yT1QYtfsMpbXdLkYQQ,64
+anti_slop_python/checker.py,sha256=lO2ysGZNC0fHcwuEiaPCkA0rkEGGu2Fnl0ukSiA8BaA,1526
+anti_slop_python/cli.py,sha256=A1EuYu-yNimswzxBUVtm7K4aijRItwzIu7qGJQCRzkw,2566
+anti_slop_python/diagnostics.py,sha256=34UxfZPmUkHl6Oeq1QnGXtKpSFdjGpvH9-3vypUxoUE,403
+anti_slop_python/ruff_integration.py,sha256=W9k5u38AORFU6xuWQYMq97_yIb3QD9X4Ej62Bfju-cc,6646
+anti_slop_python/ruff_policy.py,sha256=8AJv62Xsw8GvrzZxyUBad-tkBLzxf8JuRXm5wf7WfkM,13461
+anti_slop_python/rules/__init__.py,sha256=fVfcMMdM3FHF0VX0Gh2azu725rATRKtLppKw-JhSswk,348
+anti_slop_python/rules/base.py,sha256=eR7GS_-Ays1uZUfRLATpQhvItTDKjxpcnCjtfKPkz9A,2572
+anti_slop_python/rules/no_any_containers.py,sha256=pG3D4nfImnhq3M9zoH3ST-r6qxYK5Ua6RE58cwemPDk,1443
+anti_slop_python/rules/no_dynamic_attribute_access.py,sha256=4b0OEGpXlM_AuoU5lTwlommPNb_BKxvkh990FhnCI3A,779
+anti_slop_python-0.1.0.dist-info/METADATA,sha256=u26KSgk9J7jkudKVwI5niRaqpwfNYF_EPKIRvGP6p4k,13755
+anti_slop_python-0.1.0.dist-info/WHEEL,sha256=zOwg4jB6zX2kU910N-cMawjivD6tO8NEWvE12je1bVk,87
+anti_slop_python-0.1.0.dist-info/entry_points.txt,sha256=2LuCaWUA9_X8B3dT-ccfKZ-prhl7pNwGn9NanzNG9i0,63
+anti_slop_python-0.1.0.dist-info/licenses/LICENSE,sha256=-DUrK07cTAr9HVwvRNoUZHJc9gfE2X-CuFkrIG5FvjQ,1072
+anti_slop_python-0.1.0.dist-info/RECORD,,

anti_slop_python-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.32.0
+Root-Is-Purelib: true
+Tag: py3-none-any

anti_slop_python-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+anti-slop-python = anti_slop_python.cli:main

anti_slop_python-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Ruairí O'Brien
+
+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.