---
source: crates/ruff_linter/src/rules/flake8_trio/mod.rs
---
TRIO105.py:30:5: TRIO105 [*] Call to `trio.aclose_forcefully` is not immediately awaited
   |
29 |     # TRIO105
30 |     trio.aclose_forcefully(foo)
   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^ TRIO105
31 |     trio.open_file(foo)
32 |     trio.open_ssl_over_tcp_listeners(foo, foo)
   |
   = help: Add `await`

ℹ Unsafe fix
27 27 |     await trio.lowlevel.wait_writable(foo)
28 28 | 
29 29 |     # TRIO105
30    |-    trio.aclose_forcefully(foo)
   30 |+    await trio.aclose_forcefully(foo)
31 31 |     trio.open_file(foo)
32 32 |     trio.open_ssl_over_tcp_listeners(foo, foo)
33 33 |     trio.open_ssl_over_tcp_stream(foo, foo)

TRIO105.py:31:5: TRIO105 [*] Call to `trio.open_file` is not immediately awaited
   |
29 |     # TRIO105
30 |     trio.aclose_forcefully(foo)
31 |     trio.open_file(foo)
   |     ^^^^^^^^^^^^^^^^^^^ TRIO105
32 |     trio.open_ssl_over_tcp_listeners(foo, foo)
33 |     trio.open_ssl_over_tcp_stream(foo, foo)
   |
   = help: Add `await`

ℹ Unsafe fix
28 28 | 
29 29 |     # TRIO105
30 30 |     trio.aclose_forcefully(foo)
31    |-    trio.open_file(foo)
   31 |+    await trio.open_file(foo)
32 32 |     trio.open_ssl_over_tcp_listeners(foo, foo)
33 33 |     trio.open_ssl_over_tcp_stream(foo, foo)
34 34 |     trio.open_tcp_listeners(foo)

TRIO105.py:32:5: TRIO105 [*] Call to `trio.open_ssl_over_tcp_listeners` is not immediately awaited
   |
30 |     trio.aclose_forcefully(foo)
31 |     trio.open_file(foo)
32 |     trio.open_ssl_over_tcp_listeners(foo, foo)
   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ TRIO105
33 |     trio.open_ssl_over_tcp_stream(foo, foo)
34 |     trio.open_tcp_listeners(foo)
   |
   = help: Add `await`

ℹ Unsafe fix
29 29 |     # TRIO105
30 30 |     trio.aclose_forcefully(foo)
31 31 |     trio.open_file(foo)
32    |-    trio.open_ssl_over_tcp_listeners(foo, foo)
   32 |+    await trio.open_ssl_over_tcp_listeners(foo, foo)
33 33 |     trio.open_ssl_over_tcp_stream(foo, foo)
34 34 |     trio.open_tcp_listeners(foo)
35 35 |     trio.open_tcp_stream(foo, foo)

TRIO105.py:33:5: TRIO105 [*] Call to `trio.open_ssl_over_tcp_stream` is not immediately awaited
   |
31 |     trio.open_file(foo)
32 |     trio.open_ssl_over_tcp_listeners(foo, foo)
33 |     trio.open_ssl_over_tcp_stream(foo, foo)
   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ TRIO105
34 |     trio.open_tcp_listeners(foo)
35 |     trio.open_tcp_stream(foo, foo)
   |
   = help: Add `await`

ℹ Unsafe fix
30 30 |     trio.aclose_forcefully(foo)
31 31 |     trio.open_file(foo)
32 32 |     trio.open_ssl_over_tcp_listeners(foo, foo)
33    |-    trio.open_ssl_over_tcp_stream(foo, foo)
   33 |+    await trio.open_ssl_over_tcp_stream(foo, foo)
34 34 |     trio.open_tcp_listeners(foo)
35 35 |     trio.open_tcp_stream(foo, foo)
36 36 |     trio.open_unix_socket(foo)

TRIO105.py:34:5: TRIO105 [*] Call to `trio.open_tcp_listeners` is not immediately awaited
   |
32 |     trio.open_ssl_over_tcp_listeners(foo, foo)
33 |     trio.open_ssl_over_tcp_stream(foo, foo)
34 |     trio.open_tcp_listeners(foo)
   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ TRIO105
35 |     trio.open_tcp_stream(foo, foo)
36 |     trio.open_unix_socket(foo)
   |
   = help: Add `await`

ℹ Unsafe fix
31 31 |     trio.open_file(foo)
32 32 |     trio.open_ssl_over_tcp_listeners(foo, foo)
33 33 |     trio.open_ssl_over_tcp_stream(foo, foo)
34    |-    trio.open_tcp_listeners(foo)
   34 |+    await trio.open_tcp_listeners(foo)
35 35 |     trio.open_tcp_stream(foo, foo)
36 36 |     trio.open_unix_socket(foo)
37 37 |     trio.run_process(foo)

TRIO105.py:35:5: TRIO105 [*] Call to `trio.open_tcp_stream` is not immediately awaited
   |
33 |     trio.open_ssl_over_tcp_stream(foo, foo)
34 |     trio.open_tcp_listeners(foo)
35 |     trio.open_tcp_stream(foo, foo)
   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ TRIO105
36 |     trio.open_unix_socket(foo)
37 |     trio.run_process(foo)
   |
   = help: Add `await`

ℹ Unsafe fix
32 32 |     trio.open_ssl_over_tcp_listeners(foo, foo)
33 33 |     trio.open_ssl_over_tcp_stream(foo, foo)
34 34 |     trio.open_tcp_listeners(foo)
35    |-    trio.open_tcp_stream(foo, foo)
   35 |+    await trio.open_tcp_stream(foo, foo)
36 36 |     trio.open_unix_socket(foo)
37 37 |     trio.run_process(foo)
38 38 |     trio.serve_listeners(foo, foo)

TRIO105.py:36:5: TRIO105 [*] Call to `trio.open_unix_socket` is not immediately awaited
   |
34 |     trio.open_tcp_listeners(foo)
35 |     trio.open_tcp_stream(foo, foo)
36 |     trio.open_unix_socket(foo)
   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^ TRIO105
37 |     trio.run_process(foo)
38 |     trio.serve_listeners(foo, foo)
   |
   = help: Add `await`

ℹ Unsafe fix
33 33 |     trio.open_ssl_over_tcp_stream(foo, foo)
34 34 |     trio.open_tcp_listeners(foo)
35 35 |     trio.open_tcp_stream(foo, foo)
36    |-    trio.open_unix_socket(foo)
   36 |+    await trio.open_unix_socket(foo)
37 37 |     trio.run_process(foo)
38 38 |     trio.serve_listeners(foo, foo)
39 39 |     trio.serve_ssl_over_tcp(foo, foo, foo)

TRIO105.py:37:5: TRIO105 [*] Call to `trio.run_process` is not immediately awaited
   |
35 |     trio.open_tcp_stream(foo, foo)
36 |     trio.open_unix_socket(foo)
37 |     trio.run_process(foo)
   |     ^^^^^^^^^^^^^^^^^^^^^ TRIO105
38 |     trio.serve_listeners(foo, foo)
39 |     trio.serve_ssl_over_tcp(foo, foo, foo)
   |
   = help: Add `await`

ℹ Unsafe fix
34 34 |     trio.open_tcp_listeners(foo)
35 35 |     trio.open_tcp_stream(foo, foo)
36 36 |     trio.open_unix_socket(foo)
37    |-    trio.run_process(foo)
   37 |+    await trio.run_process(foo)
38 38 |     trio.serve_listeners(foo, foo)
39 39 |     trio.serve_ssl_over_tcp(foo, foo, foo)
40 40 |     trio.serve_tcp(foo, foo)

TRIO105.py:38:5: TRIO105 [*] Call to `trio.serve_listeners` is not immediately awaited
   |
36 |     trio.open_unix_socket(foo)
37 |     trio.run_process(foo)
38 |     trio.serve_listeners(foo, foo)
   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ TRIO105
39 |     trio.serve_ssl_over_tcp(foo, foo, foo)
40 |     trio.serve_tcp(foo, foo)
   |
   = help: Add `await`

ℹ Unsafe fix
35 35 |     trio.open_tcp_stream(foo, foo)
36 36 |     trio.open_unix_socket(foo)
37 37 |     trio.run_process(foo)
38    |-    trio.serve_listeners(foo, foo)
   38 |+    await trio.serve_listeners(foo, foo)
39 39 |     trio.serve_ssl_over_tcp(foo, foo, foo)
40 40 |     trio.serve_tcp(foo, foo)
41 41 |     trio.sleep(foo)

TRIO105.py:39:5: TRIO105 [*] Call to `trio.serve_ssl_over_tcp` is not immediately awaited
   |
37 |     trio.run_process(foo)
38 |     trio.serve_listeners(foo, foo)
39 |     trio.serve_ssl_over_tcp(foo, foo, foo)
   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ TRIO105
40 |     trio.serve_tcp(foo, foo)
41 |     trio.sleep(foo)
   |
   = help: Add `await`

ℹ Unsafe fix
36 36 |     trio.open_unix_socket(foo)
37 37 |     trio.run_process(foo)
38 38 |     trio.serve_listeners(foo, foo)
39    |-    trio.serve_ssl_over_tcp(foo, foo, foo)
   39 |+    await trio.serve_ssl_over_tcp(foo, foo, foo)
40 40 |     trio.serve_tcp(foo, foo)
41 41 |     trio.sleep(foo)
42 42 |     trio.sleep_forever()

TRIO105.py:40:5: TRIO105 [*] Call to `trio.serve_tcp` is not immediately awaited
   |
38 |     trio.serve_listeners(foo, foo)
39 |     trio.serve_ssl_over_tcp(foo, foo, foo)
40 |     trio.serve_tcp(foo, foo)
   |     ^^^^^^^^^^^^^^^^^^^^^^^^ TRIO105
41 |     trio.sleep(foo)
42 |     trio.sleep_forever()
   |
   = help: Add `await`

ℹ Unsafe fix
37 37 |     trio.run_process(foo)
38 38 |     trio.serve_listeners(foo, foo)
39 39 |     trio.serve_ssl_over_tcp(foo, foo, foo)
40    |-    trio.serve_tcp(foo, foo)
   40 |+    await trio.serve_tcp(foo, foo)
41 41 |     trio.sleep(foo)
42 42 |     trio.sleep_forever()
43 43 |     trio.sleep_until(foo)

TRIO105.py:41:5: TRIO105 [*] Call to `trio.sleep` is not immediately awaited
   |
39 |     trio.serve_ssl_over_tcp(foo, foo, foo)
40 |     trio.serve_tcp(foo, foo)
41 |     trio.sleep(foo)
   |     ^^^^^^^^^^^^^^^ TRIO105
42 |     trio.sleep_forever()
43 |     trio.sleep_until(foo)
   |
   = help: Add `await`

ℹ Unsafe fix
38 38 |     trio.serve_listeners(foo, foo)
39 39 |     trio.serve_ssl_over_tcp(foo, foo, foo)
40 40 |     trio.serve_tcp(foo, foo)
41    |-    trio.sleep(foo)
   41 |+    await trio.sleep(foo)
42 42 |     trio.sleep_forever()
43 43 |     trio.sleep_until(foo)
44 44 |     trio.lowlevel.cancel_shielded_checkpoint()

TRIO105.py:42:5: TRIO105 [*] Call to `trio.sleep_forever` is not immediately awaited
   |
40 |     trio.serve_tcp(foo, foo)
41 |     trio.sleep(foo)
42 |     trio.sleep_forever()
   |     ^^^^^^^^^^^^^^^^^^^^ TRIO105
43 |     trio.sleep_until(foo)
44 |     trio.lowlevel.cancel_shielded_checkpoint()
   |
   = help: Add `await`

ℹ Unsafe fix
39 39 |     trio.serve_ssl_over_tcp(foo, foo, foo)
40 40 |     trio.serve_tcp(foo, foo)
41 41 |     trio.sleep(foo)
42    |-    trio.sleep_forever()
   42 |+    await trio.sleep_forever()
43 43 |     trio.sleep_until(foo)
44 44 |     trio.lowlevel.cancel_shielded_checkpoint()
45 45 |     trio.lowlevel.checkpoint()

TRIO105.py:44:5: TRIO105 [*] Call to `trio.lowlevel.cancel_shielded_checkpoint` is not immediately awaited
   |
42 |     trio.sleep_forever()
43 |     trio.sleep_until(foo)
44 |     trio.lowlevel.cancel_shielded_checkpoint()
   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ TRIO105
45 |     trio.lowlevel.checkpoint()
46 |     trio.lowlevel.checkpoint_if_cancelled()
   |
   = help: Add `await`

ℹ Unsafe fix
41 41 |     trio.sleep(foo)
42 42 |     trio.sleep_forever()
43 43 |     trio.sleep_until(foo)
44    |-    trio.lowlevel.cancel_shielded_checkpoint()
   44 |+    await trio.lowlevel.cancel_shielded_checkpoint()
45 45 |     trio.lowlevel.checkpoint()
46 46 |     trio.lowlevel.checkpoint_if_cancelled()
47 47 |     trio.lowlevel.open_process()

TRIO105.py:45:5: TRIO105 [*] Call to `trio.lowlevel.checkpoint` is not immediately awaited
   |
43 |     trio.sleep_until(foo)
44 |     trio.lowlevel.cancel_shielded_checkpoint()
45 |     trio.lowlevel.checkpoint()
   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^ TRIO105
46 |     trio.lowlevel.checkpoint_if_cancelled()
47 |     trio.lowlevel.open_process()
   |
   = help: Add `await`

ℹ Unsafe fix
42 42 |     trio.sleep_forever()
43 43 |     trio.sleep_until(foo)
44 44 |     trio.lowlevel.cancel_shielded_checkpoint()
45    |-    trio.lowlevel.checkpoint()
   45 |+    await trio.lowlevel.checkpoint()
46 46 |     trio.lowlevel.checkpoint_if_cancelled()
47 47 |     trio.lowlevel.open_process()
48 48 |     trio.lowlevel.permanently_detach_coroutine_object(foo)

TRIO105.py:46:5: TRIO105 [*] Call to `trio.lowlevel.checkpoint_if_cancelled` is not immediately awaited
   |
44 |     trio.lowlevel.cancel_shielded_checkpoint()
45 |     trio.lowlevel.checkpoint()
46 |     trio.lowlevel.checkpoint_if_cancelled()
   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ TRIO105
47 |     trio.lowlevel.open_process()
48 |     trio.lowlevel.permanently_detach_coroutine_object(foo)
   |
   = help: Add `await`

ℹ Unsafe fix
43 43 |     trio.sleep_until(foo)
44 44 |     trio.lowlevel.cancel_shielded_checkpoint()
45 45 |     trio.lowlevel.checkpoint()
46    |-    trio.lowlevel.checkpoint_if_cancelled()
   46 |+    await trio.lowlevel.checkpoint_if_cancelled()
47 47 |     trio.lowlevel.open_process()
48 48 |     trio.lowlevel.permanently_detach_coroutine_object(foo)
49 49 |     trio.lowlevel.reattach_detached_coroutine_object(foo, foo)

TRIO105.py:47:5: TRIO105 [*] Call to `trio.lowlevel.open_process` is not immediately awaited
   |
45 |     trio.lowlevel.checkpoint()
46 |     trio.lowlevel.checkpoint_if_cancelled()
47 |     trio.lowlevel.open_process()
   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ TRIO105
48 |     trio.lowlevel.permanently_detach_coroutine_object(foo)
49 |     trio.lowlevel.reattach_detached_coroutine_object(foo, foo)
   |
   = help: Add `await`

ℹ Unsafe fix
44 44 |     trio.lowlevel.cancel_shielded_checkpoint()
45 45 |     trio.lowlevel.checkpoint()
46 46 |     trio.lowlevel.checkpoint_if_cancelled()
47    |-    trio.lowlevel.open_process()
   47 |+    await trio.lowlevel.open_process()
48 48 |     trio.lowlevel.permanently_detach_coroutine_object(foo)
49 49 |     trio.lowlevel.reattach_detached_coroutine_object(foo, foo)
50 50 |     trio.lowlevel.temporarily_detach_coroutine_object(foo)

TRIO105.py:48:5: TRIO105 [*] Call to `trio.lowlevel.permanently_detach_coroutine_object` is not immediately awaited
   |
46 |     trio.lowlevel.checkpoint_if_cancelled()
47 |     trio.lowlevel.open_process()
48 |     trio.lowlevel.permanently_detach_coroutine_object(foo)
   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ TRIO105
49 |     trio.lowlevel.reattach_detached_coroutine_object(foo, foo)
50 |     trio.lowlevel.temporarily_detach_coroutine_object(foo)
   |
   = help: Add `await`

ℹ Unsafe fix
45 45 |     trio.lowlevel.checkpoint()
46 46 |     trio.lowlevel.checkpoint_if_cancelled()
47 47 |     trio.lowlevel.open_process()
48    |-    trio.lowlevel.permanently_detach_coroutine_object(foo)
   48 |+    await trio.lowlevel.permanently_detach_coroutine_object(foo)
49 49 |     trio.lowlevel.reattach_detached_coroutine_object(foo, foo)
50 50 |     trio.lowlevel.temporarily_detach_coroutine_object(foo)
51 51 |     trio.lowlevel.wait_readable(foo)

TRIO105.py:49:5: TRIO105 [*] Call to `trio.lowlevel.reattach_detached_coroutine_object` is not immediately awaited
   |
47 |     trio.lowlevel.open_process()
48 |     trio.lowlevel.permanently_detach_coroutine_object(foo)
49 |     trio.lowlevel.reattach_detached_coroutine_object(foo, foo)
   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ TRIO105
50 |     trio.lowlevel.temporarily_detach_coroutine_object(foo)
51 |     trio.lowlevel.wait_readable(foo)
   |
   = help: Add `await`

ℹ Unsafe fix
46 46 |     trio.lowlevel.checkpoint_if_cancelled()
47 47 |     trio.lowlevel.open_process()
48 48 |     trio.lowlevel.permanently_detach_coroutine_object(foo)
49    |-    trio.lowlevel.reattach_detached_coroutine_object(foo, foo)
   49 |+    await trio.lowlevel.reattach_detached_coroutine_object(foo, foo)
50 50 |     trio.lowlevel.temporarily_detach_coroutine_object(foo)
51 51 |     trio.lowlevel.wait_readable(foo)
52 52 |     trio.lowlevel.wait_task_rescheduled(foo)

TRIO105.py:50:5: TRIO105 [*] Call to `trio.lowlevel.temporarily_detach_coroutine_object` is not immediately awaited
   |
48 |     trio.lowlevel.permanently_detach_coroutine_object(foo)
49 |     trio.lowlevel.reattach_detached_coroutine_object(foo, foo)
50 |     trio.lowlevel.temporarily_detach_coroutine_object(foo)
   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ TRIO105
51 |     trio.lowlevel.wait_readable(foo)
52 |     trio.lowlevel.wait_task_rescheduled(foo)
   |
   = help: Add `await`

ℹ Unsafe fix
47 47 |     trio.lowlevel.open_process()
48 48 |     trio.lowlevel.permanently_detach_coroutine_object(foo)
49 49 |     trio.lowlevel.reattach_detached_coroutine_object(foo, foo)
50    |-    trio.lowlevel.temporarily_detach_coroutine_object(foo)
   50 |+    await trio.lowlevel.temporarily_detach_coroutine_object(foo)
51 51 |     trio.lowlevel.wait_readable(foo)
52 52 |     trio.lowlevel.wait_task_rescheduled(foo)
53 53 |     trio.lowlevel.wait_writable(foo)

TRIO105.py:51:5: TRIO105 [*] Call to `trio.lowlevel.wait_readable` is not immediately awaited
   |
49 |     trio.lowlevel.reattach_detached_coroutine_object(foo, foo)
50 |     trio.lowlevel.temporarily_detach_coroutine_object(foo)
51 |     trio.lowlevel.wait_readable(foo)
   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ TRIO105
52 |     trio.lowlevel.wait_task_rescheduled(foo)
53 |     trio.lowlevel.wait_writable(foo)
   |
   = help: Add `await`

ℹ Unsafe fix
48 48 |     trio.lowlevel.permanently_detach_coroutine_object(foo)
49 49 |     trio.lowlevel.reattach_detached_coroutine_object(foo, foo)
50 50 |     trio.lowlevel.temporarily_detach_coroutine_object(foo)
51    |-    trio.lowlevel.wait_readable(foo)
   51 |+    await trio.lowlevel.wait_readable(foo)
52 52 |     trio.lowlevel.wait_task_rescheduled(foo)
53 53 |     trio.lowlevel.wait_writable(foo)
54 54 | 

TRIO105.py:52:5: TRIO105 [*] Call to `trio.lowlevel.wait_task_rescheduled` is not immediately awaited
   |
50 |     trio.lowlevel.temporarily_detach_coroutine_object(foo)
51 |     trio.lowlevel.wait_readable(foo)
52 |     trio.lowlevel.wait_task_rescheduled(foo)
   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ TRIO105
53 |     trio.lowlevel.wait_writable(foo)
   |
   = help: Add `await`

ℹ Unsafe fix
49 49 |     trio.lowlevel.reattach_detached_coroutine_object(foo, foo)
50 50 |     trio.lowlevel.temporarily_detach_coroutine_object(foo)
51 51 |     trio.lowlevel.wait_readable(foo)
52    |-    trio.lowlevel.wait_task_rescheduled(foo)
   52 |+    await trio.lowlevel.wait_task_rescheduled(foo)
53 53 |     trio.lowlevel.wait_writable(foo)
54 54 | 
55 55 |     async with await trio.open_file(foo):  # Ok

TRIO105.py:53:5: TRIO105 [*] Call to `trio.lowlevel.wait_writable` is not immediately awaited
   |
51 |     trio.lowlevel.wait_readable(foo)
52 |     trio.lowlevel.wait_task_rescheduled(foo)
53 |     trio.lowlevel.wait_writable(foo)
   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ TRIO105
54 | 
55 |     async with await trio.open_file(foo):  # Ok
   |
   = help: Add `await`

ℹ Unsafe fix
50 50 |     trio.lowlevel.temporarily_detach_coroutine_object(foo)
51 51 |     trio.lowlevel.wait_readable(foo)
52 52 |     trio.lowlevel.wait_task_rescheduled(foo)
53    |-    trio.lowlevel.wait_writable(foo)
   53 |+    await trio.lowlevel.wait_writable(foo)
54 54 | 
55 55 |     async with await trio.open_file(foo):  # Ok
56 56 |         pass

TRIO105.py:58:16: TRIO105 [*] Call to `trio.open_file` is not immediately awaited
   |
56 |         pass
57 | 
58 |     async with trio.open_file(foo):  # TRIO105
   |                ^^^^^^^^^^^^^^^^^^^ TRIO105
59 |         pass
   |
   = help: Add `await`

ℹ Unsafe fix
55 55 |     async with await trio.open_file(foo):  # Ok
56 56 |         pass
57 57 | 
58    |-    async with trio.open_file(foo):  # TRIO105
   58 |+    async with await trio.open_file(foo):  # TRIO105
59 59 |         pass
60 60 | 
61 61 | 

TRIO105.py:64:5: TRIO105 Call to `trio.open_file` is not immediately awaited
   |
62 | def func() -> None:
63 |     # TRIO105 (without fix)
64 |     trio.open_file(foo)
   |     ^^^^^^^^^^^^^^^^^^^ TRIO105
   |
   = help: Add `await`


