sarj-python-lint 0.11.0__tar.gz → 0.11.1__tar.gz

{sarj_python_lint-0.11.0 → sarj_python_lint-0.11.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sarj-python-lint
-Version: 0.11.0
+Version: 0.11.1
 Summary: Custom Python lint rules — AST-based, pre-commit-friendly, hypermodern defaults
 Project-URL: Homepage, https://github.com/sarj-ai/standards/tree/main/packages/python
 Project-URL: Repository, https://github.com/sarj-ai/standards

{sarj_python_lint-0.11.0 → sarj_python_lint-0.11.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "sarj-python-lint"
-version = "0.11.0"
+version = "0.11.1"
 description = "Custom Python lint rules — AST-based, pre-commit-friendly, hypermodern defaults"
 readme = "README.md"
 authors = [{ name = "sarj-ai" }]

{sarj_python_lint-0.11.0 → sarj_python_lint-0.11.1}/src/sarj_python_lint/rules/_registry.py

@@ -5,8 +5,6 @@ from typing import TYPE_CHECKING
 from sarj_python_lint.rules.inefficient_string_concat_in_loop import (
     InefficientStringConcatInLoop,
 )
-from sarj_python_lint.rules.json_response_not_parsed import JsonResponseNotParsed
-from sarj_python_lint.rules.len_as_truthiness import LenAsTruthiness
 from sarj_python_lint.rules.no_aggregation_in_store_query import (
     NoAggregationInStoreQuery,
 )
@@ -17,7 +15,6 @@ from sarj_python_lint.rules.no_cors_wildcard_with_credentials import (
 from sarj_python_lint.rules.no_fat_try_blocks import NoFatTryBlocks
 from sarj_python_lint.rules.no_fstring_in_log import NoFstringInLog
 from sarj_python_lint.rules.no_isinstance_union_chain import NoIsinstanceUnionChain
-from sarj_python_lint.rules.no_manual_log_prefix import NoManualLogPrefix
 from sarj_python_lint.rules.no_offset_pagination import NoOffsetPagination
 from sarj_python_lint.rules.no_query_with_many_joins import NoQueryWithManyJoins
 from sarj_python_lint.rules.no_repeated_string_literal import NoRepeatedStringLiteral
@@ -64,10 +61,7 @@ REGISTRY: dict[str, type[Rule]] = {
     NoIsinstanceUnionChain.id: NoIsinstanceUnionChain,
     NoOffsetPagination.id: NoOffsetPagination,
     PreferNamedtupleOverTupleReturn.id: PreferNamedtupleOverTupleReturn,
-    LenAsTruthiness.id: LenAsTruthiness,
     NoCorsWildcardWithCredentials.id: NoCorsWildcardWithCredentials,
-    NoManualLogPrefix.id: NoManualLogPrefix,
-    JsonResponseNotParsed.id: JsonResponseNotParsed,
     NoSleepInTestBody.id: NoSleepInTestBody,
     PydanticAtBoundaries.id: PydanticAtBoundaries,
     NoSentinelReturnOnExcept.id: NoSentinelReturnOnExcept,

sarj_python_lint-0.11.0/src/sarj_python_lint/rules/json_response_not_parsed.py

@@ -1,110 +0,0 @@
-"""SARJ030: flag an external JSON payload consumed untyped.
-
-A `.json()` call (no args) or a `json.loads(...)` / `json.load(...)` result used
-*directly* — subscripted (`["k"]`), `.get(...)`-ed, or attribute-chained — reaches
-into an external payload's shape without ever parsing it into a pydantic model.
-When the vendor changes that shape the access breaks silently at runtime instead
-of at a validated boundary.
-
-    resp.json()["access_token"]        # fires
-    resp.json().get("data")            # fires
-    (await client.get(u)).json()["k"]  # fires
-    json.loads(body)["id"]             # fires
-
-Parse the payload first: `Token.model_validate(resp.json())`, then read typed
-attributes off the model.
-
-This is an access-shape signal, distinct from the annotation-based SARJ008 /
-ANN401 (`dict[str, Any]` parameters): those catch an untyped *type*, this catches
-an untyped *use* of a live external response with no annotation at all.
-
-Deliberately NOT flagged (keeps false positives at zero):
-- assign-then-subscript (`d = resp.json(); d["k"]`) — only DIRECT chaining off the
-  `.json()` / `json.loads()` call is tracked; a bound name could be anything,
-- a `.json(...)` call WITH arguments — that receiver is not the payload accessor,
-- the payload passed to a parser (`Model.model_validate(resp.json())`) rather than
-  subscripted — that IS the parse we want,
-- a plain dict/list literal subscript (`{"a": 1}["a"]`),
-- a bare `.json` attribute that is never called, and `json.dumps(...)`.
-"""
-
-from __future__ import annotations
-
-import ast
-from typing import TYPE_CHECKING, override
-
-from sarj_python_lint.rule_base import Diagnostic, Rule, parse_or_none
-
-
-if TYPE_CHECKING:
-    from pathlib import Path
-
-
-class JsonResponseNotParsed(Rule):
-    """External JSON payload consumed untyped instead of parsed into a model."""
-
-    id: str = "json-response-not-parsed"
-    code: str = "SARJ030"
-    description: str = (
-        "A `.json()` / `json.loads()` result is subscripted, `.get()`-ed, or "
-        "attribute-chained directly — parse it into a pydantic model first."
-    )
-
-    @override
-    def check(self, path: Path, source: str) -> list[Diagnostic]:
-        tree = parse_or_none(path, source)
-        if tree is None:
-            return []
-        diags: list[Diagnostic] = []
-        for node in ast.walk(tree):
-            value = _direct_accessed_value(node)
-            if value is None or not _is_json_payload_call(value):
-                continue
-            diags.append(
-                Diagnostic(
-                    path=path,
-                    line=node.lineno,
-                    col=node.col_offset + 1,
-                    code=self.code,
-                    message=(
-                        "External JSON payload consumed untyped — parse the "
-                        "`.json()` / `json.loads()` result into a pydantic model "
-                        "before subscripting or attribute access."
-                    ),
-                )
-            )
-        diags.sort(key=lambda d: (d.line, d.col))
-        return diags
-
-
-def _direct_accessed_value(node: ast.AST) -> ast.expr | None:
-    """The receiver being read off, if `node` reaches directly into a value.
-
-    Covers the three access shapes — `<value>[...]` (Subscript), `<value>.attr`
-    (Attribute, which also covers `<value>.get(...)` since `.get` is an
-    attribute), and nothing else. Returns the `<value>` expression, or None.
-    """
-    if isinstance(node, ast.Subscript):
-        return node.value
-    if isinstance(node, ast.Attribute):
-        return node.value
-    return None
-
-
-def _is_json_payload_call(node: ast.expr) -> bool:
-    """True for a JSON-payload-producing call: `<x>.json()` with NO args, or
-    `json.loads(...)` / `json.load(...)`.
-
-    A `.json(...)` call with any positional or keyword argument is not the payload
-    accessor and is skipped.
-    """
-    if not isinstance(node, ast.Call):
-        return False
-    func = node.func
-    if not isinstance(func, ast.Attribute):
-        return False
-    if func.attr == "json":
-        return not node.args and not node.keywords
-    if func.attr in {"loads", "load"}:
-        return isinstance(func.value, ast.Name) and func.value.id == "json"
-    return False

sarj_python_lint-0.11.0/src/sarj_python_lint/rules/len_as_truthiness.py

@@ -1,126 +0,0 @@
-"""SARJ027: flag `len(x) <cmp> 0|1` comparisons that are just a truthiness test.
-
-Six zero-boundary forms of `len(x)` compared against `0` or `1` are exactly
-equivalent to testing the container's truthiness — an empty container is falsy,
-a non-empty one is truthy:
-
-    len(x) == 0   ->  not x
-    len(x) < 1    ->  not x
-    len(x) <= 0   ->  not x
-    len(x) != 0   ->  x
-    len(x) > 0    ->  x
-    len(x) >= 1   ->  x
-
-`len(x)` allocates nothing but reads as size arithmetic; the truthiness form is
-shorter and states the intent. pylint shipped this as C1802/C1803 but neither
-check was ever ported to ruff, so it is genuinely uncovered.
-
-Deliberately NOT flagged — these are real size checks, not truthiness:
-- exact-count / other-boundary comparisons (`len(x) == 1`, `>= 2`, `> 1`, `< 2`,
-  `== 3`, ...); only the six zero-boundary forms above collapse to truthiness,
-- a right-hand constant other than `0`/`1` (or a bool literal `True`/`False`),
-- anything that is not literally `len(<one expr>)` on the left — a different
-  builtin (`count(x) == 0`), `len` with 0/2+ args, or `len` called via attribute,
-- chained comparisons (`0 < len(x) < 5`) — more than one operator,
-- `x == []` / `x == {}` — a different check (it excludes `None`; see the
-  separate empty-collection-literal rule).
-
-The yoda form `0 == len(x)` is intentionally not handled (rare; would widen the
-signal for little gain).
-
-References:
-- https://pylint.readthedocs.io/en/latest/user_guide/messages/refactor/use-implicit-booleaness-not-len.html
-"""
-
-from __future__ import annotations
-
-import ast
-from typing import TYPE_CHECKING, override
-
-from sarj_python_lint.rule_base import Diagnostic, Rule, parse_or_none
-
-
-if TYPE_CHECKING:
-    from pathlib import Path
-
-
-# (comparison-operator type, right-hand int constant) pairs that are equivalent to a
-# plain truthiness test, mapped to the truthy suggestion ("x") or falsy one ("not x").
-_TRUTHINESS_FORMS: dict[tuple[type[ast.cmpop], int], str] = {
-    (ast.Eq, 0): "not x",
-    (ast.Lt, 1): "not x",
-    (ast.LtE, 0): "not x",
-    (ast.NotEq, 0): "x",
-    (ast.Gt, 0): "x",
-    (ast.GtE, 1): "x",
-}
-
-
-class LenAsTruthiness(Rule):
-    """`len(x) <cmp> 0|1` zero-boundary comparisons — prefer a plain truthiness test."""
-
-    id: str = "len-as-truthiness"
-    code: str = "SARJ027"
-    description: str = (
-        "len(x) compared against 0/1 at a zero boundary is a truthiness test — "
-        "use `x` / `not x` instead of `len(x)`."
-    )
-
-    @override
-    def check(self, path: Path, source: str) -> list[Diagnostic]:
-        tree = parse_or_none(path, source)
-        if tree is None:
-            return []
-        diags: list[Diagnostic] = []
-        for node in ast.walk(tree):
-            if not isinstance(node, ast.Compare):
-                continue
-            suggestion = _truthiness_suggestion(node)
-            if suggestion is None:
-                continue
-            diags.append(
-                Diagnostic(
-                    path=path,
-                    line=node.lineno,
-                    col=node.col_offset + 1,
-                    code=self.code,
-                    message=(
-                        f"len(...) compared against a zero boundary is a truthiness "
-                        f"test — use `{suggestion}` instead of `len(...)`."
-                    ),
-                )
-            )
-        diags.sort(key=lambda d: (d.line, d.col))
-        return diags
-
-
-def _truthiness_suggestion(node: ast.Compare) -> str | None:
-    """The `x`/`not x` suggestion if `node` is a zero-boundary `len(...)` compare, else None."""
-    if len(node.ops) != 1 or len(node.comparators) != 1:
-        return None
-    if not _is_len_call(node.left):
-        return None
-    const = _int_constant(node.comparators[0])
-    if const is None:
-        return None
-    return _TRUTHINESS_FORMS.get((type(node.ops[0]), const))
-
-
-def _is_len_call(expr: ast.expr) -> bool:
-    """True iff `expr` is literally `len(<single positional expr>)`."""
-    if not isinstance(expr, ast.Call):
-        return False
-    if not (isinstance(expr.func, ast.Name) and expr.func.id == "len"):
-        return False
-    if len(expr.args) != 1 or expr.keywords:
-        return False
-    return not isinstance(expr.args[0], ast.Starred)
-
-
-def _int_constant(expr: ast.expr) -> int | None:
-    """The int value of a plain integer literal, else None. Bool literals are excluded."""
-    if not isinstance(expr, ast.Constant):
-        return None
-    if type(expr.value) is not int:
-        return None
-    return expr.value

sarj_python_lint-0.11.0/src/sarj_python_lint/rules/no_manual_log_prefix.py

@@ -1,146 +0,0 @@
-"""SARJ029: flag a manual `"[Component] ..."` bracket tag in a logging message.
-
-The house logging style is structured: identify the emitting component with a
-bound field so aggregators can filter on it, rather than baking the label into
-the message text where it can only be grepped:
-
-    # flagged
-    logger.info("[STT] transcription finished")
-
-    # preferred
-    logger.bind(component="STT").info("transcription finished")
-
-A leading `[Tag]` in the literal message duplicates context that belongs in
-structured metadata and fragments template grouping. This is distinct from
-SARJ017 (no-fstring-in-log) / ruff G004, which fire only on *interpolating*
-f-strings; the messages caught here are plain string literals.
-
-To keep false positives near zero the rule requires BOTH a logger-like receiver
-(resolved through builder/factory chains via `is_logger_expr`) AND a logging
-method name, and only inspects the message argument (arg 1 for
-`logger.log(LEVEL, msg)`, arg 0 otherwise).
-
-The bracket tag must be a *component* label, not incidental data. The match
-pattern allows only letters, spaces, underscores and hyphens inside the
-brackets and requires at least one letter, so data-shaped brackets never match:
-`[Errno 2]` (digit), `[1, 2]` (digit/comma), `['a', 'b']` (quotes/comma),
-`[12:34]` (colon) are all excluded, while `[STT]`, `[TTS Pronunciation]` and
-`[AgentDispatch]` match. Empirically this matches 0 data brackets across the
-bulbul (273 hits) and noura (24 hits) corpora.
-
-Suppress an intentional case with `# sarj-noqa: SARJ029 — <reason>`.
-"""
-
-from __future__ import annotations
-
-import ast
-import re
-from typing import TYPE_CHECKING, override
-
-from sarj_python_lint.rule_base import Diagnostic, Rule, parse_or_none
-from sarj_python_lint.rules._logging import is_logger_expr
-
-
-if TYPE_CHECKING:
-    from pathlib import Path
-
-
-_LOG_METHODS = frozenset(
-    {
-        "debug",
-        "info",
-        "warning",
-        "warn",
-        "error",
-        "exception",
-        "critical",
-        "fatal",
-        "trace",
-        "success",
-        "log",
-    }
-)
-
-_PREFIX_RE = re.compile(r"^\[[A-Za-z_ -]*[A-Za-z][A-Za-z_ -]*\]")
-
-_LOG_LEVEL_AND_MESSAGE_ARGC = 2
-
-
-class NoManualLogPrefix(Rule):
-    """Manual `[Component]` prefix in a logging message — bind it as structured context."""
-
-    id: str = "no-manual-log-prefix"
-    code: str = "SARJ029"
-    description: str = (
-        "manual '[Component]' prefix in a logging message — bind the component as "
-        "structured context (logger.bind(component=...)) so aggregators filter on a "
-        "field instead of grepping baked-in text."
-    )
-
-    @override
-    def check(self, path: Path, source: str) -> list[Diagnostic]:
-        tree = parse_or_none(path, source)
-        if tree is None:
-            return []
-        diags: list[Diagnostic] = []
-        for node in ast.walk(tree):
-            if not isinstance(node, ast.Call) or not _is_logging_call(node):
-                continue
-            message = _message_arg(node)
-            if message is None:
-                continue
-            leading = _leading_static_str(message)
-            if leading is None or not _PREFIX_RE.match(leading):
-                continue
-            diags.append(
-                Diagnostic(
-                    path=path,
-                    line=node.lineno,
-                    col=node.col_offset + 1,
-                    code=self.code,
-                    message=(
-                        "manual '[Component]' prefix in a logging message — bind it as "
-                        "structured context (logger.bind(component=...)) instead."
-                    ),
-                )
-            )
-        diags.sort(key=lambda d: (d.line, d.col))
-        return diags
-
-
-def _is_logging_call(node: ast.Call) -> bool:
-    func = node.func
-    if not isinstance(func, ast.Attribute) or func.attr not in _LOG_METHODS:
-        return False
-    return is_logger_expr(func.value)
-
-
-def _message_arg(node: ast.Call) -> ast.expr | None:
-    """The message argument: index 1 for `logger.log(LEVEL, msg)`, else index 0.
-
-    A `.log` call carrying fewer than two positionals has no message argument (the
-    lone positional is the level), so there is nothing to inspect.
-    """
-    if isinstance(node.func, ast.Attribute) and node.func.attr == "log":
-        return node.args[1] if len(node.args) >= _LOG_LEVEL_AND_MESSAGE_ARGC else None
-    return node.args[0] if node.args else None
-
-
-def _leading_static_str(node: ast.expr) -> str | None:
-    """The leading static string of a message expr, or None if there isn't one.
-
-    Handles a bare string literal, the leading literal chunk of an f-string, and
-    the left operand of a `+`-concatenation (recursively), so a baked-in prefix
-    is found even when the value is later interpolated or concatenated.
-    """
-    match node:
-        case ast.Constant(value=str() as value):
-            return value
-        case ast.JoinedStr(values=[ast.Constant(value=str() as value), *_]):
-            return value
-        case ast.JoinedStr():
-            return None
-        case ast.BinOp(op=ast.Add(), left=left):
-            return _leading_static_str(left)
-        case _:
-            return None