Ruff preview mode

notes-to-self/how-does-windows-so-reuseaddr-work.py

@@ -49,12 +49,15 @@ def table_entry(mode1, bind_type1, mode2, bind_type2):
     """
                                                        second bind
                                | """
-    + " | ".join(["%-19s" % mode for mode in modes]),
+    + " | ".join(f"{mode:<19}" for mode in modes),
 )
 
 print("""                              """, end="")
 for _ in modes:
-    print(" | " + " | ".join(["%8s" % bind_type for bind_type in bind_types]), end="")
+    print(
+        " | " + " | ".join(f"{bind_type:>8}" for bind_type in bind_types),
+        end="",
+    )
 
 print(
     """
@@ -72,5 +75,5 @@ def table_entry(mode1, bind_type1, mode2, bind_type2):
                 # print(mode1, bind_type1, mode2, bind_type2, entry)
         print(
             f"{mode1:>19} | {bind_type1:>8} | "
-            + " | ".join(["%8s" % entry for entry in row]),
+            + " | ".join(f"{entry:>8}" for entry in row),
         )

notes-to-self/socket-scaling.py

@@ -32,7 +32,7 @@ def pt(desc, *, count=total, item="socket"):
             now = time.perf_counter()
             total_ms = (now - last_time) * 1000
             per_us = total_ms * 1000 / count
-            print(f"{desc}: {total_ms:.2f} ms total, {per_us:.2f} µs/{item}")
+            print(f"{desc}: {total_ms:.2f} ms total, {per_us:.2f} μs/{item}")
             last_time = now
 
         print(f"\n-- {total} sockets --")

notes-to-self/thread-dispatch-bench.py

@@ -30,7 +30,7 @@ def main():
             in_q.put(lambda: None)
             out_q.get()
         end = time.monotonic()
-        print(f"{(end - start) / COUNT * 1e6:.2f} µs/job")
+        print(f"{(end - start) / COUNT * 1e6:.2f} μs/job")
 
 
 main()

notes-to-self/trivial-err.py

@@ -5,7 +5,7 @@
 sys.stderr = sys.stdout
 
 
-async def child1():
+async def child1():  # noqa: RUF029  # async not required
     raise ValueError
 
 
@@ -15,11 +15,11 @@ async def child2():
         nursery.start_soon(grandchild2)
 
 
-async def grandchild1():
+async def grandchild1():  # noqa: RUF029  # async not required
     raise KeyError
 
 
-async def grandchild2():
+async def grandchild2():  # noqa: RUF029  # async not required
     raise NameError("Bob")
 
 

notes-to-self/trivial.py

@@ -1,7 +1,7 @@
 import trio
 
 
-async def foo():
+async def foo():  # noqa: RUF029  # await not used
     print("in foo!")
     return 3
 

pyproject.toml

@@ -102,6 +102,7 @@ extend-exclude = [
 ]
 
 [tool.ruff.lint]
+preview = true
 allowed-confusables = ["–"]
 
 select = [
@@ -147,10 +148,20 @@ extend-ignore = [
 # to export for public use.
 'src/trio/__init__.py' = ['F401']
 'src/trio/_core/__init__.py' = ['F401']
-'src/trio/abc.py' = ['F401']
+'src/trio/abc.py' = ['F401', 'A005']
 'src/trio/lowlevel.py' = ['F401']
-'src/trio/socket.py' = ['F401']
+'src/trio/socket.py' = ['F401', 'A005']
 'src/trio/testing/__init__.py' = ['F401']
+# RUF029 is ignoring tests that are marked as async functions but
+# do not use an await in their function bodies. There are several
+# places where internal trio synchronous code relies on being
+# called from an async function, where current task is set up.
+'src/trio/_tests/*.py' = ['RUF029']
+'src/trio/_core/_tests/*.py' = ['RUF029']
+# A005 is ignoring modules that shadow stdlib modules.
+'src/trio/_abc.py' = ['A005']
+'src/trio/_socket.py' = ['A005']
+'src/trio/_ssl.py' = ['A005']
 
 [tool.ruff.lint.isort]
 combine-as-imports = true

src/trio/_core/_entry_queue.py

@@ -64,7 +64,9 @@ def run_cb(job: Job) -> None:
                 sync_fn(*args)
             except BaseException as exc:
 
-                async def kill_everything(exc: BaseException) -> NoReturn:
+                async def kill_everything(  # noqa: RUF029  # await not used
+                    exc: BaseException,
+                ) -> NoReturn:
                     raise exc
 
                 try:
@@ -139,7 +141,7 @@ def run_sync_soon(
             # wakeup call might trigger an OSError b/c the IO manager has
             # already been shut down.
             if idempotent:
-                self.idempotent_queue[(sync_fn, args)] = None
+                self.idempotent_queue[sync_fn, args] = None
             else:
                 self.queue.append((sync_fn, args))
             self.wakeup.wakeup_thread_and_signal_safe()

src/trio/_core/_tests/test_asyncgen.py

@@ -110,7 +110,7 @@ async def agen() -> AsyncGenerator[int, None]:
     await _core.wait_all_tasks_blocked()
     assert record == ["crashing"]
     # Following type ignore is because typing for LogCaptureFixture is wrong
-    exc_type, exc_value, exc_traceback = caplog.records[0].exc_info  # type: ignore[misc]
+    exc_type, exc_value, _exc_traceback = caplog.records[0].exc_info  # type: ignore[misc]
     assert exc_type is ValueError
     assert str(exc_value) == "oops"
     assert "during finalization of async generator" in caplog.records[0].message
@@ -227,8 +227,8 @@ async def async_main() -> None:
     # failure as small as we want.
     for _attempt in range(50):
         needs_retry = False
-        del record[:]
-        del saved[:]
+        record.clear()
+        saved.clear()
         _core.run(async_main)
         if needs_retry:  # pragma: no cover
             assert record == ["cleaned up"]

src/trio/_core/_tests/test_instrumentation.py

@@ -204,7 +204,7 @@ async def main() -> Task:
     assert ("after_run", None) in r.record
     # And we got a log message
     assert caplog.records[0].exc_info is not None
-    exc_type, exc_value, exc_traceback = caplog.records[0].exc_info
+    exc_type, exc_value, _exc_traceback = caplog.records[0].exc_info
     assert exc_type is ValueError
     assert str(exc_value) == "oops"
     assert "Instrument has been disabled" in caplog.records[0].message

src/trio/_core/_tests/test_io.py

@@ -161,7 +161,7 @@ async def block_on_write() -> None:
 
 @read_socket_test
 async def test_double_read(socketpair: SocketPair, wait_readable: WaitSocket) -> None:
-    a, b = socketpair
+    a, _b = socketpair
 
     # You can't have two tasks trying to read from a socket at the same time
     async with _core.open_nursery() as nursery:
@@ -174,7 +174,7 @@ async def test_double_read(socketpair: SocketPair, wait_readable: WaitSocket) ->
 
 @write_socket_test
 async def test_double_write(socketpair: SocketPair, wait_writable: WaitSocket) -> None:
-    a, b = socketpair
+    a, _b = socketpair
 
     # You can't have two tasks trying to write to a socket at the same time
     fill_socket(a)
@@ -195,7 +195,7 @@ async def test_interrupted_by_close(
     wait_writable: WaitSocket,
     notify_closing: Callable[[stdlib_socket.socket], object],
 ) -> None:
-    a, b = socketpair
+    a, _b = socketpair
 
     async def reader() -> None:
         with pytest.raises(_core.ClosedResourceError):

src/trio/_core/_tests/test_mock_clock.py

@@ -92,7 +92,8 @@ async def test_mock_clock_autojump(mock_clock: MockClock) -> None:
     mock_clock.autojump_threshold = 0
     # if the above line didn't take affect immediately, then this would be
     # bad:
-    await sleep(100000)
+    # ignore ASYNC116, not sleep_forever, trying to test a large but finite sleep
+    await sleep(100000)  # noqa: ASYNC116
 
 
 async def test_mock_clock_autojump_interference(mock_clock: MockClock) -> None:
@@ -109,7 +110,8 @@ async def test_mock_clock_autojump_interference(mock_clock: MockClock) -> None:
     await wait_all_tasks_blocked(0.015)
 
     # but the 0.02 limit does apply
-    await sleep(100000)
+    # ignore ASYNC116, not sleep_forever, trying to test a large but finite sleep
+    await sleep(100000)  # noqa: ASYNC116
 
 
 def test_mock_clock_autojump_preset() -> None:

src/trio/_core/_tests/test_run.py

@@ -269,8 +269,8 @@ async def test_current_time_with_mock_clock(mock_clock: _core.MockClock) -> None
     start = mock_clock.current_time()
     assert mock_clock.current_time() == _core.current_time()
     assert mock_clock.current_time() == _core.current_time()
-    mock_clock.jump(3.14)
-    assert start + 3.14 == mock_clock.current_time() == _core.current_time()
+    mock_clock.jump(3.15)
+    assert start + 3.15 == mock_clock.current_time() == _core.current_time()
 
 
 async def test_current_clock(mock_clock: _core.MockClock) -> None:

src/trio/_dtls.py

@@ -561,10 +561,9 @@ def _current_cookie_tick() -> int:
 # Simple deterministic and invertible serializer -- i.e., a useful tool for converting
 # structured data into something we can cryptographically sign.
 def _signable(*fields: bytes) -> bytes:
-    out = []
+    out: list[bytes] = []
     for field in fields:
-        out.append(struct.pack("!Q", len(field)))
-        out.append(field)
+        out.extend((struct.pack("!Q", len(field)), field))
     return b"".join(out)
 
 

src/trio/_socket.py

@@ -1,3 +1,6 @@
+# ruff: noqa: PYI063  # Several cases throughout file where
+# argument names with __ used because of typeshed, see comment for recv in _SocketType
+
 from __future__ import annotations
 
 import os
@@ -676,7 +679,6 @@ async def accept(self) -> tuple[SocketType, AddressFormat]:
     async def connect(self, address: AddressFormat) -> None:
         raise NotImplementedError
 
-    # argument names with __ used because of typeshed, see comment for recv in _SocketType
     def recv(__self, __buflen: int, __flags: int = 0) -> Awaitable[bytes]:
         raise NotImplementedError
 

src/trio/_subprocess.py

@@ -430,7 +430,8 @@ async def _open_process(
     return Process._create(popen, trio_stdin, trio_stdout, trio_stderr)
 
 
-async def _windows_deliver_cancel(p: Process) -> None:
+# async function missing await
+async def _windows_deliver_cancel(p: Process) -> None:  # noqa: RUF029
     try:
         p.terminate()
     except OSError as exc:

src/trio/_tests/test_channel.py

@@ -150,7 +150,7 @@ async def receive_block(r: trio.MemoryReceiveChannel[int]) -> None:
         with pytest.raises(trio.ClosedResourceError):
             await r.receive()
 
-    s2, r2 = open_memory_channel[int](0)
+    _s2, r2 = open_memory_channel[int](0)
     async with trio.open_nursery() as nursery:
         nursery.start_soon(receive_block, r2)
         await wait_all_tasks_blocked()

src/trio/_tests/test_dtls.py

@@ -91,7 +91,7 @@ async def echo_handler(dtls_channel: DTLSChannel) -> None:
 
 @parametrize_ipv6
 async def test_smoke(ipv6: bool) -> None:
-    async with dtls_echo_server(ipv6=ipv6) as (server_endpoint, address):
+    async with dtls_echo_server(ipv6=ipv6) as (_server_endpoint, address):
         with endpoint(ipv6=ipv6) as client_endpoint:
             client_channel = client_endpoint.connect(address, client_ctx)
             with pytest.raises(trio.NeedHandshakeError):
@@ -260,7 +260,7 @@ async def test_channel_closing() -> None:
 
 
 async def test_serve_exits_cleanly_on_close() -> None:
-    async with dtls_echo_server(autocancel=False) as (server_endpoint, address):
+    async with dtls_echo_server(autocancel=False) as (server_endpoint, _address):
         server_endpoint.close()
         # Testing that the nursery exits even without being cancelled
     # close is idempotent
@@ -679,7 +679,7 @@ def route_packet(packet: UDPPacket) -> None:
 
     fn.route_packet = route_packet  # type: ignore[assignment]  # TODO add type annotations for FakeNet
 
-    async with dtls_echo_server(mtu=MTU) as (server, address):
+    async with dtls_echo_server(mtu=MTU) as (_server, address):
         with endpoint() as client:
             channel = client.connect(address, client_ctx)
             channel.set_ciphertext_mtu(MTU)

src/trio/_tests/test_exports.py

@@ -117,7 +117,7 @@ def iter_modules(
 # they might be using a newer version of Python with additional symbols which
 # won't be reflected in trio.socket, and this shouldn't cause downstream test
 # runs to start failing.
-@pytest.mark.redistributors_should_skip()
+@pytest.mark.redistributors_should_skip
 # Static analysis tools often have trouble with alpha releases, where Python's
 # internals are in flux, grammar may not have settled down, etc.
 @pytest.mark.skipif(
@@ -243,7 +243,7 @@ def no_underscores(symbols: Iterable[str]) -> set[str]:
 # modules, instead of once per class.
 @slow
 # see comment on test_static_tool_sees_all_symbols
-@pytest.mark.redistributors_should_skip()
+@pytest.mark.redistributors_should_skip
 # Static analysis tools often have trouble with alpha releases, where Python's
 # internals are in flux, grammar may not have settled down, etc.
 @pytest.mark.skipif(

src/trio/_tests/test_fakenet.py

@@ -64,7 +64,7 @@ async def test_msg_trunc() -> None:
     s2 = trio.socket.socket(type=trio.socket.SOCK_DGRAM)
     await s1.bind(("127.0.0.1", 0))
     await s2.sendto(b"xyz", s1.getsockname())
-    data, addr = await s1.recvfrom(10)
+    await s1.recvfrom(10)
 
 
 async def test_recv_methods() -> None:

src/trio/_tests/test_file_io.py

@@ -199,7 +199,7 @@ async def test_async_methods_wrap(
         wrapped.reset_mock()
 
 
-async def test_async_methods_match_wrapper(
+def test_async_methods_match_wrapper(
     async_file: AsyncIOWrapper[mock.Mock],
     wrapped: mock.Mock,
 ) -> None:

src/trio/_tests/test_highlevel_open_tcp_listeners.py

@@ -329,7 +329,7 @@ async def test_open_tcp_listeners_some_address_families_unavailable(
 ) -> None:
     fsf = FakeSocketFactory(
         10,
-        raise_on_family={family: errno.EAFNOSUPPORT for family in fail_families},
+        raise_on_family=dict.fromkeys(fail_families, errno.EAFNOSUPPORT),
     )
     tsocket.set_custom_socket_factory(fsf)
     tsocket.set_custom_hostname_resolver(
@@ -402,7 +402,7 @@ async def test_open_tcp_listeners_backlog() -> None:
 async def test_open_tcp_listeners_backlog_float_error() -> None:
     fsf = FakeSocketFactory(99)
     tsocket.set_custom_socket_factory(fsf)
-    for should_fail in (0.0, 2.18, 3.14, 9.75):
+    for should_fail in (0.0, 2.18, 3.15, 9.75):
         with pytest.raises(
             TypeError,
             match=f"backlog must be an int or None, not {should_fail!r}",

src/trio/_tests/test_highlevel_open_tcp_stream.py

@@ -382,21 +382,21 @@ async def run_scenario(
 
 
 async def test_one_host_quick_success(autojump_clock: MockClock) -> None:
-    sock, scenario = await run_scenario(80, [("1.2.3.4", 0.123, "success")])
+    sock, _scenario = await run_scenario(80, [("1.2.3.4", 0.123, "success")])
     assert isinstance(sock, FakeSocket)
     assert sock.ip == "1.2.3.4"
     assert trio.current_time() == 0.123
 
 
 async def test_one_host_slow_success(autojump_clock: MockClock) -> None:
-    sock, scenario = await run_scenario(81, [("1.2.3.4", 100, "success")])
+    sock, _scenario = await run_scenario(81, [("1.2.3.4", 100, "success")])
     assert isinstance(sock, FakeSocket)
     assert sock.ip == "1.2.3.4"
     assert trio.current_time() == 100
 
 
 async def test_one_host_quick_fail(autojump_clock: MockClock) -> None:
-    exc, scenario = await run_scenario(
+    exc, _scenario = await run_scenario(
         82,
         [("1.2.3.4", 0.123, "error")],
         expect_error=OSError,
@@ -406,7 +406,7 @@ async def test_one_host_quick_fail(autojump_clock: MockClock) -> None:
 
 
 async def test_one_host_slow_fail(autojump_clock: MockClock) -> None:
-    exc, scenario = await run_scenario(
+    exc, _scenario = await run_scenario(
         83,
         [("1.2.3.4", 100, "error")],
         expect_error=OSError,
@@ -416,7 +416,7 @@ async def test_one_host_slow_fail(autojump_clock: MockClock) -> None:
 
 
 async def test_one_host_failed_after_connect(autojump_clock: MockClock) -> None:
-    exc, scenario = await run_scenario(
+    exc, _scenario = await run_scenario(
         83,
         [("1.2.3.4", 1, "postconnect_fail")],
         expect_error=KeyboardInterrupt,
@@ -656,7 +656,7 @@ async def test_handles_no_ipv6(autojump_clock: MockClock) -> None:
 
 
 async def test_no_hosts(autojump_clock: MockClock) -> None:
-    exc, scenario = await run_scenario(80, [], expect_error=OSError)
+    exc, _scenario = await run_scenario(80, [], expect_error=OSError)
     assert "no results found" in str(exc)