flake8-async 24.4.2__tar.gz → 24.5.2__tar.gz

{flake8_async-24.4.2 → flake8_async-24.5.2}/CHANGELOG.md

@@ -1,6 +1,15 @@
 # Changelog
 *[CalVer, YY.month.patch](https://calver.org/)*
 
+## 24.5.2
+- ASYNC101 now also warns on anyio & asyncio taskgroup.s
+- Fixed a bug where ASYNC101 and ASYNC91x would not recognize decorators with parameters directly imported. I.e. `@fixture(...)` will now suppress errors.
+
+## 24.5.1
+- Add ASYNC912: no checkpoints in with statement are guaranteed to run.
+- ASYNC100 now properly treats async for comprehensions as checkpoints.
+- ASYNC100 now supports autofixing on asyncio.
+
 ## 24.4.2
 - Add ASYNC119: yield in contextmanager in async generator.
 

{flake8_async-24.4.2 → flake8_async-24.5.2}/CONTRIBUTING.md

@@ -44,11 +44,15 @@ You can instead of `error` specify the error code.
 With `# ARG` lines you can also specify command-line arguments that should be passed to the plugin when parsing a file. Can be specified multiple times for several different arguments.  
 Generated tests will by default `--select` the error code of the file, which will enable any visitors that can generate that code (and if those visitors can raise other codes they might be raised too). This can be overridden by adding an `# ARG --select=...` line.
 
-### `# NOANYIO` and `# NOTRIO`
-Eval files are also evaluated where ~all instances of "trio" is replaced with "anyio" and `--anyio` is prepended to the argument list, to check for compatibility with the [anyio](https://github.com/agronholm/anyio) library - unless they are marked with `# NOANYIO`.
-If a file is marked with `# NOTRIO` it will not replace instances of "trio" with "anyio", and the file will not be run by the normal `eval_files` test generator.
-#### `# ANYIO_NO_ERROR`
-A file which is marked with this will ignore all `# error` or `# TRIO...` comments when running with anyio. Use when an error is trio-specific and replacing "trio" with "anyio" should silence all errors.
+### Library parametrization
+Eval files are evaluated with each supported library. It does this by replacing all instances of the `BASE_LIBRARY` ("trio" by default) with the two other libraries, and setting the corresponding flag (`--anyio` or `--asyncio`).
+### `# BASE_LIBRARY anyio` / `# BASE_LIBRARY asyncio`
+Defaults to `trio`. Used to specify the primary library an eval file is testing.
+
+#### `# ANYIO_NO_ERROR`, `# TRIO_NO_ERROR`, `# ASYNCIO_NO_ERROR`
+A file which is marked with this will ignore all `# error` or `# TRIO...` comments when running with anyio. Use when an error is library-specific and replacing all instances means the file should no longer raise any errors.
+### `# NOANYIO`, `# NOTRIO`, `#NOASYNCIO`
+Disables checking a file with the specified library. Should be used somewhat sparingly, and always have a comment motivating its use.
 
 ## Running pytest outside tox
 If you don't want to bother with tox to quickly test stuff, you'll need to install the following dependencies:

{flake8_async-24.4.2 → flake8_async-24.5.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: flake8-async
-Version: 24.4.2
+Version: 24.5.2
 Summary: A highly opinionated flake8 plugin for Trio-related problems.
 Home-page: https://github.com/python-trio/flake8-async
 Author: Zac Hatfield-Dodds, John Litborn, and Contributors
@@ -89,6 +89,7 @@ Note: 22X, 23X and 24X has not had asyncio-specific suggestions written.
 - **ASYNC910**: Exit or `return` from async function with no guaranteed checkpoint or exception since function definition. You might want to enable this on a codebase to make it easier to reason about checkpoints, and make the logic of ASYNC911 correct.
 - **ASYNC911**: Exit, `yield` or `return` from async iterable with no guaranteed checkpoint since possible function entry (yield or function definition)
   Checkpoints are `await`, `async for`, and `async with` (on one of enter/exit).
+- **ASYNC912**: Timeout/Cancelscope has no awaits that are guaranteed to run. If the scope has no checkpoints at all, then `ASYNC100` will be raised instead.
 
 ### Removed Warnings
 - **TRIOxxx**: All error codes are now renamed ASYNCxxx
@@ -110,7 +111,7 @@ adding the following to your `.pre-commit-config.yaml`:
 minimum_pre_commit_version: '2.9.0'
 repos:
 - repo: https://github.com/python-trio/flake8-async
-  rev: 24.4.2
+  rev: 24.5.2
   hooks:
     - id: flake8-async
       # args: [--enable=ASYNC, --disable=ASYNC9, --autofix=ASYNC]
@@ -225,6 +226,15 @@ async def my_function():
 # Changelog
 *[CalVer, YY.month.patch](https://calver.org/)*
 
+## 24.5.2
+- ASYNC101 now also warns on anyio & asyncio taskgroup.s
+- Fixed a bug where ASYNC101 and ASYNC91x would not recognize decorators with parameters directly imported. I.e. `@fixture(...)` will now suppress errors.
+
+## 24.5.1
+- Add ASYNC912: no checkpoints in with statement are guaranteed to run.
+- ASYNC100 now properly treats async for comprehensions as checkpoints.
+- ASYNC100 now supports autofixing on asyncio.
+
 ## 24.4.2
 - Add ASYNC119: yield in contextmanager in async generator.
 

{flake8_async-24.4.2 → flake8_async-24.5.2}/README.md

@@ -64,6 +64,7 @@ Note: 22X, 23X and 24X has not had asyncio-specific suggestions written.
 - **ASYNC910**: Exit or `return` from async function with no guaranteed checkpoint or exception since function definition. You might want to enable this on a codebase to make it easier to reason about checkpoints, and make the logic of ASYNC911 correct.
 - **ASYNC911**: Exit, `yield` or `return` from async iterable with no guaranteed checkpoint since possible function entry (yield or function definition)
   Checkpoints are `await`, `async for`, and `async with` (on one of enter/exit).
+- **ASYNC912**: Timeout/Cancelscope has no awaits that are guaranteed to run. If the scope has no checkpoints at all, then `ASYNC100` will be raised instead.
 
 ### Removed Warnings
 - **TRIOxxx**: All error codes are now renamed ASYNCxxx
@@ -85,7 +86,7 @@ adding the following to your `.pre-commit-config.yaml`:
 minimum_pre_commit_version: '2.9.0'
 repos:
 - repo: https://github.com/python-trio/flake8-async
-  rev: 24.4.2
+  rev: 24.5.2
   hooks:
     - id: flake8-async
       # args: [--enable=ASYNC, --disable=ASYNC9, --autofix=ASYNC]

{flake8_async-24.4.2 → flake8_async-24.5.2}/flake8_async/__init__.py

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

{flake8_async-24.4.2 → flake8_async-24.5.2}/flake8_async/visitors/__init__.py

@@ -30,7 +30,6 @@ utility_visitors_cst: set[type[Flake8AsyncVisitor_cst]] = set()
 from . import (
     visitor2xx,
     visitor91x,
-    visitor100,
     visitor101,
     visitor102,
     visitor103_104,

{flake8_async-24.4.2 → flake8_async-24.5.2}/flake8_async/visitors/flake8asyncvisitor.py

@@ -98,7 +98,11 @@ class Flake8AsyncVisitor(ast.NodeVisitor, ABC):
             ), "No error code defined, but class has multiple codes"
             error_code = next(iter(self.error_codes))
         # don't emit an error if this code is disabled in a multi-code visitor
-        elif strip_error_subidentifier(error_code) not in self.options.enabled_codes:
+        elif (
+            (ec_no_sub := strip_error_subidentifier(error_code))
+            not in self.options.enabled_codes
+            and ec_no_sub not in self.options.autofix_codes
+        ):
             return
 
         self.__state.problems.append(
@@ -217,7 +221,11 @@ class Flake8AsyncVisitor_cst(cst.CSTTransformer, ABC):
             error_code = next(iter(self.error_codes))
         # don't emit an error if this code is disabled in a multi-code visitor
         # TODO: write test for only one of 910/911 enabled/autofixed
-        elif strip_error_subidentifier(error_code) not in self.options.enabled_codes:
+        elif (
+            (ec_no_sub := strip_error_subidentifier(error_code))
+            not in self.options.enabled_codes
+            and ec_no_sub not in self.options.autofix_codes
+        ):
             return False  # pragma: no cover
 
         if self.is_noqa(node, error_code):
@@ -237,7 +245,7 @@ class Flake8AsyncVisitor_cst(cst.CSTTransformer, ABC):
         return True
 
     def should_autofix(self, node: cst.CSTNode, code: str | None = None) -> bool:
-        if code is None:
+        if code is None:  # pragma: no cover
             assert len(self.error_codes) == 1
             code = next(iter(self.error_codes))
         # this does not currently need to check for `noqa`s, as error() does that

{flake8_async-24.4.2 → flake8_async-24.5.2}/flake8_async/visitors/helpers.py

@@ -51,6 +51,7 @@ def error_class_cst(error_class: type[T_CST]) -> type[T_CST]:
 
 
 def disabled_by_default(error_class: type[T_EITHER]) -> type[T_EITHER]:
+    """Default-disables all error codes in a class."""
     assert error_class.error_codes  # type: ignore[attr-defined]
     default_disabled_error_codes.extend(
         error_class.error_codes  # type: ignore[attr-defined]
@@ -58,6 +59,11 @@ def disabled_by_default(error_class: type[T_EITHER]) -> type[T_EITHER]:
     return error_class
 
 
+def disable_codes_by_default(*codes: str) -> None:
+    """Default-disables only specified codes."""
+    default_disabled_error_codes.extend(codes)
+
+
 def utility_visitor(c: type[T]) -> type[T]:
     assert not hasattr(c, "error_codes")
     c.error_codes = {}
@@ -83,7 +89,8 @@ def _get_identifier(node: ast.expr) -> str:
 
 
 # ignores module and only checks the unqualified name of the decorator
-# used in 101, 113, 900 and 910/911
+# used in 113. cst version used in 101, 900 and 910/911
+# matches @name, @foo.name, @name(...), and @foo.name(...)
 def has_decorator(node: ast.FunctionDef | ast.AsyncFunctionDef, *names: str):
     return any(_get_identifier(dec) in names for dec in node.decorator_list)
 
@@ -317,30 +324,68 @@ class AttributeCall(NamedTuple):
     function: str
 
 
+# the custom __or__ in libcst breaks pyright type checking. It's possible to use
+# `Union` as a workaround ... except pyupgrade will automatically replace that.
+# So we have to resort to specifying one of the base classes.
+# See https://github.com/Instagram/LibCST/issues/1143
+def build_cst_matcher(attr: str) -> m.BaseExpression:
+    """Build a cst matcher structure with attributes&names matching a string `a.b.c`."""
+    if "." not in attr:
+        return m.Name(value=attr)
+    body, tail = attr.rsplit(".")
+    return m.Attribute(value=build_cst_matcher(body), attr=m.Name(value=tail))
+
+
+def identifier_to_string(attr: cst.Name | cst.Attribute) -> str:
+    if isinstance(attr, cst.Name):
+        return attr.value
+    assert isinstance(attr.value, (cst.Attribute, cst.Name))
+    return identifier_to_string(attr.value) + "." + attr.attr.value
+
+
 def with_has_call(
-    node: cst.With, *names: str, base: Iterable[str] = ("trio", "anyio")
+    node: cst.With, *names: str, base: Iterable[str] | str = ("trio", "anyio")
 ) -> list[AttributeCall]:
+    """Check if a with statement has a matching call, returning a list with matches.
+
+    `names` specify the names of functions to match, `base` specifies the
+    library/module(s) the function must be in.
+    The list elements in the return value are named tuples with the matched node,
+    base and function.
+
+    Examples_
+
+    `with_has_call(node, "bar", base="foo")` matches foo.bar.
+    `with_has_call(node, "bar", "bee", base=("foo", "a.b.c")` matches
+      `foo.bar`, `foo.bee`, `a.b.c.bar`, and `a.b.c.bee`.
+
+    """
+    if isinstance(base, str):
+        base = (base,)  # pragma: no cover
+
+    # build matcher, using SaveMatchedNode to save the base and the function name.
+    matcher = m.Call(
+        func=m.Attribute(
+            value=m.SaveMatchedNode(
+                m.OneOf(*(build_cst_matcher(b) for b in base)), name="base"
+            ),
+            attr=m.SaveMatchedNode(
+                oneof_names(*names),
+                name="function",
+            ),
+        )
+    )
+
     res_list: list[AttributeCall] = []
     for item in node.items:
-        if res := m.extract(
-            item.item,
-            m.Call(
-                func=m.Attribute(
-                    value=m.SaveMatchedNode(m.Name(), name="library"),
-                    attr=m.SaveMatchedNode(
-                        oneof_names(*names),
-                        name="function",
-                    ),
-                )
-            ),
-        ):
+        if res := m.extract(item.item, matcher):
             assert isinstance(item.item, cst.Call)
-            assert isinstance(res["library"], cst.Name)
+            assert isinstance(res["base"], (cst.Name, cst.Attribute))
             assert isinstance(res["function"], cst.Name)
-            if res["library"].value not in base:
-                continue
             res_list.append(
-                AttributeCall(item.item, res["library"].value, res["function"].value)
+                AttributeCall(
+                    item.item, identifier_to_string(res["base"]), res["function"].value
+                )
             )
     return res_list
 
@@ -351,8 +396,13 @@ def func_has_decorator(func: cst.FunctionDef, *names: str) -> bool:
             func.decorators,
             m.Decorator(
                 decorator=m.OneOf(
+                    # @name
                     oneof_names(*names),
+                    # @foo.name
                     m.Attribute(attr=oneof_names(*names)),
+                    # @name(...)
+                    m.Call(func=oneof_names(*names)),
+                    # @foo.name(...)
                     m.Call(func=m.Attribute(attr=oneof_names(*names))),
                 )
             ),

{flake8_async-24.4.2 → flake8_async-24.5.2}/flake8_async/visitors/visitor101.py

@@ -40,12 +40,22 @@ class Visitor101(Flake8AsyncVisitor_cst):
         self.save_state(node, "_yield_is_error", copy=True)
         # if there's no safe decorator,
         # and it's not yet been determined that yield is error
-        # and this withitem opens a cancelscope:
+        # and this withitem opens a nursery/taskgroup/cancelscope:
         # then yielding is unsafe
         self._yield_is_error = (
             not self._safe_decorator
             and not self._yield_is_error
-            and bool(with_has_call(node, "open_nursery", *cancel_scope_names))
+            # It's not strictly necessary to specify the base, as raising errors on
+            # e.g. anyio.open_nursery isn't much of a problem.
+            and bool(
+                # nursery/taskgroup
+                with_has_call(node, "open_nursery", base="trio")
+                or with_has_call(node, "create_task_group", base="anyio")
+                or with_has_call(node, "TaskGroup", base="asyncio")
+                # cancel scopes
+                or with_has_call(node, "timeout", "timeout_at", base="asyncio")
+                or with_has_call(node, *cancel_scope_names, base=("trio", "anyio"))
+            )
         )
 
     def leave_With(

{flake8_async-24.4.2 → flake8_async-24.5.2}/flake8_async/visitors/visitor111.py

@@ -12,13 +12,21 @@ if TYPE_CHECKING:
     from collections.abc import Mapping
 
 
+def is_nursery_like(node: ast.expr) -> bool:
+    return bool(
+        get_matching_call(node, "open_nursery", base="trio")
+        or get_matching_call(node, "create_task_group", base="anyio")
+        or get_matching_call(node, "TaskGroup", base="asyncio")
+    )
+
+
 @error_class
 class Visitor111(Flake8AsyncVisitor):
     error_codes: Mapping[str, str] = {
         "ASYNC111": (
             "variable {2} is usable within the context manager on line {0}, but that "
-            "will close before nursery opened on line {1} - this is usually a bug.  "
-            "Nurseries should generally be the inner-most context manager."
+            "will close before nursery/taskgroup opened on line {1} - this is usually "
+            "a bug. Nursery/TaskGroup should generally be the inner-most context manager."
         ),
     }
 
@@ -48,8 +56,7 @@ class Visitor111(Flake8AsyncVisitor):
                     self.TrioContextManager(
                         item.context_expr.lineno,
                         item.optional_vars.id,
-                        get_matching_call(item.context_expr, "open_nursery")
-                        is not None,
+                        is_nursery_like(item.context_expr),
                     )
                 )
 
@@ -75,7 +82,7 @@ class Visitor111(Flake8AsyncVisitor):
         if (
             isinstance(node.func, ast.Attribute)
             and isinstance(node.func.value, ast.Name)
-            and node.func.attr in ("start", "start_soon")
+            and node.func.attr in ("start", "start_soon", "create_task")
         ):
             self._nursery_call = None
             for i, cm in enumerate(self._context_managers):

{flake8_async-24.4.2 → flake8_async-24.5.2}/flake8_async/visitors/visitor91x.py

@@ -18,19 +18,32 @@ from libcst.metadata import PositionProvider
 from ..base import Statement
 from .flake8asyncvisitor import Flake8AsyncVisitor_cst
 from .helpers import (
-    disabled_by_default,
+    AttributeCall,
+    cancel_scope_names,
+    disable_codes_by_default,
     error_class_cst,
+    flatten_preserving_comments,
     fnmatch_qualified_name_cst,
     func_has_decorator,
     iter_guaranteed_once_cst,
+    with_has_call,
 )
 
 if TYPE_CHECKING:
     from collections.abc import Mapping, Sequence
 
 
+class ArtificialStatement(Statement):
+    """Statement that should not trigger 910/911 on function exit.
+
+    Used by loops and `with` statements.
+    """
+
+
 # Statement injected at the start of loops to track missed checkpoints.
-ARTIFICIAL_STATEMENT = Statement("artificial", -1)
+ARTIFICIAL_STATEMENT = ArtificialStatement("artificial", -1)
+# There's no particular reason why loops use a globally instanced statement, but
+# `with` does not - mostly just an artifact of them being implemented at different times.
 
 
 def func_empty_body(node: cst.FunctionDef) -> bool:
@@ -231,8 +244,10 @@ class InsertCheckpointsInLoopBody(CommonVisitors):
     leave_Return = leave_Yield  # type: ignore
 
 
+disable_codes_by_default("ASYNC910", "ASYNC911", "ASYNC912")
+
+
 @error_class_cst
-@disabled_by_default
 class Visitor91X(Flake8AsyncVisitor_cst, CommonVisitors):
     error_codes: Mapping[str, str] = {
         "ASYNC910": (
@@ -243,6 +258,14 @@ class Visitor91X(Flake8AsyncVisitor_cst, CommonVisitors):
             "{0} from async iterable with no guaranteed checkpoint since {1.name} "
             "on line {1.lineno}."
         ),
+        "ASYNC912": (
+            "CancelScope with no guaranteed checkpoint. This makes it potentially "
+            "impossible to cancel."
+        ),
+        "ASYNC100": (
+            "{0}.{1} context contains no checkpoints, remove the context or add"
+            " `await {0}.lowlevel.checkpoint()`."
+        ),
     }
 
     def __init__(self, *args: Any, **kwargs: Any):
@@ -256,15 +279,24 @@ class Visitor91X(Flake8AsyncVisitor_cst, CommonVisitors):
         self.loop_state = LoopState()
         self.try_state = TryState()
 
+        # ASYNC100
+        self.has_checkpoint_stack: list[bool] = []
+        self.node_dict: dict[cst.With, list[AttributeCall]] = {}
+
     def should_autofix(self, node: cst.CSTNode, code: str | None = None) -> bool:
+        if code is None:  # pragma: no branch
+            code = "ASYNC911" if self.has_yield else "ASYNC910"
+
         return (
             not self.noautofix
-            and super().should_autofix(
-                node, "ASYNC911" if self.has_yield else "ASYNC910"
-            )
+            and super().should_autofix(node, code)
             and self.library != ("asyncio",)
         )
 
+    def checkpoint(self) -> None:
+        self.uncheckpointed_statements = set()
+        self.has_checkpoint_stack = [True] * len(self.has_checkpoint_stack)
+
     def checkpoint_statement(self) -> cst.SimpleStatementLine:
         return checkpoint_statement(self.library[0])
 
@@ -283,9 +315,11 @@ class Visitor91X(Flake8AsyncVisitor_cst, CommonVisitors):
             "uncheckpointed_statements",
             "loop_state",
             "try_state",
+            "has_checkpoint_stack",
             copy=True,
         )
         self.uncheckpointed_statements = set()
+        self.has_checkpoint_stack = []
         self.has_yield = self.safe_decorator = False
         self.loop_state = LoopState()
 
@@ -359,7 +393,7 @@ class Visitor91X(Flake8AsyncVisitor_cst, CommonVisitors):
         any_errors = False
         # raise the actual errors
         for statement in self.uncheckpointed_statements:
-            if statement == ARTIFICIAL_STATEMENT:
+            if isinstance(statement, ArtificialStatement):
                 continue
             any_errors |= self.error_91x(original_node, statement)
 
@@ -376,6 +410,7 @@ class Visitor91X(Flake8AsyncVisitor_cst, CommonVisitors):
             self.add_statement = self.checkpoint_statement()
         # avoid duplicate error messages
         self.uncheckpointed_statements = set()
+        # we don't treat it as a checkpoint for ASYNC100
 
         # return original node to avoid problems with identity equality
         assert original_node.deep_equals(updated_node)
@@ -386,7 +421,7 @@ class Visitor91X(Flake8AsyncVisitor_cst, CommonVisitors):
         node: cst.Return | cst.FunctionDef | cst.Yield,
         statement: Statement,
     ) -> bool:
-        assert statement != ARTIFICIAL_STATEMENT
+        assert not isinstance(statement, ArtificialStatement)
 
         if isinstance(node, cst.FunctionDef):
             msg = "exit"
@@ -407,7 +442,7 @@ class Visitor91X(Flake8AsyncVisitor_cst, CommonVisitors):
         # so only set checkpoint after the await node
 
         # all nodes are now checkpointed
-        self.uncheckpointed_statements = set()
+        self.checkpoint()
         return updated_node
 
     # raising exception means we don't need to checkpoint so we can treat it as one
@@ -419,9 +454,54 @@ class Visitor91X(Flake8AsyncVisitor_cst, CommonVisitors):
     # missing-checkpoint warning when there might in fact be one (i.e. a false alarm).
     def visit_With_body(self, node: cst.With):
         if getattr(node, "asynchronous", None):
-            self.uncheckpointed_statements = set()
-
-    leave_With_body = visit_With_body
+            self.checkpoint()
+        if res := (
+            with_has_call(node, *cancel_scope_names)
+            or with_has_call(
+                node, "timeout", "timeout_at", base=("asyncio", "asyncio.timeouts")
+            )
+        ):
+            pos = self.get_metadata(PositionProvider, node).start  # pyright: ignore
+            line: int = pos.line  # pyright: ignore
+            column: int = pos.column  # pyright: ignore
+            self.uncheckpointed_statements.add(
+                ArtificialStatement("with", line, column)
+            )
+            self.node_dict[node] = res
+            self.has_checkpoint_stack.append(False)
+        else:
+            self.has_checkpoint_stack.append(True)
+
+    def leave_With(self, original_node: cst.With, updated_node: cst.With):
+        # Uses leave_With instead of leave_With_body because we need access to both
+        # original and updated node
+        # ASYNC100
+        if not self.has_checkpoint_stack.pop():
+            autofix = len(updated_node.items) == 1
+            for res in self.node_dict[original_node]:
+                # bypass 910 & 911's should_autofix logic, which excludes asyncio
+                # (TODO: and uses self.noautofix ... which I don't remember what it's for)
+                autofix &= self.error(
+                    res.node, res.base, res.function, error_code="ASYNC100"
+                ) and super().should_autofix(res.node, code="ASYNC100")
+
+            if autofix:
+                return flatten_preserving_comments(updated_node)
+        # ASYNC912
+        else:
+            pos = self.get_metadata(  # pyright: ignore
+                PositionProvider, original_node
+            ).start  # pyright: ignore
+            line: int = pos.line  # pyright: ignore
+            column: int = pos.column  # pyright: ignore
+            s = ArtificialStatement("with", line, column)
+            if s in self.uncheckpointed_statements:
+                self.uncheckpointed_statements.remove(s)
+                for res in self.node_dict[original_node]:
+                    self.error(res.node, error_code="ASYNC912")
+        if getattr(original_node, "asynchronous", None):
+            self.checkpoint()
+        return updated_node
 
     # error if no checkpoint since earlier yield or function entry
     def leave_Yield(
@@ -431,6 +511,10 @@ class Visitor91X(Flake8AsyncVisitor_cst, CommonVisitors):
             return updated_node
         self.has_yield = True
 
+        # Treat as a checkpoint for ASYNC100, since the context we yield to
+        # may checkpoint.
+        self.has_checkpoint_stack = [True] * len(self.has_checkpoint_stack)
+
         if self.check_function_exit(original_node) and self.should_autofix(
             original_node
         ):
@@ -605,7 +689,7 @@ class Visitor91X(Flake8AsyncVisitor_cst, CommonVisitors):
         # appropriate errors if the loop doesn't checkpoint
 
         if getattr(node, "asynchronous", None):
-            self.uncheckpointed_statements = set()
+            self.checkpoint()
         else:
             self.uncheckpointed_statements = {ARTIFICIAL_STATEMENT}
 
@@ -651,7 +735,7 @@ class Visitor91X(Flake8AsyncVisitor_cst, CommonVisitors):
         # AsyncFor guarantees checkpoint on running out of iterable
         # so reset checkpoint state at end of loop. (but not state at break)
         if getattr(node, "asynchronous", None):
-            self.uncheckpointed_statements = set()
+            self.checkpoint()
         else:
             # enter orelse with worst case:
             # loop body might execute fully before entering orelse
@@ -780,7 +864,7 @@ class Visitor91X(Flake8AsyncVisitor_cst, CommonVisitors):
 
         # if async comprehension, checkpoint
         if node.asynchronous:
-            self.uncheckpointed_statements = set()
+            self.checkpoint()
             self.comp_unknown = False
             return False
 

{flake8_async-24.4.2 → flake8_async-24.5.2}/flake8_async/visitors/visitors.py

@@ -104,17 +104,29 @@ class Visitor112(Flake8AsyncVisitor):
                 continue
             var_name = item.optional_vars.id
 
-            # check for trio.open_nursery
+            # check for trio.open_nursery and anyio.create_task_group
             nursery = get_matching_call(
-                item.context_expr, "open_nursery", base=("trio",)
-            )
+                item.context_expr, "open_nursery", base="trio"
+            ) or get_matching_call(item.context_expr, "create_task_group", base="anyio")
+            start_methods: tuple[str, ...] = ("start", "start_soon")
+            if nursery is None:
+                # check for asyncio.TaskGroup
+                nursery = get_matching_call(
+                    item.context_expr, "TaskGroup", base="asyncio"
+                )
+                if nursery is None:
+                    continue
+                start_methods = ("create_task",)
+
+            body_call = node.body[0].value
+            if isinstance(body_call, ast.Await):
+                body_call = body_call.value
 
             # `isinstance(..., ast.Call)` is done in get_matching_call
-            body_call = cast("ast.Call", node.body[0].value)
+            body_call = cast("ast.Call", body_call)
 
             if (
-                nursery is not None
-                and get_matching_call(body_call, "start", "start_soon", base=var_name)
+                get_matching_call(body_call, *start_methods, base=var_name)
                 # check for presence of <X> as parameter
                 and not any(
                     (isinstance(n, ast.Name) and n.id == var_name)

{flake8_async-24.4.2 → flake8_async-24.5.2}/flake8_async.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: flake8-async
-Version: 24.4.2
+Version: 24.5.2
 Summary: A highly opinionated flake8 plugin for Trio-related problems.
 Home-page: https://github.com/python-trio/flake8-async
 Author: Zac Hatfield-Dodds, John Litborn, and Contributors
@@ -89,6 +89,7 @@ Note: 22X, 23X and 24X has not had asyncio-specific suggestions written.
 - **ASYNC910**: Exit or `return` from async function with no guaranteed checkpoint or exception since function definition. You might want to enable this on a codebase to make it easier to reason about checkpoints, and make the logic of ASYNC911 correct.
 - **ASYNC911**: Exit, `yield` or `return` from async iterable with no guaranteed checkpoint since possible function entry (yield or function definition)
   Checkpoints are `await`, `async for`, and `async with` (on one of enter/exit).
+- **ASYNC912**: Timeout/Cancelscope has no awaits that are guaranteed to run. If the scope has no checkpoints at all, then `ASYNC100` will be raised instead.
 
 ### Removed Warnings
 - **TRIOxxx**: All error codes are now renamed ASYNCxxx
@@ -110,7 +111,7 @@ adding the following to your `.pre-commit-config.yaml`:
 minimum_pre_commit_version: '2.9.0'
 repos:
 - repo: https://github.com/python-trio/flake8-async
-  rev: 24.4.2
+  rev: 24.5.2
   hooks:
     - id: flake8-async
       # args: [--enable=ASYNC, --disable=ASYNC9, --autofix=ASYNC]
@@ -225,6 +226,15 @@ async def my_function():
 # Changelog
 *[CalVer, YY.month.patch](https://calver.org/)*
 
+## 24.5.2
+- ASYNC101 now also warns on anyio & asyncio taskgroup.s
+- Fixed a bug where ASYNC101 and ASYNC91x would not recognize decorators with parameters directly imported. I.e. `@fixture(...)` will now suppress errors.
+
+## 24.5.1
+- Add ASYNC912: no checkpoints in with statement are guaranteed to run.
+- ASYNC100 now properly treats async for comprehensions as checkpoints.
+- ASYNC100 now supports autofixing on asyncio.
+
 ## 24.4.2
 - Add ASYNC119: yield in contextmanager in async generator.