flake8-async 24.3.4__tar.gz → 24.3.6__tar.gz

{flake8-async-24.3.4 → flake8-async-24.3.6}/CHANGELOG.md

@@ -1,8 +1,14 @@
 # Changelog
 *[CalVer, YY.month.patch](https://calver.org/)*
 
+## 24.3.6
+- ASYNC100 no longer triggers if a context manager contains a `yield`.
+
+## 24.3.5
+- ASYNC102 (no await inside finally or critical except) no longer raises warnings for calls to `aclose()` on objects in trio/anyio code. See https://github.com/python-trio/flake8-async/issues/156
+
 ## 24.3.4
-- ASYNC110 (don't loop sleep) now also warns if looping `[trio/anyio].lowlevel.checkpoint()`
+- ASYNC110 (don't loop sleep) now also warns if looping `[trio/anyio].lowlevel.checkpoint()`.
 
 ## 24.3.3
 - Add ASYNC251: `time.sleep()` in async method.

{flake8-async-24.3.4 → flake8-async-24.3.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: flake8-async
-Version: 24.3.4
+Version: 24.3.6
 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
@@ -50,7 +50,7 @@ pip install flake8-async
 ## List of warnings
 - **ASYNC100**: A `with [trio/anyio].fail_after(...):` or `with [trio/anyio].move_on_after(...):`
   context does not contain any `await` statements.  This makes it pointless, as
-  the timeout can only be triggered by a checkpoint.
+  the timeout can only be triggered by a checkpoint. This check also allows `yield` statements, since checkpoints can happen in the caller we yield to.
 - **ASYNC101**: `yield` inside a trio/anyio nursery or cancel scope is only safe when implementing a context manager - otherwise, it breaks exception handling.
 - **ASYNC102**: It's unsafe to await inside `finally:` or `except BaseException/trio.Cancelled/anyio.get_cancelled_exc_class()/asyncio.exceptions.CancelledError` unless you use a shielded cancel scope with a timeout. This is currently not able to detect asyncio shields.
 - **ASYNC103**: `except BaseException/trio.Cancelled/anyio.get_cancelled_exc_class()/asyncio.exceptions.CancelledError`, or a bare `except:` with a code path that doesn't re-raise. If you don't want to re-raise `BaseException`, add a separate handler for `trio.Cancelled`/`anyio.get_cancelled_exc_class()`/`asyncio.exceptions.CancelledError` before.
@@ -109,7 +109,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.3.4
+  rev: 24.3.6
   hooks:
     - id: flake8-async
       # args: [--enable=ASYNC, --disable=ASYNC9, --autofix=ASYNC]
@@ -221,8 +221,14 @@ async def my_function():
 # Changelog
 *[CalVer, YY.month.patch](https://calver.org/)*
 
+## 24.3.6
+- ASYNC100 no longer triggers if a context manager contains a `yield`.
+
+## 24.3.5
+- ASYNC102 (no await inside finally or critical except) no longer raises warnings for calls to `aclose()` on objects in trio/anyio code. See https://github.com/python-trio/flake8-async/issues/156
+
 ## 24.3.4
-- ASYNC110 (don't loop sleep) now also warns if looping `[trio/anyio].lowlevel.checkpoint()`
+- ASYNC110 (don't loop sleep) now also warns if looping `[trio/anyio].lowlevel.checkpoint()`.
 
 ## 24.3.3
 - Add ASYNC251: `time.sleep()` in async method.

{flake8-async-24.3.4 → flake8-async-24.3.6}/README.md

@@ -25,7 +25,7 @@ pip install flake8-async
 ## List of warnings
 - **ASYNC100**: A `with [trio/anyio].fail_after(...):` or `with [trio/anyio].move_on_after(...):`
   context does not contain any `await` statements.  This makes it pointless, as
-  the timeout can only be triggered by a checkpoint.
+  the timeout can only be triggered by a checkpoint. This check also allows `yield` statements, since checkpoints can happen in the caller we yield to.
 - **ASYNC101**: `yield` inside a trio/anyio nursery or cancel scope is only safe when implementing a context manager - otherwise, it breaks exception handling.
 - **ASYNC102**: It's unsafe to await inside `finally:` or `except BaseException/trio.Cancelled/anyio.get_cancelled_exc_class()/asyncio.exceptions.CancelledError` unless you use a shielded cancel scope with a timeout. This is currently not able to detect asyncio shields.
 - **ASYNC103**: `except BaseException/trio.Cancelled/anyio.get_cancelled_exc_class()/asyncio.exceptions.CancelledError`, or a bare `except:` with a code path that doesn't re-raise. If you don't want to re-raise `BaseException`, add a separate handler for `trio.Cancelled`/`anyio.get_cancelled_exc_class()`/`asyncio.exceptions.CancelledError` before.
@@ -84,7 +84,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.3.4
+  rev: 24.3.6
   hooks:
     - id: flake8-async
       # args: [--enable=ASYNC, --disable=ASYNC9, --autofix=ASYNC]

{flake8-async-24.3.4 → flake8-async-24.3.6}/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.3.4"
+__version__ = "24.3.6"
 
 
 # taken from https://github.com/Zac-HD/shed

{flake8-async-24.3.4 → flake8-async-24.3.6}/flake8_async/visitors/visitor100.py

@@ -74,9 +74,11 @@ class Visitor100_libcst(Flake8AsyncVisitor_cst):
         if node.asynchronous is not None:
             self.checkpoint()
 
-    def visit_Await(self, node: cst.Await | cst.For | cst.With):
+    def visit_Await(self, node: cst.Await | cst.Yield):
         self.checkpoint()
 
+    visit_Yield = visit_Await
+
     def visit_FunctionDef(self, node: cst.FunctionDef):
         self.save_state(node, "has_checkpoint_stack", copy=True)
         self.has_checkpoint_stack = []

{flake8-async-24.3.4 → flake8-async-24.3.6}/flake8_async/visitors/visitor102.py

@@ -52,15 +52,35 @@ class Visitor102(Flake8AsyncVisitor):
         self._trio_context_managers: list[Visitor102.TrioScope] = []
         self.cancelled_caught = False
 
-    # if we're inside a finally, and we're not inside a scope that doesn't have
-    # both a timeout and shield
-    def visit_Await(self, node: ast.Await | ast.AsyncFor | ast.AsyncWith):
+    # if we're inside a finally or critical except, and we're not inside a scope that
+    # doesn't have both a timeout and shield
+    def async_call_checker(
+        self, node: ast.Await | ast.AsyncFor | ast.AsyncWith
+    ) -> None:
         if self._critical_scope is not None and not any(
             cm.has_timeout and cm.shielded for cm in self._trio_context_managers
         ):
             self.error(node, self._critical_scope)
 
-    visit_AsyncFor = visit_Await
+    def is_safe_aclose_call(self, node: ast.Await) -> bool:
+        return (
+            # don't mark calls safe in asyncio-only files
+            # a more defensive option would be `asyncio not in self.library`
+            self.library != ("asyncio",)
+            and isinstance(node.value, ast.Call)
+            # only known safe if no arguments
+            and not node.value.args
+            and not node.value.keywords
+            and isinstance(node.value.func, ast.Attribute)
+            and node.value.func.attr == "aclose"
+        )
+
+    def visit_Await(self, node: ast.Await):
+        # allow calls to `.aclose()`
+        if not (self.is_safe_aclose_call(node)):
+            self.async_call_checker(node)
+
+    visit_AsyncFor = async_call_checker
 
     def visit_With(self, node: ast.With | ast.AsyncWith):
         self.save_state(node, "_trio_context_managers", copy=True)
@@ -82,7 +102,7 @@ class Visitor102(Flake8AsyncVisitor):
             break
 
     def visit_AsyncWith(self, node: ast.AsyncWith):
-        self.visit_Await(node)
+        self.async_call_checker(node)
         self.visit_With(node)
 
     def visit_Try(self, node: ast.Try):
@@ -94,6 +114,10 @@ class Visitor102(Flake8AsyncVisitor):
         self.visit_nodes(node.body, node.handlers, node.orelse)
 
         self._trio_context_managers = []
+        # node.finalbody does not have a lineno, so we give the position of the try
+        # it'd be possible to estimate the lineno given the last except and the first
+        # statement in the finally, but it would be very hard to get it perfect with
+        # comments and empty lines and stuff.
         self._critical_scope = Statement("try/finally", node.lineno, node.col_offset)
         self.visit_nodes(node.finalbody)
 

{flake8-async-24.3.4 → flake8-async-24.3.6}/flake8_async.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: flake8-async
-Version: 24.3.4
+Version: 24.3.6
 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
@@ -50,7 +50,7 @@ pip install flake8-async
 ## List of warnings
 - **ASYNC100**: A `with [trio/anyio].fail_after(...):` or `with [trio/anyio].move_on_after(...):`
   context does not contain any `await` statements.  This makes it pointless, as
-  the timeout can only be triggered by a checkpoint.
+  the timeout can only be triggered by a checkpoint. This check also allows `yield` statements, since checkpoints can happen in the caller we yield to.
 - **ASYNC101**: `yield` inside a trio/anyio nursery or cancel scope is only safe when implementing a context manager - otherwise, it breaks exception handling.
 - **ASYNC102**: It's unsafe to await inside `finally:` or `except BaseException/trio.Cancelled/anyio.get_cancelled_exc_class()/asyncio.exceptions.CancelledError` unless you use a shielded cancel scope with a timeout. This is currently not able to detect asyncio shields.
 - **ASYNC103**: `except BaseException/trio.Cancelled/anyio.get_cancelled_exc_class()/asyncio.exceptions.CancelledError`, or a bare `except:` with a code path that doesn't re-raise. If you don't want to re-raise `BaseException`, add a separate handler for `trio.Cancelled`/`anyio.get_cancelled_exc_class()`/`asyncio.exceptions.CancelledError` before.
@@ -109,7 +109,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.3.4
+  rev: 24.3.6
   hooks:
     - id: flake8-async
       # args: [--enable=ASYNC, --disable=ASYNC9, --autofix=ASYNC]
@@ -221,8 +221,14 @@ async def my_function():
 # Changelog
 *[CalVer, YY.month.patch](https://calver.org/)*
 
+## 24.3.6
+- ASYNC100 no longer triggers if a context manager contains a `yield`.
+
+## 24.3.5
+- ASYNC102 (no await inside finally or critical except) no longer raises warnings for calls to `aclose()` on objects in trio/anyio code. See https://github.com/python-trio/flake8-async/issues/156
+
 ## 24.3.4
-- ASYNC110 (don't loop sleep) now also warns if looping `[trio/anyio].lowlevel.checkpoint()`
+- ASYNC110 (don't loop sleep) now also warns if looping `[trio/anyio].lowlevel.checkpoint()`.
 
 ## 24.3.3
 - Add ASYNC251: `time.sleep()` in async method.

{flake8-async-24.3.4 → flake8-async-24.3.6}/flake8_async.egg-info/SOURCES.txt

@@ -56,6 +56,8 @@ tests/eval_files/async100_noautofix.py
 tests/eval_files/async100_simple_autofix.py
 tests/eval_files/async101.py
 tests/eval_files/async102.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

{flake8-async-24.3.4 → flake8-async-24.3.6}/tests/autofix_files/async100.py

@@ -114,3 +114,9 @@ async def more_nested_tests():
     with contextlib.suppress(Exception):
         with open("blah") as file:
             print("foo")
+
+
+# Don't trigger for blocks with a yield statement
+async def foo():
+    with trio.fail_after(1):
+        yield

{flake8-async-24.3.4 → flake8-async-24.3.6}/tests/autofix_files/noqa.py

@@ -1,47 +1,57 @@
 # AUTOFIX
 # NOASYNCIO - does not trigger on ASYNC100
-# ARG --enable=ASYNC100,ASYNC911
+# ARG --enable=ASYNC100,ASYNC911,ASYNC910
 from typing import Any
 
 import trio
 
 
+def foo() -> bool:
+    return False
+
+
 # fmt: off
 async def foo_no_noqa():
-    await trio.lowlevel.checkpoint()
     # ASYNC100: 9, 'trio', 'fail_after'
-    yield  # ASYNC911: 8, "yield", Statement("function definition", lineno-2)
+    if foo():
+        await trio.lowlevel.checkpoint()
+        return  # ASYNC910: 12, "return", Statement("function definition", lineno-3)
     await trio.lowlevel.checkpoint()
 
 
 async def foo_noqa_bare():
     with trio.fail_after(5):  # noqa
-        yield  # noqa
+        if foo():
+            return  # noqa
     await trio.lowlevel.checkpoint()
 
 
 async def foo_noqa_100():
     with trio.fail_after(5):  # noqa: ASYNC100
-        await trio.lowlevel.checkpoint()
-        yield  # ASYNC911: 8, "yield", Statement("function definition", lineno-2)
+        if foo():
+            await trio.lowlevel.checkpoint()
+            return  # ASYNC910: 12, "return", Statement("function definition", lineno-3)
     await trio.lowlevel.checkpoint()
 
 
 async def foo_noqa_911():
     # ASYNC100: 9, 'trio', 'fail_after'
-    yield  # noqa: ASYNC911
+    if foo():
+        return  # noqa: ASYNC910
     await trio.lowlevel.checkpoint()
 
 
 async def foo_noqa_100_911():
     with trio.fail_after(5):  # noqa: ASYNC100, ASYNC911
-        yield  # noqa: ASYNC911
+        if foo():
+            return  # noqa: ASYNC910
     await trio.lowlevel.checkpoint()
 
 
 async def foo_noqa_100_911_500():
     with trio.fail_after(5):  # noqa: ASYNC100, ASYNC911 , ASYNC500,,,
-        yield  # noqa: ASYNC100, ASYNC911 , ASYNC500,,,
+        if foo():
+            return  # noqa: ASYNC100, ASYNC910 , ASYNC500,,,
     await trio.lowlevel.checkpoint()
 # fmt: on
 

{flake8-async-24.3.4 → flake8-async-24.3.6}/tests/eval_files/async100.py

@@ -114,3 +114,9 @@ async def more_nested_tests():
     with contextlib.suppress(Exception):
         with open("blah") as file:
             print("foo")
+
+
+# Don't trigger for blocks with a yield statement
+async def foo():
+    with trio.fail_after(1):
+        yield

{flake8-async-24.3.4 → flake8-async-24.3.6}/tests/eval_files/async102.py

@@ -252,3 +252,16 @@ async def foo_nested_excepts():
             await foo()
         await foo()
     await foo()
+
+
+# double check that this works nested inside an async for
+async def foo_nested_async_for():
+
+    async for i in trio.bypasslinters:
+        try:
+            ...
+        except BaseException:
+            async for (  # error: 12, Statement("BaseException", lineno-1)
+                j
+            ) in trio.bypasslinters:
+                ...

flake8-async-24.3.6/tests/eval_files/async102_aclose.py

@@ -0,0 +1,22 @@
+# type: ignore
+
+# exclude finally: await x.aclose() from async102, with trio/anyio
+# ANYIO_NO_ERROR
+# TRIO_NO_ERROR
+# See also async102_aclose_args.py - which makes sure trio/anyio raises errors if there
+# are arguments to aclose().
+
+
+async def foo():
+    # no type tracking in this check, we allow any call that looks like
+    # `await [...].aclose()`
+    x = None
+
+    try:
+        ...
+    except BaseException:
+        await x.aclose()  # ASYNC102: 8, Statement("BaseException", lineno-1)
+        await x.y.aclose()  # ASYNC102: 8, Statement("BaseException", lineno-2)
+    finally:
+        await x.aclose()  # ASYNC102: 8, Statement("try/finally", lineno-6)
+        await x.y.aclose()  # ASYNC102: 8, Statement("try/finally", lineno-7)

flake8-async-24.3.6/tests/eval_files/async102_aclose_args.py

@@ -0,0 +1,24 @@
+# type: ignore
+
+# trio/anyio should still raise errors if there's args
+# asyncio will always raise errors
+
+# See also async102_aclose.py, which checks that trio/anyio marks arg-less aclose() as safe
+
+
+async def foo():
+    # no type tracking in this check
+    x = None
+
+    try:
+        ...
+    except BaseException:
+        await x.aclose(foo)  # ASYNC102: 8, Statement("BaseException", lineno-1)
+        await x.aclose(bar=foo)  # ASYNC102: 8, Statement("BaseException", lineno-2)
+        await x.aclose(*foo)  # ASYNC102: 8, Statement("BaseException", lineno-3)
+        await x.aclose(None)  # ASYNC102: 8, Statement("BaseException", lineno-4)
+    finally:
+        await x.aclose(foo)  # ASYNC102: 8, Statement("try/finally", lineno-8)
+        await x.aclose(bar=foo)  # ASYNC102: 8, Statement("try/finally", lineno-9)
+        await x.aclose(*foo)  # ASYNC102: 8, Statement("try/finally", lineno-10)
+        await x.aclose(None)  # ASYNC102: 8, Statement("try/finally", lineno-11)

{flake8-async-24.3.4 → flake8-async-24.3.6}/tests/eval_files/noqa.py

@@ -1,45 +1,55 @@
 # AUTOFIX
 # NOASYNCIO - does not trigger on ASYNC100
-# ARG --enable=ASYNC100,ASYNC911
+# ARG --enable=ASYNC100,ASYNC911,ASYNC910
 from typing import Any
 
 import trio
 
 
+def foo() -> bool:
+    return False
+
+
 # fmt: off
 async def foo_no_noqa():
     with trio.fail_after(5):  # ASYNC100: 9, 'trio', 'fail_after'
-        yield  # ASYNC911: 8, "yield", Statement("function definition", lineno-2)
+        if foo():
+            return  # ASYNC910: 12, "return", Statement("function definition", lineno-3)
     await trio.lowlevel.checkpoint()
 
 
 async def foo_noqa_bare():
     with trio.fail_after(5):  # noqa
-        yield  # noqa
+        if foo():
+            return  # noqa
     await trio.lowlevel.checkpoint()
 
 
 async def foo_noqa_100():
     with trio.fail_after(5):  # noqa: ASYNC100
-        yield  # ASYNC911: 8, "yield", Statement("function definition", lineno-2)
+        if foo():
+            return  # ASYNC910: 12, "return", Statement("function definition", lineno-3)
     await trio.lowlevel.checkpoint()
 
 
 async def foo_noqa_911():
     with trio.fail_after(5):  # ASYNC100: 9, 'trio', 'fail_after'
-        yield  # noqa: ASYNC911
+        if foo():
+            return  # noqa: ASYNC910
     await trio.lowlevel.checkpoint()
 
 
 async def foo_noqa_100_911():
     with trio.fail_after(5):  # noqa: ASYNC100, ASYNC911
-        yield  # noqa: ASYNC911
+        if foo():
+            return  # noqa: ASYNC910
     await trio.lowlevel.checkpoint()
 
 
 async def foo_noqa_100_911_500():
     with trio.fail_after(5):  # noqa: ASYNC100, ASYNC911 , ASYNC500,,,
-        yield  # noqa: ASYNC100, ASYNC911 , ASYNC500,,,
+        if foo():
+            return  # noqa: ASYNC100, ASYNC910 , ASYNC500,,,
     await trio.lowlevel.checkpoint()
 # fmt: on
 

{flake8-async-24.3.4 → flake8-async-24.3.6}/tests/test_messages_documented.py

@@ -44,7 +44,9 @@ def test_messages_documented():
         if not file_path.is_file():
             continue
 
-        if m := re.search(r"async\d\d\d", str(file_path)):
+        # only look in the stem (final part of the path), so as not to get tripped
+        # up by [git worktree] directories with an exception code in the name
+        if m := re.search(r"^async\d\d\d", str(file_path.stem)):
             documented_errors["eval_files"].add(m.group().upper())
 
         with open(file_path) as file: