sarj-python-lint 1.27.1__tar.gz → 1.27.3__tar.gz

{sarj_python_lint-1.27.1 → sarj_python_lint-1.27.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: sarj-python-lint
-Version: 1.27.1
+Version: 1.27.3
 Summary: Custom Python lint rules — AST-based, pre-commit-friendly, hypermodern defaults
 Project-URL: Homepage, https://code-standards.sarj.ai/rules/python/
 Project-URL: Documentation, https://code-standards.sarj.ai/rules/python/

{sarj_python_lint-1.27.1 → sarj_python_lint-1.27.3}/pyproject.toml

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

{sarj_python_lint-1.27.1 → sarj_python_lint-1.27.3}/src/sarj_python_lint/interpreter_argv.py

@@ -85,18 +85,20 @@ class UnprovableCommandError(ValueError):
     """A wrapper executable position cannot be established safely."""
 
 
-def unwrap_command(argv: Sequence[str]) -> tuple[str, ...]:
+def unwrap_command(
+    argv: Sequence[str], *, allow_shell_builtins: bool = True, allowed_wrappers: frozenset[str] | None = None
+) -> tuple[str, ...]:
     current = tuple(argv)
     for _ in range(_MAX_WRAPPERS):
         if not current:
             return ()
         command = PurePosixPath(current[0]).name
-        if command in {"exec", "command"}:
+        if allow_shell_builtins and command in {"exec", "command"}:
             if command == "command" and any(argument in {"-v", "-V"} for argument in current[1:2]):
                 return current
             current = current[_command_wrapper_index(current, command) :]
             continue
-        if command not in _WRAPPER_VALUES:
+        if command not in _WRAPPER_VALUES or (allowed_wrappers is not None and command not in allowed_wrappers):
             return current
         current = current[_value_wrapper_index(current, command) :]
     msg = "command wrapper nesting exceeds analysis bound"
@@ -120,25 +122,69 @@ def _command_wrapper_index(arguments: Sequence[str], command: str) -> int:
 
 
 def _value_wrapper_index(arguments: Sequence[str], command: str) -> int:
+    if command == "env":
+        return _env_wrapper_index(arguments)
     index = 1
     while index < len(arguments):
         argument = arguments[index]
         if argument == "--":
             index += 1
             break
-        if command == "env" and re.match(r"^[A-Za-z_][A-Za-z0-9_]*=", argument):
-            index += 1
-            continue
         if not argument.startswith("-") or argument == "-":
             break
-        if command == "env" and argument in {"-S", "--split-string"}:
-            msg = "env split-string has a separate unproven quoting grammar"
-            raise UnprovableCommandError(msg)
         index += 2 if argument in _WRAPPER_VALUES[command] else 1
     # Timeout's positional duration precedes its executable.
     return index + int(command == "timeout")
 
 
+def _env_wrapper_index(arguments: Sequence[str]) -> int:
+    index = 1
+    while index < len(arguments) and arguments[index].startswith("-"):
+        argument = arguments[index]
+        if argument == "-":
+            index += 1
+            break
+        if argument == "--":
+            index += 1
+            break
+        index += _env_option_size(arguments, index)
+    # Assignments follow options, including after --; later option-looking words
+    # are executable operands, not additional env options.
+    while index < len(arguments) and "=" in arguments[index]:
+        if arguments[index].startswith("="):
+            msg = "env assignment requires a nonempty variable name"
+            raise UnprovableCommandError(msg)
+        index += 1
+    return index
+
+
+def _env_option_size(arguments: Sequence[str], index: int) -> int:
+    argument = arguments[index]
+    if argument in {"--help", "--version"}:
+        return len(arguments) - index  # GNU env terminates without executing operands.
+    if argument in {"-S", "--split-string"} or argument.startswith(("-S", "--split-string=")):
+        msg = "env split-string has a separate unproven quoting grammar"
+        raise UnprovableCommandError(msg)
+    if argument in {"-i", "--ignore-environment", "-v", "--debug"}:
+        return 1
+    if argument in _WRAPPER_VALUES["env"]:
+        value = arguments[index + 1] if index + 1 < len(arguments) else ""
+        _validate_env_operand(argument, value)
+        return 2
+    for option in ("--unset=", "--chdir=", "-u", "-C"):
+        if argument.startswith(option):
+            _validate_env_operand(option, argument[len(option) :])
+            return 1
+    msg = "unsupported env wrapper option"
+    raise UnprovableCommandError(msg)
+
+
+def _validate_env_operand(option: str, value: str) -> None:
+    if not value or (option in {"-u", "--unset", "--unset="} and "=" in value):
+        msg = "env option requires a valid value"
+        raise UnprovableCommandError(msg)
+
+
 def is_python_executable(executable: str) -> bool:
     return re.fullmatch(r"python(?:[23](?:\.\d+)?)?", PurePosixPath(executable).name) is not None
 
@@ -175,6 +221,11 @@ def _python(arguments: Sequence[str]) -> InterpreterInvocation:
         if boundary is not None:
             return boundary
         argument = arguments[index]
+        if argument == "--check-hash-based-pycs":
+            if _following_operand(arguments, index) not in {"default", "always", "never"}:
+                return InterpreterInvocation("unknown")
+            index += 2
+            continue
         if argument.startswith("--"):
             return InterpreterInvocation(
                 "external"

{sarj_python_lint-1.27.1 → sarj_python_lint-1.27.3}/src/sarj_python_lint/rules/require_injectable_retry_sleep.py

@@ -29,7 +29,7 @@ _POLICIES: Final = frozenset(
 )
 _WAIT_MODULES: Final = frozenset({"tenacity", "tenacity.wait"})
 _WALL_CLOCK_SLEEPS: Final = frozenset(
-    {"asyncio.sleep", "anyio.sleep", "trio.sleep", "time.sleep", "tenacity.nap.sleep"}
+    {"asyncio.sleep", "anyio.sleep", "trio.sleep", "time.sleep", "tenacity.sleep", "tenacity.nap.sleep"}
 )
 _MESSAGE: Final = (
     "this tenacity policy waits between attempts on the wall clock without a sleep= seam; pass an injected sleep "
@@ -58,8 +58,8 @@ class RequireInjectableRetrySleep(Rule):
         autofix=AutofixPolicy.NONE,
         limitations=(
             "Only calls to tenacity.retry, tenacity.Retrying, and tenacity.AsyncRetrying resolved through imports are inspected; bare @retry, positional arguments, and **kwargs expansion abstain.",
-            "A wait is reported only when it is built inline from tenacity wait_* calls, optionally combined with +; wait_none() and wait_fixed(0) do not wait. A wait read from a name, attribute, or other call is treated as injected.",
-            "Any sleep= argument other than a wall-clock sleep imported from asyncio, anyio, trio, time, or tenacity.nap counts as a seam; the rule does not prove that tests replace it.",
+            "A wait is reported only when it is built inline from tenacity wait_* calls, optionally combined with +; wait_none(), literal-zero wait_fixed and wait_random calls, and known zero-only wait_combine or wait_chain calls do not wait. A wait read from a name, attribute, or other call is treated as injected.",
+            "Any sleep= argument other than a wall-clock sleep imported from asyncio, anyio, trio, time, tenacity, or tenacity.nap counts as a seam; the rule does not prove that tests replace it.",
             "The backoff library has no sleep parameter, so its decorators are not inspected. Test modules, test directories, conftest.py, test-support paths, and generated files are excluded.",
         ),
         examples=(
@@ -143,20 +143,55 @@ def _waits_without_seam(call: ast.Call, imports: ImportIndex) -> bool:
 def _wait_strategy(node: ast.expr, imports: ImportIndex) -> bool | None:
     match node:
         case ast.BinOp(left=left, op=ast.Add(), right=right):
-            parts = (_wait_strategy(left, imports), _wait_strategy(right, imports))
-            return None if None in parts else any(parts)
+            return _combined_waits((left, right), imports)
         case ast.Call(func=func, args=args, keywords=keywords):
             module, _, strategy = (imports.resolved_qualified_name(func) or "").rpartition(".")
             if module not in _WAIT_MODULES or not strategy.startswith("wait_"):
                 return None
-            match strategy, args, keywords:
-                case "wait_none", [], []:
-                    return False
-                case "wait_fixed", [ast.Constant(value=0)], []:
-                    return False
-                case "wait_fixed", [], [ast.keyword(arg="wait", value=ast.Constant(value=0))]:
-                    return False
-                case _:
-                    return True
+            return _wait_constructor(strategy, args, keywords, imports)
         case _:
             return None
+
+
+def _wait_constructor(
+    strategy: str, args: list[ast.expr], keywords: list[ast.keyword], imports: ImportIndex
+) -> bool | None:
+    match strategy, args, keywords:
+        case "wait_none", [], []:
+            return False
+        case ("wait_fixed", [value], []) | ("wait_fixed", [], [ast.keyword(arg="wait", value=value)]):
+            return not _literal_zero(value)
+        case "wait_random", _, _:
+            return _random_waits(args, keywords)
+        case "wait_combine" | "wait_chain", _, _:
+            if keywords or any(isinstance(argument, ast.Starred) for argument in args):
+                return None
+            if strategy == "wait_chain" and not args:
+                return None
+            return _combined_waits(tuple(args), imports)
+        case _:
+            return True
+
+
+def _combined_waits(nodes: tuple[ast.expr, ...], imports: ImportIndex) -> bool | None:
+    parts = tuple(_wait_strategy(node, imports) for node in nodes)
+    return None if None in parts else any(parts)
+
+
+def _random_waits(args: list[ast.expr], keywords: list[ast.keyword]) -> bool | None:
+    names = ("min", "max")
+    if len(args) > len(names) or any(isinstance(argument, ast.Starred) for argument in args):
+        return None
+    values = dict(zip(names, args, strict=False))
+    for keyword in keywords:
+        if keyword.arg not in names or keyword.arg in values:
+            return None
+        values[keyword.arg] = keyword.value
+    return not (("min" not in values or _literal_zero(values["min"])) and _literal_zero(values.get("max")))
+
+
+def _literal_zero(node: ast.expr | None) -> bool:
+    if isinstance(node, ast.UnaryOp) and isinstance(node.op, (ast.UAdd, ast.USub)):
+        operand = node.operand
+        return isinstance(operand, ast.Constant) and isinstance(operand.value, (int, float)) and operand.value == 0
+    return isinstance(node, ast.Constant) and node.value == 0