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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: flake8-async
-Version: 25.2.3
+Version: 25.3.1
 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.2.3 → flake8_async-25.3.1}/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.2.3"
+__version__ = "25.3.1"
 
 
 # taken from https://github.com/Zac-HD/shed
@@ -138,7 +138,7 @@ class Plugin:
         self.module: cst.Module = cst_parse_module_native(source)
 
     @classmethod
-    def from_filename(cls, filename: str | PathLike[str]) -> Plugin:  # pragma: no cover
+    def from_filename(cls, filename: str | PathLike[str]) -> Plugin:
         # only used with --runslow
         with tokenize.open(filename) as f:
             source = f.read()
@@ -204,7 +204,7 @@ class Plugin:
                     'lines with "# noqa" at the end.'
                 ),
             )
-        else:  # if run as a flake8 plugin
+        else:  # pragma: no-cov-no-flake8
             Plugin.standalone = False
             # Disable ASYNC9xx calls by default
             option_manager.extend_default_ignore(default_disabled_error_codes)
@@ -380,7 +380,7 @@ class Plugin:
         }
         assert all_codes
 
-        if options.autofix and not Plugin.standalone:
+        if options.autofix and not Plugin.standalone:  # pragma: no-cov-no-flake8
             print("Cannot autofix when run as a flake8 plugin.", file=sys.stderr)
             sys.exit(1)
         autofix_codes = set(get_matching_codes(options.autofix, all_codes))
@@ -457,6 +457,7 @@ def parse_async200_dict(raw_value: str) -> dict[str, str]:
 
 
 # not run if flake8 is installed
+# TODO: this is not tested at all atm, I'm not even sure if it works
 def parse_per_file_disable(  # pragma: no cover
     raw_value: str,
 ) -> dict[str, tuple[str, ...]]:

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

@@ -371,7 +371,7 @@ def with_has_call(
 
     """
     if isinstance(base, str):
-        base = (base,)  # pragma: no cover
+        base = (base,)
 
     # build matcher, using SaveMatchedNode to save the base and the function name.
     matcher = m.Call(

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

@@ -149,7 +149,7 @@ class Visitor102(Flake8AsyncVisitor):
                 break
         self.visit_With(node)
 
-    def visit_Try(self, node: ast.Try):
+    def visit_Try(self, node: ast.Try | ast.TryStar):  # type: ignore[name-defined]
         self.save_state(
             node, "_critical_scope", "_trio_context_managers", "cancelled_caught"
         )
@@ -165,6 +165,8 @@ class Visitor102(Flake8AsyncVisitor):
         self._critical_scope = Statement("try/finally", node.lineno, node.col_offset)
         self.visit_nodes(node.finalbody)
 
+    visit_TryStar = visit_Try
+
     def visit_ExceptHandler(self, node: ast.ExceptHandler):
         # if we're inside a critical scope, a nested except should never override that
         if self._critical_scope is not None and self._critical_scope.name != "except":

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

@@ -160,7 +160,7 @@ class Visitor103_104(Flake8AsyncVisitor):
     visit_Yield = visit_Return
 
     # Treat Try's as fully covering only if `finally` always raises.
-    def visit_Try(self, node: ast.Try):
+    def visit_Try(self, node: ast.Try | ast.TryStar):  # type: ignore[name-defined]
         self.save_state(node, "cancelled_caught", copy=True)
         self.cancelled_caught = set()
 
@@ -179,6 +179,8 @@ class Visitor103_104(Flake8AsyncVisitor):
         # but it's fine if we raise in finally
         self.visit_nodes(node.finalbody)
 
+    visit_TryStar = visit_Try
+
     # Treat if's as fully covering if both `if` and `else` raise.
     # `elif` is parsed by the ast as a new if statement inside the else.
     def visit_If(self, node: ast.If):

{flake8_async-25.2.3 → flake8_async-25.3.1}/flake8_async/visitors/visitor123.py

@@ -78,8 +78,7 @@ class Visitor123(Flake8AsyncVisitor):
         self.exception_group_names = {node.name}
 
     # ast.TryStar added in py311
-    # we run strict codecov on all python versions, this one doesn't run on <py311
-    def visit_TryStar(self, node: ast.TryStar):  # type: ignore[name-defined]  # pragma: no cover
+    def visit_TryStar(self, node: ast.TryStar):  # type: ignore[name-defined]  # pragma: no-cov-py-lt-311
         self.save_state(node, "try_star", copy=False)
         self.try_star = True
 

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

@@ -386,7 +386,7 @@ class Visitor91X(Flake8AsyncVisitor_cst, CommonVisitors):
         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
+        if code is None:
             code = "ASYNC911" if self.has_yield else "ASYNC910"
 
         return (
@@ -768,7 +768,7 @@ class Visitor91X(Flake8AsyncVisitor_cst, CommonVisitors):
     # try can jump into any except or into the finally* at any point during it's
     # execution so we need to make sure except & finally can handle worst-case
     # * unless there's a bare except / except BaseException - not implemented.
-    def visit_Try(self, node: cst.Try):
+    def visit_Try(self, node: cst.Try | cst.TryStar):
         if not self.async_function:
             return
         self.save_state(node, "try_state", copy=True)
@@ -784,39 +784,41 @@ class Visitor91X(Flake8AsyncVisitor_cst, CommonVisitors):
                 Statement("yield", pos.line, pos.column)  # type: ignore
             )
 
-    def leave_Try_body(self, node: cst.Try):
+    def leave_Try_body(self, node: cst.Try | cst.TryStar):
         # save state at end of try for entering else
         self.try_state.try_checkpoint = self.uncheckpointed_statements
 
         # check that all except handlers checkpoint (await or most likely raise)
         self.try_state.except_uncheckpointed_statements = set()
 
-    def visit_ExceptHandler(self, node: cst.ExceptHandler):
+    def visit_ExceptHandler(self, node: cst.ExceptHandler | cst.ExceptStarHandler):
         # enter with worst case of try
         self.uncheckpointed_statements = (
             self.try_state.body_uncheckpointed_statements.copy()
         )
 
     def leave_ExceptHandler(
-        self, original_node: cst.ExceptHandler, updated_node: cst.ExceptHandler
-    ) -> cst.ExceptHandler:
+        self,
+        original_node: cst.ExceptHandler | cst.ExceptStarHandler,
+        updated_node: cst.ExceptHandler | cst.ExceptStarHandler,
+    ) -> Any:  # not worth creating a TypeVar to handle correctly
         self.try_state.except_uncheckpointed_statements.update(
             self.uncheckpointed_statements
         )
         return updated_node
 
-    def visit_Try_orelse(self, node: cst.Try):
+    def visit_Try_orelse(self, node: cst.Try | cst.TryStar):
         # check else
         # if else runs it's after all of try, so restore state to back then
         self.uncheckpointed_statements = self.try_state.try_checkpoint
 
-    def leave_Try_orelse(self, node: cst.Try):
+    def leave_Try_orelse(self, node: cst.Try | cst.TryStar):
         # checkpoint if else checkpoints, and all excepts checkpoint
         self.uncheckpointed_statements.update(
             self.try_state.except_uncheckpointed_statements
         )
 
-    def visit_Try_finalbody(self, node: cst.Try):
+    def visit_Try_finalbody(self, node: cst.Try | cst.TryStar):
         if node.finalbody:
             self.try_state.added = (
                 self.try_state.body_uncheckpointed_statements.difference(
@@ -835,14 +837,26 @@ class Visitor91X(Flake8AsyncVisitor_cst, CommonVisitors):
             ):
                 self.uncheckpointed_statements.update(self.try_state.added)
 
-    def leave_Try_finalbody(self, node: cst.Try):
+    def leave_Try_finalbody(self, node: cst.Try | cst.TryStar):
         if node.finalbody:
             self.uncheckpointed_statements.difference_update(self.try_state.added)
 
-    def leave_Try(self, original_node: cst.Try, updated_node: cst.Try) -> cst.Try:
+    def leave_Try(
+        self, original_node: cst.Try | cst.TryStar, updated_node: cst.Try | cst.TryStar
+    ) -> cst.Try | cst.TryStar:
         self.restore_state(original_node)
         return updated_node
 
+    visit_TryStar = visit_Try
+    leave_TryStar = leave_Try
+    leave_TryStar_body = leave_Try_body
+    visit_TryStar_orelse = visit_Try_orelse
+    leave_TryStar_orelse = leave_Try_orelse
+    visit_TryStar_finalbody = visit_Try_finalbody
+    leave_TryStar_finalbody = leave_Try_finalbody
+    visit_ExceptStarHandler = visit_ExceptHandler
+    leave_ExceptStarHandler = leave_ExceptHandler
+
     def leave_If_test(self, node: cst.If | cst.IfExp) -> None:
         if not self.async_function:
             return

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: flake8-async
-Version: 25.2.3
+Version: 25.3.1
 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.2.3 → flake8_async-25.3.1}/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_py311.py
 tests/autofix_files/exception_suppress_context_manager.py
 tests/autofix_files/exception_suppress_context_manager_import_star.py
 tests/autofix_files/noqa.py
@@ -65,12 +66,14 @@ tests/eval_files/async100_simple_autofix.py
 tests/eval_files/async101.py
 tests/eval_files/async101_asyncio.py
 tests/eval_files/async102.py
+tests/eval_files/async102_120_py311.py
 tests/eval_files/async102_aclose.py
 tests/eval_files/async102_aclose_args.py
 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_py311.py
 tests/eval_files/async103_all_imported.py
 tests/eval_files/async103_both_imported.py
 tests/eval_files/async103_no_104.py
@@ -127,10 +130,12 @@ tests/eval_files/async911.py
 tests/eval_files/async911_insert_library.py
 tests/eval_files/async912.py
 tests/eval_files/async912_asyncio.py
+tests/eval_files/async912_py311.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/async91x_py311.py
 tests/eval_files/exception_suppress_context_manager.py
 tests/eval_files/exception_suppress_context_manager_import_star.py
 tests/eval_files/no_library.py

{flake8_async-25.2.3 → flake8_async-25.3.1}/pyproject.toml

@@ -14,6 +14,34 @@ force-exclude = "tests/autofix_files/.*.py"
 [tool.codespell]
 ignore-words-list = 'spawnve'
 
+[tool.coverage.coverage_conditional_plugin.rules]
+no-cov-has-flake8 = "is_installed('flake8')"
+no-cov-no-flake8 = "not is_installed('flake8')"
+no-cov-py-lt-311 = "sys.version_info < (3, 11)"
+
+[tool.coverage.paths]
+source = [
+  "flake8_async",
+  "*/site-packages/flake8_async"
+]
+
+[tool.coverage.report]
+exclude_lines = [
+  # Have to re-enable the standard pragma
+  "pragma: no cover",
+  # Don't complain about abstract methods, they aren't run:
+  "@(abc\\.)?abstractmethod",
+  # Don't check guarded type imports
+  "if (typing.)?TYPE_CHECKING:"
+]
+fail_under = 100
+skip_covered = true
+skip_empty = true
+
+[tool.coverage.run]
+branch = true
+plugins = ["coverage_conditional_plugin"]
+
 [tool.isort]
 only_modified = true
 profile = "black"
@@ -45,6 +73,10 @@ reportUnnecessaryTypeIgnoreComment = false
 reportUnusedCallResult = false
 strict = ["*.py", "tests/*.py", "flake8_async/**/*.py"]
 
+[tool.pytest.ini_options]
+filterwarnings = ["error"]
+testpaths = ["tests"]
+
 [tool.ruff]
 extend-exclude = [
   ".*",

flake8_async-25.3.1/tests/autofix_files/async91x_py311.py

@@ -0,0 +1,97 @@
+"""Test for ASYNC91x rules with except* blocks.
+
+ASYNC910: async-function-no-checkpoint
+ASYNC911: async-generator-no-checkpoint
+ASYNC913: indefinite-loop-no-guaranteed-checkpoint
+
+async912 handled in separate file
+"""
+
+# ARG --enable=ASYNC910,ASYNC911,ASYNC913
+# AUTOFIX
+# ASYNCIO_NO_AUTOFIX
+import trio
+
+
+async def foo(): ...
+
+
+async def foo_try_except_star_1():  # ASYNC910: 0, "exit", Statement("function definition", lineno)
+    try:
+        await foo()
+    except* ValueError:
+        ...
+    except* RuntimeError:
+        raise
+    else:
+        await foo()
+    await trio.lowlevel.checkpoint()
+
+
+async def foo_try_except_star_2():  # safe
+    try:
+        ...
+    except* ValueError:
+        ...
+    finally:
+        await foo()
+
+
+async def foo_try_except_star_3():  # safe
+    try:
+        await foo()
+    except* ValueError:
+        raise
+
+
+# Multiple except* handlers - should all guarantee checkpoint/raise
+async def foo_try_except_star_4():
+    try:
+        await foo()
+    except* ValueError:
+        await foo()
+    except* TypeError:
+        raise
+    except* Exception:
+        raise
+
+
+async def try_else_no_raise_in_except():  # ASYNC910: 0, "exit", Statement("function definition", lineno)
+    try:
+        ...
+    except* ValueError:
+        ...
+    else:
+        await foo()
+    await trio.lowlevel.checkpoint()
+
+
+async def try_else_raise_in_except():
+    try:
+        ...
+    except* ValueError:
+        raise
+    else:
+        await foo()
+
+
+async def check_async911():  # ASYNC911: 0, "exit", Statement("yield", lineno+7)
+    try:
+        await foo()
+    except* ValueError:
+        ...
+    except* RuntimeError:
+        raise
+    await trio.lowlevel.checkpoint()
+    yield  # ASYNC911: 4, "yield", Statement("function definition", lineno-7)
+    await trio.lowlevel.checkpoint()
+
+
+async def check_async913():
+    while True:  # ASYNC913: 4
+        await trio.lowlevel.checkpoint()
+        try:
+            await foo()
+        except* ValueError:
+            # Missing checkpoint
+            ...

flake8_async-25.3.1/tests/eval_files/async102_120_py311.py

@@ -0,0 +1,29 @@
+"""Test for ASYNC102/ASYNC120 with except*
+
+ASYNC102: await-in-finally-or-cancelled
+
+ASYNC120: await-in-except
+"""
+
+# type: ignore
+# ARG --enable=ASYNC102,ASYNC120
+# NOASYNCIO # TODO: support asyncio shields
+import trio
+
+
+async def foo():
+    try:
+        ...
+    except* ValueError:
+        await foo()  # ASYNC120: 8, Statement("except", lineno-1)
+        raise
+    except* BaseException:
+        await foo()  # ASYNC102: 8, Statement("BaseException", lineno-1)
+    finally:
+        await foo()  # ASYNC102: 8, Statement("try/finally", lineno-8)
+
+    try:
+        ...
+    except* BaseException:
+        with trio.move_on_after(30, shield=True):
+            await foo()

flake8_async-25.3.1/tests/eval_files/async103_104_py311.py

@@ -0,0 +1,40 @@
+"""Test for ASYNC103/ASYNC104 with except* blocks.
+
+ASYNC103: no-reraise-cancelled
+ASYNC104: cancelled-not-raised
+"""
+
+# ARG --enable=ASYNC103,ASYNC104
+
+try:
+    ...
+except* BaseException:  # ASYNC103_trio: 8, "BaseException"
+    ...
+
+try:
+    ...
+except* BaseException:
+    raise
+
+try:
+    ...
+except* ValueError:
+    ...
+except* BaseException:  # ASYNC103_trio: 8, "BaseException"
+    ...
+
+try:
+    ...
+except* BaseException:
+    raise ValueError  # ASYNC104: 4
+
+
+def foo():
+    try:
+        ...
+    except* BaseException:  # ASYNC103_trio: 12, "BaseException"
+        return  # ASYNC104: 8
+    try:
+        ...
+    except* BaseException:
+        raise ValueError  # ASYNC104: 8

flake8_async-25.3.1/tests/eval_files/async912_py311.py

@@ -0,0 +1,16 @@
+# ASYNC912 can't be tested with the other 91x rules since there's no universal
+# cancelscope name across trio/asyncio/anyio - so we need ASYNCIO_NO_ERROR
+
+
+# ASYNCIO_NO_ERROR
+async def foo(): ...
+
+
+async def check_async912():
+    with trio.move_on_after(30):  # ASYNC912: 9
+        try:
+            await foo()
+        except* ValueError:
+            # Missing checkpoint
+            ...
+    await foo()

flake8_async-25.3.1/tests/eval_files/async91x_py311.py

@@ -0,0 +1,92 @@
+"""Test for ASYNC91x rules with except* blocks.
+
+ASYNC910: async-function-no-checkpoint
+ASYNC911: async-generator-no-checkpoint
+ASYNC913: indefinite-loop-no-guaranteed-checkpoint
+
+async912 handled in separate file
+"""
+
+# ARG --enable=ASYNC910,ASYNC911,ASYNC913
+# AUTOFIX
+# ASYNCIO_NO_AUTOFIX
+import trio
+
+
+async def foo(): ...
+
+
+async def foo_try_except_star_1():  # ASYNC910: 0, "exit", Statement("function definition", lineno)
+    try:
+        await foo()
+    except* ValueError:
+        ...
+    except* RuntimeError:
+        raise
+    else:
+        await foo()
+
+
+async def foo_try_except_star_2():  # safe
+    try:
+        ...
+    except* ValueError:
+        ...
+    finally:
+        await foo()
+
+
+async def foo_try_except_star_3():  # safe
+    try:
+        await foo()
+    except* ValueError:
+        raise
+
+
+# Multiple except* handlers - should all guarantee checkpoint/raise
+async def foo_try_except_star_4():
+    try:
+        await foo()
+    except* ValueError:
+        await foo()
+    except* TypeError:
+        raise
+    except* Exception:
+        raise
+
+
+async def try_else_no_raise_in_except():  # ASYNC910: 0, "exit", Statement("function definition", lineno)
+    try:
+        ...
+    except* ValueError:
+        ...
+    else:
+        await foo()
+
+
+async def try_else_raise_in_except():
+    try:
+        ...
+    except* ValueError:
+        raise
+    else:
+        await foo()
+
+
+async def check_async911():  # ASYNC911: 0, "exit", Statement("yield", lineno+7)
+    try:
+        await foo()
+    except* ValueError:
+        ...
+    except* RuntimeError:
+        raise
+    yield  # ASYNC911: 4, "yield", Statement("function definition", lineno-7)
+
+
+async def check_async913():
+    while True:  # ASYNC913: 4
+        try:
+            await foo()
+        except* ValueError:
+            # Missing checkpoint
+            ...

{flake8_async-25.2.3 → flake8_async-25.3.1}/tests/test_config_and_args.py

@@ -282,6 +282,24 @@ def test_async200_from_config_subprocess(tmp_path: Path):
     assert res.stdout == err_msg.encode("ascii")
 
 
+def test_trio200_warning(tmp_path: Path):
+    fpath = tmp_path / "foo.py"
+    fpath.touch()
+    res = subprocess.run(
+        ["flake8-async", "--trio200-blocking-calls=foo->bar", "foo.py"],
+        cwd=tmp_path,
+        capture_output=True,
+        check=False,
+        encoding="utf8",
+    )
+    assert res.returncode == 0
+    assert res.stderr.endswith(
+        "UserWarning: trio200-blocking-calls has been deprecated in favor of "
+        "async200-blocking-calls\n  warnings.warn(\n"
+    )
+    assert not res.stdout
+
+
 @pytest.mark.skipif(flake8 is None, reason="flake8 is not installed")
 def test_async200_from_config_subprocess_cli_ignore(tmp_path: Path):
     _ = _test_async200_from_config_common(tmp_path)
@@ -297,7 +315,7 @@ def test_async200_from_config_subprocess_cli_ignore(tmp_path: Path):
     assert res.returncode == 0
 
 
-def test_900_default_off(capsys: pytest.CaptureFixture[str]):
+def test_900_default_off():
     res = subprocess.run(
         ["flake8-async", "tests/eval_files/async900.py"],
         capture_output=True,

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

@@ -422,6 +422,10 @@ def _parse_eval_file(
         if not line or line[0] == "#":
             continue
 
+        # skip lines that *don't* have a comment
+        if "#" not in line:
+            continue
+
         # get text between `error:` and (end of line or another comment)
         k = re.findall(r"(error|ASYNC...)(_.*)?:([^#]*)(?=#|$)", line)
 
@@ -539,6 +543,7 @@ class SyncTransformer(ast.NodeTransformer):
 def test_noerror_on_sync_code(test: str, path: Path):
     if any(e in test for e in error_codes_ignored_when_checking_transformed_sync_code):
         return
+    check_version(test)
     with tokenize.open(path) as f:
         source = f.read()
     tree = SyncTransformer().visit(ast.parse(source))

{flake8_async-25.2.3 → flake8_async-25.3.1}/tox.ini

@@ -11,14 +11,16 @@ deps =
     flake8_7: flake8>=7.0
     flake8_6: flake8>=6.0, <7.0
     pytest
-    pytest-cov
+    pytest-cov  # to make it easy to pass --no-cov
+    coverage
+    coverage-conditional-plugin
     pytest-xdist
     hypothesis
     # 0.3.3 adds py313 support
     hypothesmith >= 0.3.3
     trio
 commands =
-    pytest {posargs:-n auto}
+    coverage run -m pytest {posargs:-n auto}
 
 [testenv:docs]
 description = Generate docs locally
@@ -32,29 +34,3 @@ skip_install = True
 commands =
     make clean
     make html
-
-# Settings for other tools
-[pytest]
-addopts =
-    --cov=flake8_async
-    --cov-branch
-    --cov-report=term-missing:skip-covered
-    --cov-fail-under=100
-filterwarnings =
-    error
-
-[coverage:paths]
-source =
-    flake8_async
-    */site-packages/flake8_async
-
-[coverage:report]
-exclude_lines =
-    # Have to re-enable the standard pragma
-    pragma: no cover
-
-    # Don't complain about abstract methods, they aren't run:
-    @(abc\.)?abstractmethod
-
-    # Don't check guarded type imports
-    if (typing.)?TYPE_CHECKING: