flake8-async 25.3.1__tar.gz → 25.4.2__tar.gz

{flake8_async-25.3.1 → flake8_async-25.4.2}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.4
 Name: flake8-async
-Version: 25.3.1
+Version: 25.4.2
 Summary: A highly opinionated flake8 plugin for Trio-related problems.
 Author: Zac Hatfield-Dodds, John Litborn, and Contributors
 Author-email: zac@zhd.dev

{flake8_async-25.3.1 → flake8_async-25.4.2}/flake8_async/__init__.py

@@ -38,7 +38,7 @@ if TYPE_CHECKING:
 
 
 # CalVer: YY.month.patch, e.g. first release of July 2022 == "22.7.1"
-__version__ = "25.3.1"
+__version__ = "25.4.2"
 
 
 # taken from https://github.com/Zac-HD/shed

{flake8_async-25.3.1 → flake8_async-25.4.2}/flake8_async/visitors/helpers.py

@@ -6,6 +6,7 @@ Also contains the decorator definitions used to register error classes.
 from __future__ import annotations
 
 import ast
+from dataclasses import dataclass
 from fnmatch import fnmatch
 from typing import TYPE_CHECKING, NamedTuple, TypeVar, Union
 
@@ -287,11 +288,20 @@ cancel_scope_names = (
 )
 
 
+@dataclass
+class MatchingCall:
+    node: ast.Call
+    name: str
+    base: str
+
+    def __str__(self) -> str:
+        return self.base + "." + self.name
+
+
 # convenience function used in a lot of visitors
-# should probably return a named tuple
 def get_matching_call(
     node: ast.AST, *names: str, base: Iterable[str] = ("trio", "anyio")
-) -> tuple[ast.Call, str, str] | None:
+) -> MatchingCall | None:
     if isinstance(base, str):
         base = (base,)
     if (
@@ -301,7 +311,7 @@ def get_matching_call(
         and node.func.value.id in base
         and node.func.attr in names
     ):
-        return node, node.func.attr, node.func.value.id
+        return MatchingCall(node, node.func.attr, node.func.value.id)
     return None
 
 

{flake8_async-25.3.1 → flake8_async-25.4.2}/flake8_async/visitors/visitor102_120.py

@@ -34,7 +34,7 @@ class Visitor102(Flake8AsyncVisitor):
     }
 
     class TrioScope:
-        def __init__(self, node: ast.Call, funcname: str, _):
+        def __init__(self, node: ast.Call, funcname: str):
             super().__init__()
             self.node = node
             self.funcname = funcname
@@ -126,7 +126,7 @@ class Visitor102(Flake8AsyncVisitor):
             if call is None:
                 continue
 
-            trio_scope = self.TrioScope(*call)
+            trio_scope = self.TrioScope(call.node, call.name)
             # check if it's saved in a variable
             if isinstance(item.optional_vars, ast.Name):
                 trio_scope.variable_name = item.optional_vars.id

{flake8_async-25.3.1 → flake8_async-25.4.2}/flake8_async/visitors/visitor103_104.py

@@ -199,6 +199,24 @@ class Visitor103_104(Flake8AsyncVisitor):
         # if body didn't raise, or it's unraised after else, set unraise
         self.unraised = not body_raised or self.unraised
 
+    def visit_Match(self, node: ast.Match):  # type: ignore[name-defined]
+        if not self.unraised:
+            return
+        all_cases_raise = True
+        has_fallback = False
+        for case in node.cases:
+            # check for "bare pattern", i.e `case varname:`
+            has_fallback |= (
+                case.guard is None
+                and isinstance(case.pattern, ast.MatchAs)  # type: ignore[attr-defined]
+                and case.pattern.pattern is None
+            )
+            self.visit_nodes(case.body)
+            all_cases_raise &= not self.unraised
+            self.unraised = True
+
+        self.unraised = not (all_cases_raise and has_fallback)
+
     # A loop is guaranteed to raise if:
     # condition always raises, or
     #   else always raises, and

{flake8_async-25.3.1 → flake8_async-25.4.2}/flake8_async/visitors/visitor91x.py

@@ -198,6 +198,22 @@ class TryState:
         )
 
 
+@dataclass
+class MatchState:
+    # TryState, LoopState, and MatchState all do fairly similar things. It would be nice
+    # to harmonize them and share logic.
+    base_uncheckpointed_statements: set[Statement] = field(default_factory=set)
+    case_uncheckpointed_statements: set[Statement] = field(default_factory=set)
+    has_fallback: bool = False
+
+    def copy(self):
+        return MatchState(
+            base_uncheckpointed_statements=self.base_uncheckpointed_statements.copy(),
+            case_uncheckpointed_statements=self.case_uncheckpointed_statements.copy(),
+            has_fallback=self.has_fallback,
+        )
+
+
 def checkpoint_statement(library: str) -> cst.SimpleStatementLine:
     # logic before this should stop code from wanting to insert the non-existing
     # asyncio.lowlevel.checkpoint
@@ -373,6 +389,7 @@ class Visitor91X(Flake8AsyncVisitor_cst, CommonVisitors):
 
         self.loop_state = LoopState()
         self.try_state = TryState()
+        self.match_state = MatchState()
 
         # ASYNC100
         self.has_checkpoint_stack: list[bool] = []
@@ -500,7 +517,7 @@ class Visitor91X(Flake8AsyncVisitor_cst, CommonVisitors):
 
         # visit body
         # we're not gonna get FlattenSentinel or RemovalSentinel
-        self.new_body = cast(cst.BaseSuite, node.body.visit(self))
+        self.new_body = cast("cst.BaseSuite", node.body.visit(self))
 
         # we know that leave_FunctionDef for this FunctionDef will run immediately after
         # this function exits so we don't need to worry about save_state for new_body
@@ -894,6 +911,55 @@ class Visitor91X(Flake8AsyncVisitor_cst, CommonVisitors):
         self.leave_If(node, node)  # type: ignore
         return False  # libcst shouldn't visit subnodes again
 
+    def leave_Match_subject(self, node: cst.Match) -> None:
+        # We start the match logic after parsing the subject, instead of visit_Match,
+        # since the subject is always executed and might checkpoint.
+        if not self.async_function:
+            return
+        self.save_state(node, "match_state", copy=True)
+        self.match_state = MatchState(
+            base_uncheckpointed_statements=self.uncheckpointed_statements.copy()
+        )
+
+    def visit_MatchCase(self, node: cst.MatchCase) -> None:
+        # enter each case from the state after parsing the subject
+        self.uncheckpointed_statements = self.match_state.base_uncheckpointed_statements
+
+    def leave_MatchCase_guard(self, node: cst.MatchCase) -> None:
+        # `case _:` is no pattern and no guard, which means we know body is executed.
+        # But we also know that `case _ if <guard>:` is guaranteed to execute the guard,
+        # so for later logic we can treat them the same *if* there's no pattern and that
+        # guard checkpoints.
+        if (
+            isinstance(node.pattern, cst.MatchAs)
+            and node.pattern.pattern is None
+            and (node.guard is None or not self.uncheckpointed_statements)
+        ):
+            self.match_state.has_fallback = True
+
+    def leave_MatchCase(
+        self, original_node: cst.MatchCase, updated_node: cst.MatchCase
+    ) -> cst.MatchCase:
+        # collect the state at the end of each case
+        self.match_state.case_uncheckpointed_statements.update(
+            self.uncheckpointed_statements
+        )
+        return updated_node
+
+    def leave_Match(
+        self, original_node: cst.Match, updated_node: cst.Match
+    ) -> cst.Match:
+        # leave the Match with the worst-case of all branches
+        self.uncheckpointed_statements = self.match_state.case_uncheckpointed_statements
+        # if no fallback, also add the state at entering the match (after parsing subject)
+        if not self.match_state.has_fallback:
+            self.uncheckpointed_statements.update(
+                self.match_state.base_uncheckpointed_statements
+            )
+
+        self.restore_state(original_node)
+        return updated_node
+
     def visit_While(self, node: cst.While | cst.For):
         self.save_state(
             node,

{flake8_async-25.3.1 → flake8_async-25.4.2}/flake8_async/visitors/visitor_utility.py

@@ -17,7 +17,7 @@ if TYPE_CHECKING:
     from re import Match
 
     import libcst as cst
-    from libcst._position import CodeRange
+    from libcst.metadata import CodeRange
 
 
 @utility_visitor

{flake8_async-25.3.1 → flake8_async-25.4.2}/flake8_async/visitors/visitors.py

@@ -287,8 +287,7 @@ class Visitor115(Flake8AsyncVisitor):
             and isinstance(node.args[0], ast.Constant)
             and node.args[0].value == 0
         ):
-            # m[2] is set to node.func.value.id
-            self.error(node, m[2])
+            self.error(node, m.base)
 
 
 @error_class
@@ -326,7 +325,7 @@ class Visitor116(Flake8AsyncVisitor):
                     and arg.value > 86400
                 )
             ):
-                self.error(node, m[2])
+                self.error(node, m.base)
 
 
 @error_class
@@ -452,7 +451,49 @@ class Visitor122(Flake8AsyncVisitor):
                 node, "fail_after", "move_on_after", base=("trio", "anyio")
             )
         ):
-            self.error(node, f"{match[2]}.{match[1]}")
+            self.error(node, str(match))
+
+
+@error_class
+class Visitor125(Flake8AsyncVisitor):
+    error_codes: Mapping[str, str] = {
+        "ASYNC125": (
+            "Using {} with a constant value is nonsensical, as the value is relative "
+            "to the runner clock. Use ``fail_after(...)``, ``move_on_after(...)``, "
+            "``CancelScope(relative_deadline=...)`` or calculate it relative to "
+            "``{}.current_time()``."
+        )
+    }
+
+    def visit_Call(self, node: ast.Call):
+        def is_constant(value: ast.expr) -> bool:
+            if isinstance(value, ast.Constant):
+                return True
+            if isinstance(value, ast.BinOp):
+                return is_constant(value.left) and is_constant(value.right)
+            return False
+
+        match = get_matching_call(
+            node, "fail_at", "move_on_at", "CancelScope", base=("trio", "anyio")
+        )
+        if match is None:
+            return
+
+        if match.name in ("fail_at", "move_on_at") and len(node.args) == 1:
+            value = node.args[0]
+        else:
+            for kw in node.keywords:
+                if kw.arg == "deadline":
+                    value = kw.value
+                    break
+            else:
+                return
+        if is_constant(value):
+            self.error(
+                value,
+                str(match),
+                match.base,
+            )
 
 
 @error_class_cst

{flake8_async-25.3.1 → flake8_async-25.4.2}/flake8_async.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.4
 Name: flake8-async
-Version: 25.3.1
+Version: 25.4.2
 Summary: A highly opinionated flake8 plugin for Trio-related problems.
 Author: Zac Hatfield-Dodds, John Litborn, and Contributors
 Author-email: zac@zhd.dev

{flake8_async-25.3.1 → flake8_async-25.4.2}/flake8_async.egg-info/SOURCES.txt

@@ -53,6 +53,7 @@ tests/autofix_files/async911_insert_library.py
 tests/autofix_files/async913.py
 tests/autofix_files/async913_trio_anyio.py
 tests/autofix_files/async91x_autofix.py
+tests/autofix_files/async91x_py310.py
 tests/autofix_files/async91x_py311.py
 tests/autofix_files/exception_suppress_context_manager.py
 tests/autofix_files/exception_suppress_context_manager_import_star.py
@@ -73,6 +74,7 @@ tests/eval_files/async102_anyio.py
 tests/eval_files/async102_asyncio.py
 tests/eval_files/async102_trio.py
 tests/eval_files/async103.py
+tests/eval_files/async103_104_py310.py
 tests/eval_files/async103_104_py311.py
 tests/eval_files/async103_all_imported.py
 tests/eval_files/async103_both_imported.py
@@ -107,6 +109,7 @@ tests/eval_files/async123.py
 tests/eval_files/async123_py311.py
 tests/eval_files/async124.py
 tests/eval_files/async124_no_autofix.py
+tests/eval_files/async125.py
 tests/eval_files/async200.py
 tests/eval_files/async210.py
 tests/eval_files/async211.py
@@ -135,6 +138,7 @@ tests/eval_files/async913.py
 tests/eval_files/async913_trio_anyio.py
 tests/eval_files/async91x_autofix.py
 tests/eval_files/async91x_noautofix.py
+tests/eval_files/async91x_py310.py
 tests/eval_files/async91x_py311.py
 tests/eval_files/exception_suppress_context_manager.py
 tests/eval_files/exception_suppress_context_manager_import_star.py

flake8_async-25.4.2/tests/autofix_files/async91x_py310.py

@@ -0,0 +1,90 @@
+# ARG --enable=ASYNC910,ASYNC911,ASYNC913
+# AUTOFIX
+# ASYNCIO_NO_AUTOFIX
+import trio
+
+
+async def foo(): ...
+
+
+async def match_subject() -> None:
+    match await foo():
+        case False:
+            pass
+
+
+async def match_not_all_cases() -> (  # ASYNC910: 0, "exit", Statement("function definition", lineno)
+    None
+):
+    match foo():
+        case 1:
+            ...
+        case _:
+            await foo()
+    await trio.lowlevel.checkpoint()
+
+
+async def match_no_fallback() -> (  # ASYNC910: 0, "exit", Statement("function definition", lineno)
+    None
+):
+    match foo():
+        case 1:
+            await foo()
+        case 2:
+            await foo()
+        case _ if True:
+            await foo()
+    await trio.lowlevel.checkpoint()
+
+
+async def match_fallback_is_guarded() -> (  # ASYNC910: 0, "exit", Statement("function definition", lineno)
+    None
+):
+    match foo():
+        case 1:
+            await foo()
+        case 2:
+            await foo()
+        case _ if foo():
+            await foo()
+    await trio.lowlevel.checkpoint()
+
+
+async def match_all_cases() -> None:
+    match foo():
+        case 1:
+            await foo()
+        case 2:
+            await foo()
+        case _:
+            await foo()
+
+
+async def match_fallback_await_in_guard() -> None:
+    # The case guard is only executed if the pattern matches, so we can mostly treat
+    # it as part of the body, except for a special case for fallback+checkpointing guard.
+    match foo():
+        case 1 if await foo():
+            ...
+        case _ if await foo():
+            ...
+
+
+async def match_checkpoint_guard() -> None:
+    # The above pattern is quite cursed, but this seems fairly reasonable to do.
+    match foo():
+        case 1 if await foo():
+            ...
+        case _:
+            await foo()
+
+
+async def match_not_checkpoint_in_all_guards() -> (  # ASYNC910: 0, "exit", Statement("function definition", lineno)
+    None
+):
+    match foo():
+        case 1:
+            ...
+        case _ if await foo():
+            ...
+    await trio.lowlevel.checkpoint()

{flake8_async-25.3.1 → flake8_async-25.4.2}/tests/check_changelog_and_version.py

@@ -8,6 +8,8 @@ import sys
 from pathlib import Path
 from typing import TYPE_CHECKING, NamedTuple, TypeVar
 
+from typing_extensions import Self
+
 if TYPE_CHECKING:
     from collections.abc import Iterable
 
@@ -27,7 +29,7 @@ class Version(NamedTuple):
     patch: int
 
     @classmethod
-    def from_string(cls: type[T], string: str) -> T:
+    def from_string(cls, string: str) -> Self:
         return cls(*map(int, string.split(".")))
 
     def __str__(self) -> str:

flake8_async-25.4.2/tests/eval_files/async103_104_py310.py

@@ -0,0 +1,58 @@
+"""Test for ASYNC103/ASYNC104 with structural pattern matching
+
+ASYNC103: no-reraise-cancelled
+ASYNC104: cancelled-not-raised
+"""
+
+# ARG --enable=ASYNC103,ASYNC104
+
+
+def foo() -> Any: ...
+
+
+try:
+    ...
+except BaseException as e:  # ASYNC103_trio: 7, "BaseException"
+    match foo():
+        case True:
+            raise e
+        case False:
+            ...
+        case _:
+            raise e
+
+try:
+    ...
+except BaseException:  # ASYNC103_trio: 7, "BaseException"
+    match foo():
+        case True:
+            raise
+
+try:
+    ...
+except BaseException:  # safe
+    match foo():
+        case True:
+            raise
+        case False:
+            raise
+        case _:
+            raise
+try:
+    ...
+except BaseException:  # ASYNC103_trio: 7, "BaseException"
+    match foo():
+        case _ if foo():
+            raise
+try:
+    ...
+except BaseException:  # ASYNC103_trio: 7, "BaseException"
+    match foo():
+        case 1:
+            return  # ASYNC104: 12
+        case 2:
+            raise
+        case 3:
+            return  # ASYNC104: 12
+        case blah:
+            raise

flake8_async-25.4.2/tests/eval_files/async125.py

@@ -0,0 +1,33 @@
+import trio
+from typing import Final
+
+# ASYNCIO_NO_ERROR
+# anyio.[fail/move_on]_at doesn't exist, but no harm in erroring if we encounter them
+
+trio.fail_at(5)  # ASYNC125: 13, "trio.fail_at", "trio"
+trio.fail_at(deadline=5)  # ASYNC125: 22, "trio.fail_at", "trio"
+trio.move_on_at(10**3)  # ASYNC125: 16, "trio.move_on_at", "trio"
+trio.fail_at(7 * 3 + 2 / 5 - (8**7))  # ASYNC125: 13, "trio.fail_at", "trio"
+
+trio.CancelScope(deadline=7)  # ASYNC125: 26, "trio.CancelScope", "trio"
+trio.CancelScope(shield=True, deadline=7)  # ASYNC125: 39, "trio.CancelScope", "trio"
+
+# we *could* tell them to use math.inf here ...
+trio.fail_at(10**1000)  # ASYNC125: 13, "trio.fail_at", "trio"
+
+# _after is fine
+trio.fail_after(5)
+trio.move_on_after(2.3)
+
+trio.fail_at(trio.current_time())
+trio.fail_at(trio.current_time() + 7)
+
+# relative_deadline is fine, though anyio doesn't have it
+trio.CancelScope(relative_deadline=7)
+
+# does not trigger on other "constants".. but we could opt to trigger on
+# any all-caps variable, or on :Final
+MY_CONST_VALUE = 7
+trio.fail_at(MY_CONST_VALUE)
+my_final_value: Final = 3
+trio.fail_at(my_final_value)

flake8_async-25.4.2/tests/eval_files/async91x_py310.py

@@ -0,0 +1,86 @@
+# ARG --enable=ASYNC910,ASYNC911,ASYNC913
+# AUTOFIX
+# ASYNCIO_NO_AUTOFIX
+import trio
+
+
+async def foo(): ...
+
+
+async def match_subject() -> None:
+    match await foo():
+        case False:
+            pass
+
+
+async def match_not_all_cases() -> (  # ASYNC910: 0, "exit", Statement("function definition", lineno)
+    None
+):
+    match foo():
+        case 1:
+            ...
+        case _:
+            await foo()
+
+
+async def match_no_fallback() -> (  # ASYNC910: 0, "exit", Statement("function definition", lineno)
+    None
+):
+    match foo():
+        case 1:
+            await foo()
+        case 2:
+            await foo()
+        case _ if True:
+            await foo()
+
+
+async def match_fallback_is_guarded() -> (  # ASYNC910: 0, "exit", Statement("function definition", lineno)
+    None
+):
+    match foo():
+        case 1:
+            await foo()
+        case 2:
+            await foo()
+        case _ if foo():
+            await foo()
+
+
+async def match_all_cases() -> None:
+    match foo():
+        case 1:
+            await foo()
+        case 2:
+            await foo()
+        case _:
+            await foo()
+
+
+async def match_fallback_await_in_guard() -> None:
+    # The case guard is only executed if the pattern matches, so we can mostly treat
+    # it as part of the body, except for a special case for fallback+checkpointing guard.
+    match foo():
+        case 1 if await foo():
+            ...
+        case _ if await foo():
+            ...
+
+
+async def match_checkpoint_guard() -> None:
+    # The above pattern is quite cursed, but this seems fairly reasonable to do.
+    match foo():
+        case 1 if await foo():
+            ...
+        case _:
+            await foo()
+
+
+async def match_not_checkpoint_in_all_guards() -> (  # ASYNC910: 0, "exit", Statement("function definition", lineno)
+    None
+):
+    match foo():
+        case 1:
+            ...
+        case _ if await foo():
+            ...

{flake8_async-25.3.1 → flake8_async-25.4.2}/tests/test_flake8_async.py

@@ -510,6 +510,7 @@ error_codes_ignored_when_checking_transformed_sync_code = {
     "ASYNC121",
     "ASYNC122",
     "ASYNC123",
+    "ASYNC125",
     "ASYNC300",
     "ASYNC912",
 }