flake8-async 25.4.4__tar.gz → 25.5.2__tar.gz

{flake8_async-25.4.4 → flake8_async-25.5.2}/PKG-INFO

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

{flake8_async-25.4.4 → flake8_async-25.5.2}/flake8_async/__init__.py

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

{flake8_async-25.4.4 → flake8_async-25.5.2}/flake8_async/visitors/__init__.py

@@ -29,6 +29,7 @@ utility_visitors_cst: set[type[Flake8AsyncVisitor_cst]] = set()
 # This has to be done at the end to avoid circular imports
 from . import (
     visitor2xx,
+    visitor4xx,
     visitor91x,
     visitor101,
     visitor102_120,

{flake8_async-25.4.4 → flake8_async-25.5.2}/flake8_async/visitors/visitor102_120.py

@@ -40,16 +40,6 @@ class Visitor102(Flake8AsyncVisitor):
             self.funcname = funcname
             self.variable_name: str | None = None
             self.shielded: bool = False
-            self.has_timeout: bool = True
-
-            # scope.shielded is assigned to in visit_Assign
-
-            if self.funcname == "CancelScope":
-                self.has_timeout = False
-                for kw in node.keywords:
-                    # note: sets to True even if timeout is explicitly set to inf
-                    if kw.arg == "deadline":
-                        self.has_timeout = True
 
             # trio 0.27 adds shield parameter to all scope helpers
             if self.funcname in cancel_scope_names:
@@ -79,7 +69,7 @@ class Visitor102(Flake8AsyncVisitor):
         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
+            cm.shielded for cm in self._trio_context_managers
         ):
             # non-critical exception handlers have the statement name set to "except"
             if self._critical_scope.name == "except":

flake8_async-25.5.2/flake8_async/visitors/visitor4xx.py

@@ -0,0 +1,98 @@
+"""4XX error classes, which handle exception groups.
+
+ASYNC400 except-star-invalid-attribute checks for invalid attribute access on except*
+"""
+
+from __future__ import annotations
+
+import ast
+from typing import TYPE_CHECKING, Any
+
+from .flake8asyncvisitor import Flake8AsyncVisitor
+from .helpers import error_class
+
+if TYPE_CHECKING:
+    from collections.abc import Mapping
+
+EXCGROUP_ATTRS = (
+    # from ExceptionGroup
+    "message",
+    "exceptions",
+    "subgroup",
+    "split",
+    "derive",
+    # from BaseException
+    "args",
+    "with_traceback",
+    "add_note",
+    # in the backport
+    "_is_protocol",
+)
+
+
+@error_class
+class Visitor4xx(Flake8AsyncVisitor):
+
+    error_codes: Mapping[str, str] = {
+        "ASYNC400": (
+            "Accessing attribute {} on ExceptionGroup as if it was a bare Exception."
+        )
+    }
+
+    def __init__(self, *args: Any, **kwargs: Any):
+        super().__init__(*args, **kwargs)
+        self.exception_groups: list[str] = []
+        self.trystar = False
+
+    def visit_TryStar(self, node: ast.TryStar):  # type: ignore[name-defined]
+        self.save_state(node, "trystar")
+        self.trystar = True
+
+    def visit_Try(self, node: ast.Try):
+        self.save_state(node, "trystar")
+        self.trystar = False
+
+    def visit_ExceptHandler(self, node: ast.ExceptHandler):
+        if not self.trystar or node.name is None:
+            return
+        self.save_state(node, "exception_groups", copy=True)
+        self.exception_groups.append(node.name)
+        self.visit_nodes(node.body)
+
+    def visit_Attribute(self, node: ast.Attribute):
+        if (
+            isinstance(node.value, ast.Name)
+            and node.value.id in self.exception_groups
+            and node.attr not in EXCGROUP_ATTRS
+            and not (node.attr.startswith("__") and node.attr.endswith("__"))
+        ):
+            self.error(node, node.attr)
+
+    def _clear_if_name(self, node: ast.AST | None):
+        if isinstance(node, ast.Name) and node.id in self.exception_groups:
+            self.exception_groups.remove(node.id)
+
+    def _walk_and_clear(self, node: ast.AST | None):
+        if node is None:
+            return
+        for n in ast.walk(node):
+            self._clear_if_name(n)
+
+    def visit_Assign(self, node: ast.Assign):
+        for t in node.targets:
+            self._walk_and_clear(t)
+
+    def visit_AnnAssign(self, node: ast.AnnAssign):
+        self._clear_if_name(node.target)
+
+    def visit_withitem(self, node: ast.withitem):
+        self._walk_and_clear(node.optional_vars)
+
+    def visit_FunctionDef(
+        self, node: ast.FunctionDef | ast.AsyncFunctionDef | ast.Lambda
+    ):
+        self.save_state(node, "exception_groups", "trystar", copy=False)
+        self.exception_groups = []
+
+    visit_AsyncFunctionDef = visit_FunctionDef
+    visit_Lambda = visit_FunctionDef

{flake8_async-25.4.4 → flake8_async-25.5.2}/flake8_async/visitors/visitors.py

@@ -3,6 +3,7 @@
 from __future__ import annotations
 
 import ast
+from collections import defaultdict
 from typing import TYPE_CHECKING, Any, cast
 
 from .flake8asyncvisitor import Flake8AsyncVisitor, Flake8AsyncVisitor_cst
@@ -181,20 +182,25 @@ class Visitor113(Flake8AsyncVisitor):
         self.asynccontextmanager = False
         self.aenter = False
 
+        self.potential_errors: dict[str, list[ast.Call]] = defaultdict(list)
+
     def visit_AsyncFunctionDef(self, node: ast.AsyncFunctionDef):
-        self.save_state(node, "aenter")
+        self.save_state(node, "aenter", "asynccontextmanager", "potential_errors")
 
-        self.aenter = node.name == "__aenter__" or has_decorator(
-            node, "asynccontextmanager"
-        )
+        self.aenter = node.name == "__aenter__"
+        self.asynccontextmanager = has_decorator(node, "asynccontextmanager")
 
     def visit_FunctionDef(self, node: ast.FunctionDef):
-        self.save_state(node, "aenter")
+        self.save_state(node, "aenter", "asynccontextmanager", "potential_errors")
         # sync function should never be named __aenter__ or have @asynccontextmanager
-        self.aenter = False
+        self.aenter = self.asynccontextmanager = False
 
     def visit_Yield(self, node: ast.Yield):
-        self.aenter = False
+        for nodes in self.potential_errors.values():
+            for n in nodes:
+                self.error(n)
+        self.potential_errors.clear()
+        self.aenter = self.asynccontextmanager = False
 
     def visit_Call(self, node: ast.Call) -> None:
         def is_startable(n: ast.expr, *startable_list: str) -> bool:
@@ -210,14 +216,14 @@ class Visitor113(Flake8AsyncVisitor):
                 return any(is_startable(nn, *startable_list) for nn in n.args)
             return False
 
-        def is_nursery_call(node: ast.expr):
+        def is_nursery_call(node: ast.expr) -> str | None:
             if not isinstance(node, ast.Attribute) or node.attr not in (
                 "start_soon",
                 "create_task",
             ):
-                return False
+                return None
             var = ast.unparse(node.value)
-            return (
+            if (
                 ("trio" in self.library and var.endswith("nursery"))
                 or ("anyio" in self.library and var.endswith("task_group"))
                 or (
@@ -228,11 +234,12 @@ class Visitor113(Flake8AsyncVisitor):
                         "asyncio.TaskGroup",
                     )
                 )
-            )
+            ):
+                return var
+            return None
 
         if (
-            self.aenter
-            and is_nursery_call(node.func)
+            (var := is_nursery_call(node.func)) is not None
             and len(node.args) > 0
             and is_startable(
                 node.args[0],
@@ -241,7 +248,24 @@ class Visitor113(Flake8AsyncVisitor):
                 *self.options.startable_in_context_manager,
             )
         ):
-            self.error(node)
+            if self.aenter:
+                self.error(node)
+            elif self.asynccontextmanager:
+                self.potential_errors[var].append(node)
+
+    def visit_AsyncWith(self, node: ast.AsyncWith | ast.With):
+        # Entirely skip any nurseries that doesn't have any yields in them.
+        # This fixes an otherwise very thorny false alarm.
+        # In the worst case this does mean we iterate over the body twice, but might
+        # actually be a performance gain on average due to setting `novisit`
+        if not any(isinstance(n, ast.Yield) for b in node.body for n in ast.walk(b)):
+            self.novisit = True
+            return
+
+    # open_nursery/create_task_group only works with AsyncWith, but in case somebody
+    # is doing something very weird we'll be conservative and possibly avoid
+    # some potential false alarms
+    visit_With = visit_AsyncWith
 
 
 # Checks that all async functions with a "task_status" parameter have a match in

{flake8_async-25.4.4 → flake8_async-25.5.2}/flake8_async.egg-info/PKG-INFO

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

{flake8_async-25.4.4 → flake8_async-25.5.2}/flake8_async.egg-info/SOURCES.txt

@@ -28,6 +28,7 @@ flake8_async/visitors/visitor111.py
 flake8_async/visitors/visitor118.py
 flake8_async/visitors/visitor123.py
 flake8_async/visitors/visitor2xx.py
+flake8_async/visitors/visitor4xx.py
 flake8_async/visitors/visitor91x.py
 flake8_async/visitors/visitor_utility.py
 flake8_async/visitors/visitors.py
@@ -126,7 +127,9 @@ tests/eval_files/async250_multi_library.py
 tests/eval_files/async251.py
 tests/eval_files/async251_multi_library.py
 tests/eval_files/async300.py
+tests/eval_files/async400_py311.py
 tests/eval_files/async900.py
+tests/eval_files/async900_trio.py
 tests/eval_files/async910.py
 tests/eval_files/async910_insert_library.py
 tests/eval_files/async911.py

{flake8_async-25.4.4 → flake8_async-25.5.2}/tests/eval_files/async102.py

@@ -100,8 +100,9 @@ async def foo():
     try:
         pass
     finally:
+        # it's now fine to have a shield and no timeout
         with trio.CancelScope(shield=True):
-            await foo()  # error: 12, Statement("try/finally", lineno-4)
+            await foo()
     try:
         pass
     finally:

{flake8_async-25.4.4 → flake8_async-25.5.2}/tests/eval_files/async113.py

@@ -24,9 +24,18 @@ async def foo():
     # we don't check for `async with`
     with trio.open_nursery() as bar:  # type: ignore[attr-defined]
         bar.start_soon(my_startable)  # ASYNC113: 8
+        yield
+
+
+@asynccontextmanager
+async def foo2():
     async with trio.open_nursery() as bar:
         bar.start_soon(my_startable)  # ASYNC113: 8
+        yield
+
 
+@asynccontextmanager
+async def foo3():
     boo: trio.Nursery = ...  # type: ignore
     boo.start_soon(my_startable)  # ASYNC113: 4
 
@@ -132,3 +141,52 @@ async def foo_nested_sync_def():
             bar.start_soon(my_startable)
 
         yield
+
+
+@asynccontextmanager
+async def false_alarm():
+    async with trio.open_nursery() as nursery:
+        nursery.start_soon(my_startable)
+    yield
+
+
+@asynccontextmanager
+async def should_error():
+    async with trio.open_nursery() as nursery:
+        nursery.start_soon(my_startable)  # ASYNC113: 8
+        # overrides the nursery variable
+        async with trio.open_nursery() as nursery:
+            nursery.start_soon(my_startable)
+        yield
+
+
+@asynccontextmanager
+async def foo_sync_with_closed():
+    # we don't check for `async with`
+    with trio.open_nursery() as bar:  # type: ignore[attr-defined]
+        bar.start_soon(my_startable)
+    yield
+
+
+# fixed by entirely skipping nurseries without yields in them
+class FalseAlarm:
+    async def __aenter__(self):
+        with trio.open_nursery() as nursery:
+            nursery.start_soon(my_startable)
+
+
+@asynccontextmanager
+async def yield_before_start_soon():
+    with trio.open_nursery() as bar:
+        yield
+        bar.start_soon(my_startable)
+
+
+# This was broken when visit_AsyncWith manually visited subnodes due to not
+# letting TypeTrackerVisitor interject.
+@asynccontextmanager
+async def nested():
+    with trio.open_nursery() as foo:
+        with trio.open_nursery() as bar:
+            bar.start_soon(my_startable)  # error: 12
+            yield

{flake8_async-25.4.4 → flake8_async-25.5.2}/tests/eval_files/async113_trio.py

@@ -132,8 +132,10 @@ async def foo4(): ...
 @asynccontextmanager()  # type: ignore[call-arg]
 async def foo_paren():
     nursery.start_soon(trio.run_process)  # error: 4
+    yield
 
 
 @asynccontextmanager(1, 2, 3)  # type: ignore[call-arg]
 async def foo_params():
     nursery.start_soon(trio.run_process)  # error: 4
+    yield

{flake8_async-25.4.4 → flake8_async-25.5.2}/tests/eval_files/async120.py

@@ -121,3 +121,13 @@ async def foo_nested_funcdef():
             await foo()
 
         raise
+
+
+# shielded but no timeout no longer triggers async120
+# https://github.com/python-trio/flake8-async/issues/272
+async def foo_shield_no_timeout():
+    try:
+        ...
+    finally:
+        with trio.CancelScope(shield=True):
+            await foo()

flake8_async-25.5.2/tests/eval_files/async400_py311.py

@@ -0,0 +1,84 @@
+try:
+    ...
+except* ValueError as e:
+    e.anything  # error: 4, "anything"
+    e.foo()  # error: 4, "foo"
+    e.bar.zee  # error: 4, "bar"
+
+    # from ExceptionGroup
+    e.message
+    e.exceptions
+    e.subgroup
+    e.split
+    e.derive
+
+    # from BaseException
+    e.args
+    e.with_traceback
+    e.add_note
+
+    # ignore anything that looks like a dunder
+    e.__foo__
+    e.__bar__
+
+e.anything  # safe
+
+# assigning to the variable clears it
+try:
+    ...
+except* ValueError as e:
+    e = e.exceptions[0]
+    e.ignore  # safe
+except* ValueError as e:
+    e, f = 1, 2
+    e.anything  # safe
+except* TypeError as e:
+    (e, f) = (1, 2)
+    e.anything  # safe
+except* ValueError as e:
+    with blah as e:
+        e.anything
+    e.anything
+except* ValueError as e:
+    e: int = 1
+    e.real
+except* ValueError as e:
+    with blah as (e, f):
+        e.anything
+
+# check state saving
+try:
+    ...
+except* ValueError as e:
+    ...
+except* BaseException:
+    e.error  # safe
+
+try:
+    ...
+except* ValueError as e:
+    try:
+        ...
+    except* TypeError as e:
+        ...
+    e.anything  # error: 4, "anything"
+
+try:
+    ...
+except* ValueError as e:
+
+    def foo():
+        # possibly problematic, but we minimize false alarms
+        e.anything
+
+    e.anything  # error: 4, "anything"
+
+    def foo(e):
+        # this one is more clear it should be treated as safe
+        e.anything
+
+    e.anything  # error: 4, "anything"
+
+    lambda e: e.anything
+
+    e.anything  # error: 4, "anything"

flake8_async-25.5.2/tests/eval_files/async900_trio.py

@@ -0,0 +1,15 @@
+import trio
+
+# different error message & no as_safe_channel
+# NOANYIO
+# NOASYNCIO
+
+
+async def foo1():  # ASYNC900: 0, 'trio.as_safe_channel, contextlib.asynccontextmanager, pytest.fixture'
+    yield
+    yield
+
+
+@trio.as_safe_channel
+async def foo():
+    yield

{flake8_async-25.4.4 → flake8_async-25.5.2}/tests/test_flake8_async.py

@@ -26,6 +26,10 @@ from hypothesmith import from_grammar, from_node
 from flake8_async import Plugin
 from flake8_async.base import Error, Statement
 from flake8_async.visitors import ERROR_CLASSES, ERROR_CLASSES_CST
+from flake8_async.visitors.visitor4xx import EXCGROUP_ATTRS
+
+if sys.version_info < (3, 11):
+    from exceptiongroup import ExceptionGroup
 
 if TYPE_CHECKING:
     from collections.abc import Iterable, Sequence
@@ -512,6 +516,7 @@ error_codes_ignored_when_checking_transformed_sync_code = {
     "ASYNC123",
     "ASYNC125",
     "ASYNC300",
+    "ASYNC400",
     "ASYNC912",
 }
 
@@ -845,6 +850,13 @@ def test_910_permutations():
             assert not errors, "# false alarm:\n" + function_str
 
 
+def test_async400_excgroup_attributes():
+    for attr in dir(ExceptionGroup):
+        if attr.startswith("__") and attr.endswith("__"):
+            continue
+        assert attr in EXCGROUP_ATTRS
+
+
 # from https://docs.python.org/3/library/itertools.html#itertools-recipes
 def consume(iterator: Iterable[Any]):
     deque(iterator, maxlen=0)