flake8-async 24.11.3__tar.gz → 25.2.2__tar.gz

{flake8_async-24.11.3 → flake8_async-25.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.2
 Name: flake8-async
-Version: 24.11.3
+Version: 25.2.2
 Summary: A highly opinionated flake8 plugin for Trio-related problems.
 Author: Zac Hatfield-Dodds, John Litborn, and Contributors
 Author-email: zac@zhd.dev
@@ -21,9 +21,18 @@ Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Requires-Python: >=3.9
 Description-Content-Type: text/markdown
-License-File: LICENSE
 Requires-Dist: flake8>=6
 Requires-Dist: libcst>=1.0.1
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: license
+Dynamic: project-url
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
 
 [![Documentation](https://img.shields.io/badge/docs-read%20now-blue.svg)](https://flake8-async.readthedocs.io)
 [![Latest PyPi version](https://img.shields.io/pypi/v/flake8-async.svg)](https://pypi.org/project/flake8-async)

{flake8_async-24.11.3 → flake8_async-25.2.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__ = "24.11.3"
+__version__ = "25.2.2"
 
 
 # taken from https://github.com/Zac-HD/shed

{flake8_async-24.11.3 → flake8_async-25.2.2}/flake8_async/visitors/visitor103_104.py

@@ -51,9 +51,9 @@ _error_codes = {
     "ASYNC103": _async103_common_msg,
     "ASYNC104": "Cancelled (and therefore BaseException) must be re-raised.",
 }
-for poss_library in _suggestion_dict:
+for poss_library, _lib_suggest in _suggestion_dict.items():
     _error_codes[f"ASYNC103_{'_'.join(poss_library)}"] = (
-        _async103_common_msg + _suggestion.format(_suggestion_dict[poss_library])
+        _async103_common_msg + _suggestion.format(_lib_suggest)
     )
 
 

{flake8_async-24.11.3 → flake8_async-25.2.2}/flake8_async/visitors/visitor2xx.py

@@ -186,7 +186,9 @@ class Visitor22X(Visitor200):
             "Sync call {} in async function, use "
             "`asyncio.create_subprocess_[exec/shell]."
         ),
-        "ASYNC222": "Sync call {} in async function, wrap in `{}.to_thread.run_sync()`.",
+        "ASYNC222": (
+            "Sync call {} in async function, wrap in `{}.to_thread.run_sync()`."
+        ),
         "ASYNC222_asyncio": (
             "Sync call {} in async function, use `asyncio.loop.run_in_executor`."
         ),
@@ -397,7 +399,7 @@ wrappers: Mapping[str, str] = {
 @error_class
 class Visitor25X(Visitor200):
     error_codes: Mapping[str, str] = {
-        "ASYNC250": ("Blocking sync call `input()` in async function. Wrap in `{}`."),
+        "ASYNC250": "Blocking sync call `input()` in async function. Wrap in `{}`.",
         "ASYNC251": (
             "Blocking sync call `time.sleep(...)` in async function."
             " Use `await {}.sleep(...)`."

{flake8_async-24.11.3 → flake8_async-25.2.2}/flake8_async/visitors/visitor91x.py

@@ -1,8 +1,14 @@
-"""Contains Visitor91X.
+"""Contains Visitor91X and Visitor124.
 
-910 looks for async functions without guaranteed checkpoints (or exceptions), and 911 does
-the same except for async iterables - while also requiring that they checkpoint between
-each yield.
+Visitor91X contains checks for
+* ASYNC100 cancel-scope-no-checkpoint
+* ASYNC910 async-function-no-checkpoint
+* ASYNC911 async-generator-no-checkpoint
+* ASYNC912 cancel-scope-no-guaranteed-checkpoint
+* ASYNC913 indefinite-loop-no-guaranteed-checkpoint
+
+Visitor124 contains
+* ASYNC124 async-function-could-be-sync
 """
 
 from __future__ import annotations
@@ -25,6 +31,7 @@ from .helpers import (
     flatten_preserving_comments,
     fnmatch_qualified_name_cst,
     func_has_decorator,
+    identifier_to_string,
     iter_guaranteed_once_cst,
     with_has_call,
 )
@@ -63,6 +70,92 @@ def func_empty_body(node: cst.FunctionDef) -> bool:
     )
 
 
+# this could've been implemented as part of visitor91x, but /shrug
+@error_class_cst
+class Visitor124(Flake8AsyncVisitor_cst):
+    error_codes: Mapping[str, str] = {
+        "ASYNC124": (
+            "Async function with no `await` could be sync."
+            " Async functions are more expensive to call."
+        )
+    }
+
+    def __init__(self, *args: Any, **kwargs: Any):
+        super().__init__(*args, **kwargs)
+        self.has_await = False
+        self.in_class = False
+
+    def visit_ClassDef(self, node: cst.ClassDef):
+        self.save_state(node, "in_class", copy=False)
+        self.in_class = True
+
+    def leave_ClassDef(
+        self, original_node: cst.ClassDef, updated_node: cst.ClassDef
+    ) -> cst.ClassDef:
+        self.restore_state(original_node)
+        return updated_node
+
+    # await in sync defs are not valid, but handling this will make ASYNC124
+    # correctly pop up in parent func as if the child function was async
+    def visit_FunctionDef(self, node: cst.FunctionDef):
+        # default values are evaluated in parent scope
+        # this visitor has no autofixes, so we can throw away return value
+        _ = node.params.visit(self)
+
+        self.save_state(node, "has_await", "in_class", copy=False)
+
+        # ignore class methods
+        self.has_await = self.in_class
+
+        # but not nested functions
+        self.in_class = False
+
+        _ = node.body.visit(self)
+
+        # we've manually visited subnodes (that we care about).
+        return False
+
+    def leave_FunctionDef(
+        self, original_node: cst.FunctionDef, updated_node: cst.FunctionDef
+    ) -> cst.FunctionDef:
+        if (
+            original_node.asynchronous is not None
+            and not self.has_await
+            and not func_empty_body(original_node)
+            and not func_has_decorator(original_node, "overload")
+            # skip functions with @fixture and params since they may be relying
+            # on async fixtures.
+            and not (
+                original_node.params.params
+                and func_has_decorator(original_node, "fixture")
+            )
+            # ignore functions with no_checkpoint_warning_decorators
+            and not fnmatch_qualified_name_cst(
+                original_node.decorators, *self.options.no_checkpoint_warning_decorators
+            )
+        ):
+            self.error(original_node)
+        self.restore_state(original_node)
+        return updated_node
+
+    def visit_Await(self, node: cst.Await):
+        self.has_await = True
+
+    def visit_With(self, node: cst.With | cst.For | cst.CompFor):
+        if node.asynchronous is not None:
+            self.has_await = True
+
+    visit_For = visit_With
+    visit_CompFor = visit_With
+
+    # The generator target will be immediately evaluated, but the other
+    # elements will not be evaluated at the point of defining the GenExp.
+    # To consume those needs an explicit syntactic checkpoint
+    def visit_GeneratorExp(self, node: cst.GeneratorExp):
+        node.for_in.iter.visit(self)
+        return False
+
+
 @dataclass
 class LoopState:
     infinite_loop: bool = False
@@ -261,10 +354,10 @@ class Visitor91X(Flake8AsyncVisitor_cst, CommonVisitors):
             "on line {1.lineno}."
         ),
         "ASYNC912": (
-            "CancelScope with no guaranteed checkpoint. This makes it potentially "
+            "CancelScope with no guaranteed cancel point. This makes it potentially "
             "impossible to cancel."
         ),
-        "ASYNC913": ("Indefinite loop with no guaranteed checkpoint."),
+        "ASYNC913": "Indefinite loop with no guaranteed cancel points.",
         "ASYNC100": (
             "{0}.{1} context contains no checkpoints, remove the context or add"
             " `await {0}.lowlevel.checkpoint()`."
@@ -274,7 +367,6 @@ class Visitor91X(Flake8AsyncVisitor_cst, CommonVisitors):
     def __init__(self, *args: Any, **kwargs: Any):
         super().__init__(*args, **kwargs)
         self.has_yield = False
-        self.safe_decorator = False
         self.async_function = False
         self.uncheckpointed_statements: set[Statement] = set()
         self.comp_unknown = False
@@ -285,10 +377,14 @@ class Visitor91X(Flake8AsyncVisitor_cst, CommonVisitors):
         # ASYNC100
         self.has_checkpoint_stack: list[bool] = []
         self.node_dict: dict[cst.With, list[AttributeCall]] = {}
+        self.taskgroup_has_start_soon: dict[str, bool] = {}
 
         # --exception-suppress-context-manager
         self.suppress_imported_as: list[str] = []
 
+        # used to transfer new body between visit_FunctionDef and leave_FunctionDef
+        self.new_body: cst.BaseSuite | None = None
+
     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"
@@ -299,13 +395,37 @@ class Visitor91X(Flake8AsyncVisitor_cst, CommonVisitors):
             and self.library != ("asyncio",)
         )
 
+    def checkpoint_cancel_point(self) -> None:
+        self.has_checkpoint_stack = [True] * len(self.has_checkpoint_stack)
+        # don't need to look for any .start_soon() calls
+        self.taskgroup_has_start_soon.clear()
+
+    def checkpoint_schedule_point(self) -> None:
+        # ASYNC912&ASYNC913 only cares about cancel points, so don't remove
+        # them if we only do a schedule point
+        self.uncheckpointed_statements = {
+            s
+            for s in self.uncheckpointed_statements
+            if isinstance(s, ArtificialStatement)
+        }
+
     def checkpoint(self) -> None:
         self.uncheckpointed_statements = set()
-        self.has_checkpoint_stack = [True] * len(self.has_checkpoint_stack)
+        self.checkpoint_cancel_point()
 
     def checkpoint_statement(self) -> cst.SimpleStatementLine:
         return checkpoint_statement(self.library[0])
 
+    def visit_Call(self, node: cst.Call) -> None:
+        # [Nursery/TaskGroup].start_soon introduces a cancel point
+        if (
+            isinstance(node.func, cst.Attribute)
+            and isinstance(node.func.value, cst.Name)
+            and node.func.attr.value == "start_soon"
+            and node.func.value.value in self.taskgroup_has_start_soon
+        ):
+            self.taskgroup_has_start_soon[node.func.value.value] = True
+
     def visit_ImportFrom(self, node: cst.ImportFrom) -> None:
         # Semi-crude approach to handle `from contextlib import suppress`.
         # It does not handle the identifier being overridden, or assigned
@@ -329,6 +449,10 @@ class Visitor91X(Flake8AsyncVisitor_cst, CommonVisitors):
                     return
 
     def visit_FunctionDef(self, node: cst.FunctionDef) -> bool:
+        # `await` in default values happen in parent scope
+        # we also know we don't ever modify parameters so we can ignore the return value
+        _ = node.params.visit(self)
+
         # don't lint functions whose bodies solely consist of pass or ellipsis
         # @overload functions are also guaranteed to be empty
         # we also ignore pytest fixtures
@@ -338,19 +462,23 @@ class Visitor91X(Flake8AsyncVisitor_cst, CommonVisitors):
         self.save_state(
             node,
             "has_yield",
-            "safe_decorator",
             "async_function",
             "uncheckpointed_statements",
+            # comp_unknown does not need to be saved
             "loop_state",
             "try_state",
             "has_checkpoint_stack",
-            "suppress_imported_as",
+            # node_dict is cleaned up and don't need to be saved
+            "taskgroup_has_start_soon",
+            "suppress_imported_as",  # a copy is saved, but state is not reset
             copy=True,
         )
         self.uncheckpointed_statements = set()
         self.has_checkpoint_stack = []
-        self.has_yield = self.safe_decorator = False
+        self.has_yield = False
         self.loop_state = LoopState()
+        # try_state is reset upon entering try
+        self.taskgroup_has_start_soon = {}
 
         self.async_function = (
             node.asynchronous is not None
@@ -358,36 +486,49 @@ class Visitor91X(Flake8AsyncVisitor_cst, CommonVisitors):
                 node.decorators, *self.options.no_checkpoint_warning_decorators
             )
         )
-        if not self.async_function:
-            # only visit subnodes if there is an async function defined inside
-            # this should improve performance on codebases with many sync functions
-            return any(m.findall(node, m.FunctionDef(asynchronous=m.Asynchronous())))
+        # only visit subnodes if there is an async function defined inside
+        # this should improve performance on codebases with many sync functions
+        if not self.async_function and not any(
+            m.findall(node, m.FunctionDef(asynchronous=m.Asynchronous()))
+        ):
+            return False
 
         pos = self.get_metadata(PositionProvider, node).start  # type: ignore
         self.uncheckpointed_statements = {
             Statement("function definition", pos.line, pos.column)  # type: ignore
         }
-        return True
+
+        # visit body
+        # we're not gonna get FlattenSentinel or RemovalSentinel
+        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
+        return False
 
     def leave_FunctionDef(
         self, original_node: cst.FunctionDef, updated_node: cst.FunctionDef
     ) -> cst.FunctionDef:
         if (
-            self.async_function
+            self.new_body is not None
+            and self.async_function
             # updated_node does not have a position, so we must send original_node
             and self.check_function_exit(original_node)
             and self.should_autofix(original_node)
-            and isinstance(updated_node.body, cst.IndentedBlock)
+            and isinstance(self.new_body, cst.IndentedBlock)
         ):
             # insert checkpoint at the end of body
-            new_body = list(updated_node.body.body)
-            new_body.append(self.checkpoint_statement())
-            indentedblock = updated_node.body.with_changes(body=new_body)
-            updated_node = updated_node.with_changes(body=indentedblock)
+            new_body_block = list(self.new_body.body)
+            new_body_block.append(self.checkpoint_statement())
+            self.new_body = self.new_body.with_changes(body=new_body_block)
 
             self.ensure_imported_library()
 
+        if self.new_body is not None:
+            updated_node = updated_node.with_changes(body=self.new_body)
         self.restore_state(original_node)
+        # reset self.new_body
+        self.new_body = None
         return updated_node
 
     # error if function exit/return/yields with uncheckpointed statements
@@ -440,8 +581,8 @@ 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
+        # but don't see it as a cancel point for ASYNC100
+        self.checkpoint_schedule_point()
 
         # return original node to avoid problems with identity equality
         assert original_node.deep_equals(updated_node)
@@ -491,12 +632,47 @@ class Visitor91X(Flake8AsyncVisitor_cst, CommonVisitors):
             is not None
         )
 
+    def _checkpoint_with(self, node: cst.With, entry: bool):
+        """Conditionally checkpoints entry/exit of With.
+
+        If the `with` only contains calls to open_nursery/create_task_group, it's a
+        schedule point but not a cancellation point, so we treat it as a checkpoint
+        for async91x but not for async100.
+
+        Saves the name of the taskgroup/nursery if entry is set
+        """
+        if not getattr(node, "asynchronous", None):
+            return
+
+        for item in node.items:
+            if isinstance(item.item, cst.Call) and identifier_to_string(
+                item.item.func
+            ) in (
+                "trio.open_nursery",
+                "anyio.create_task_group",
+            ):
+                if item.asname is not None and isinstance(item.asname.name, cst.Name):
+                    # save the nursery/taskgroup to see if it has a `.start_soon`
+                    if entry:
+                        self.taskgroup_has_start_soon[item.asname.name.value] = False
+                    elif self.taskgroup_has_start_soon.pop(
+                        item.asname.name.value, False
+                    ):
+                        self.checkpoint()
+                        return
+            else:
+                self.checkpoint()
+                break
+        else:
+            # only taskgroup/nursery calls
+            self.checkpoint_schedule_point()
+
     # Async context managers can reasonably checkpoint on either or both of entry and
     # exit.  Given that we can't tell which, we assume "both" to avoid raising a
     # 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.checkpoint()
+        self.save_state(node, "taskgroup_has_start_soon", copy=True)
+        self._checkpoint_with(node, entry=True)
 
         # if this might suppress exceptions, we cannot treat anything inside it as
         # checkpointing.
@@ -548,6 +724,8 @@ class Visitor91X(Flake8AsyncVisitor_cst, CommonVisitors):
                 for res in self.node_dict[original_node]:
                     self.error(res.node, error_code="ASYNC912")
 
+        self.node_dict.pop(original_node, None)
+
         # if exception-suppressing, restore all uncheckpointed statements from
         # before the `with`.
         if self._is_exception_suppressing_context_manager(original_node):
@@ -555,8 +733,7 @@ class Visitor91X(Flake8AsyncVisitor_cst, CommonVisitors):
             self.restore_state(original_node)
             self.uncheckpointed_statements.update(prev_checkpoints)
 
-        if getattr(original_node, "asynchronous", None):
-            self.checkpoint()
+        self._checkpoint_with(original_node, entry=False)
         return updated_node
 
     # error if no checkpoint since earlier yield or function entry
@@ -569,7 +746,7 @@ class Visitor91X(Flake8AsyncVisitor_cst, CommonVisitors):
 
         # Treat as a checkpoint for ASYNC100, since the context we yield to
         # may checkpoint.
-        self.has_checkpoint_stack = [True] * len(self.has_checkpoint_stack)
+        self.checkpoint_cancel_point()
 
         if self.check_function_exit(original_node) and self.should_autofix(
             original_node
@@ -978,8 +1155,8 @@ class Visitor91X(Flake8AsyncVisitor_cst, CommonVisitors):
         return False
 
     # The generator target will be immediately evaluated, but the other
-    # elements will be lazily evaluated as the generator is consumed so we don't
-    # visit them as any checkpoints in them are not guaranteed to execute.
+    # elements will not be evaluated at the point of defining the GenExp.
+    # To consume those needs an explicit syntactic checkpoint
     def visit_GeneratorExp(self, node: cst.GeneratorExp):
         node.for_in.iter.visit(self)
         return False

{flake8_async-24.11.3 → flake8_async-25.2.2}/flake8_async/visitors/visitors.py

@@ -121,10 +121,10 @@ class Visitor112(Flake8AsyncVisitor):
             elif get_matching_call(
                 item.context_expr, "create_task_group", base="anyio"
             ):
-                nursery_type = "taskgroup"
+                nursery_type = "task group"
             # check for asyncio.TaskGroup
             elif get_matching_call(item.context_expr, "TaskGroup", base="asyncio"):
-                nursery_type = "taskgroup"
+                nursery_type = "task group"
                 start_methods = ("create_task",)
             else:
                 # incorrectly marked as not covered on py39
@@ -151,12 +151,12 @@ class Visitor112(Flake8AsyncVisitor):
 
 
 # used in 113 and 114
-STARTABLE_CALLS = (
+STARTABLE_CALLS = ("serve",)
+TRIO_STARTABLE_CALLS = (
     "run_process",
     "serve_ssl_over_tcp",
     "serve_tcp",
     "serve_listeners",
-    "serve",
 )
 
 
@@ -201,7 +201,11 @@ class Visitor113(Flake8AsyncVisitor):
             if isinstance(n, ast.Name):
                 return n.id in startable_list
             if isinstance(n, ast.Attribute):
-                return n.attr in startable_list
+                return n.attr in startable_list and not (
+                    n.attr in TRIO_STARTABLE_CALLS
+                    and isinstance(n.value, ast.Name)
+                    and n.value.id != "trio"
+                )
             if isinstance(n, ast.Call):
                 return any(is_startable(nn, *startable_list) for nn in n.args)
             return False
@@ -213,12 +217,16 @@ class Visitor113(Flake8AsyncVisitor):
             ):
                 return False
             var = ast.unparse(node.value)
-            return ("trio" in self.library and var.endswith("nursery")) or (
-                self.variables.get(var, "")
-                in (
-                    "trio.Nursery",
-                    "anyio.TaskGroup",
-                    "asyncio.TaskGroup",
+            return (
+                ("trio" in self.library and var.endswith("nursery"))
+                or ("anyio" in self.library and var.endswith("task_group"))
+                or (
+                    self.variables.get(var, "")
+                    in (
+                        "trio.Nursery",
+                        "anyio.TaskGroup",
+                        "asyncio.TaskGroup",
+                    )
                 )
             )
 
@@ -229,6 +237,7 @@ class Visitor113(Flake8AsyncVisitor):
             and is_startable(
                 node.args[0],
                 *STARTABLE_CALLS,
+                *TRIO_STARTABLE_CALLS,
                 *self.options.startable_in_context_manager,
             )
         ):
@@ -254,7 +263,11 @@ class Visitor114(Flake8AsyncVisitor):
             for n in self.walk(*node.args.args, *node.args.kwonlyargs)
         ) and not any(
             node.name == opt
-            for opt in (*self.options.startable_in_context_manager, *STARTABLE_CALLS)
+            for opt in (
+                *self.options.startable_in_context_manager,
+                *STARTABLE_CALLS,
+                *TRIO_STARTABLE_CALLS,
+            )
         ):
             self.error(node, node.name)
 
@@ -319,8 +332,10 @@ class Visitor116(Flake8AsyncVisitor):
 @error_class
 class Visitor119(Flake8AsyncVisitor):
     error_codes: Mapping[str, str] = {
-        "ASYNC119": "Yield in contextmanager in async generator might not trigger"
-        " cleanup. Use `@asynccontextmanager` or refactor."
+        "ASYNC119": (
+            "Yield in contextmanager in async generator might not trigger"
+            " cleanup. Use `@asynccontextmanager` or refactor."
+        )
     }
 
     def __init__(self, *args: Any, **kwargs: Any):
@@ -490,8 +505,10 @@ class Visitor300(Flake8AsyncVisitor_cst):
 @disabled_by_default
 class Visitor900(Flake8AsyncVisitor):
     error_codes: Mapping[str, str] = {
-        "ASYNC900": "Async generator not allowed, unless transformed "
-        "by a known decorator (one of: {})."
+        "ASYNC900": (
+            "Async generator not allowed, unless transformed "
+            "by a known decorator (one of: {})."
+        )
     }
 
     def __init__(self, *args: Any, **kwargs: Any):

{flake8_async-24.11.3 → flake8_async-25.2.2}/flake8_async.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.2
 Name: flake8-async
-Version: 24.11.3
+Version: 25.2.2
 Summary: A highly opinionated flake8 plugin for Trio-related problems.
 Author: Zac Hatfield-Dodds, John Litborn, and Contributors
 Author-email: zac@zhd.dev
@@ -21,9 +21,18 @@ Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Requires-Python: >=3.9
 Description-Content-Type: text/markdown
-License-File: LICENSE
 Requires-Dist: flake8>=6
 Requires-Dist: libcst>=1.0.1
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: license
+Dynamic: project-url
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
 
 [![Documentation](https://img.shields.io/badge/docs-read%20now-blue.svg)](https://flake8-async.readthedocs.io)
 [![Latest PyPi version](https://img.shields.io/pypi/v/flake8-async.svg)](https://pypi.org/project/flake8-async)

{flake8_async-24.11.3 → flake8_async-25.2.2}/flake8_async.egg-info/SOURCES.txt

@@ -32,9 +32,9 @@ flake8_async/visitors/visitor91x.py
 flake8_async/visitors/visitor_utility.py
 flake8_async/visitors/visitors.py
 tests/__init__.py
+tests/check_changelog_and_version.py
 tests/conftest.py
 tests/test_all_visitors_imported.py
-tests/test_changelog_and_version.py
 tests/test_config_and_args.py
 tests/test_decorator.py
 tests/test_exception_on_invalid_code.py
@@ -45,12 +45,13 @@ tests/trio_options.py
 tests/autofix_files/async100.py
 tests/autofix_files/async100_asyncio.py
 tests/autofix_files/async100_simple_autofix.py
-tests/autofix_files/async100_trio.py
+tests/autofix_files/async124.py
 tests/autofix_files/async910.py
 tests/autofix_files/async910_insert_library.py
 tests/autofix_files/async911.py
 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/exception_suppress_context_manager.py
 tests/autofix_files/exception_suppress_context_manager_import_star.py
@@ -61,11 +62,8 @@ tests/eval_files/async100.py
 tests/eval_files/async100_asyncio.py
 tests/eval_files/async100_noautofix.py
 tests/eval_files/async100_simple_autofix.py
-tests/eval_files/async100_trio.py
 tests/eval_files/async101.py
-tests/eval_files/async101_anyio.py
 tests/eval_files/async101_asyncio.py
-tests/eval_files/async101_trio.py
 tests/eval_files/async102.py
 tests/eval_files/async102_aclose.py
 tests/eval_files/async102_aclose_args.py
@@ -86,13 +84,10 @@ tests/eval_files/async106.py
 tests/eval_files/async109.py
 tests/eval_files/async110.py
 tests/eval_files/async111.py
-tests/eval_files/async111_anyio.py
 tests/eval_files/async111_asyncio.py
 tests/eval_files/async112.py
-tests/eval_files/async112_anyio.py
 tests/eval_files/async112_asyncio.py
 tests/eval_files/async113.py
-tests/eval_files/async113_anyio.py
 tests/eval_files/async113_asyncio.py
 tests/eval_files/async113_trio.py
 tests/eval_files/async114.py
@@ -107,6 +102,8 @@ tests/eval_files/async121_asyncio.py
 tests/eval_files/async122.py
 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/async200.py
 tests/eval_files/async210.py
 tests/eval_files/async211.py
@@ -131,6 +128,7 @@ tests/eval_files/async911_insert_library.py
 tests/eval_files/async912.py
 tests/eval_files/async912_asyncio.py
 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/exception_suppress_context_manager.py