Format using Ruff instead of Black.

.git-blame-ignore-revs

@@ -1,2 +1,4 @@
 # sorting all imports with isort
 933f77b96f0092e1baab4474a9208fc2e379aa32
+# reformatting using ruff
+1507cca4728ffcd9ded19c410bb134cd96df522a

.pre-commit-config.yaml

@@ -18,13 +18,10 @@ repos:
       - id: check-case-conflict
       - id: sort-simple-yaml
         files: .pre-commit-config.yaml
-  - repo: https://github.com/psf/black-pre-commit-mirror
-    rev: 24.3.0
-    hooks:
-      - id: black
   - repo: https://github.com/astral-sh/ruff-pre-commit
     rev: v0.3.5
     hooks:
+      - id: ruff-format
       - id: ruff
         types: [file]
         types_or: [python, pyi, toml]

check.sh

@@ -22,13 +22,13 @@ echo "::endgroup::"
 # see https://forum.bors.tech/t/pre-test-and-pre-merge-hooks/322)
 # autoflake --recursive --in-place .
 # pyupgrade --py3-plus $(find . -name "*.py")
-echo "::group::Black"
-if ! black --check src/trio; then
-    echo "* Black found issues" >> "$GITHUB_STEP_SUMMARY"
+echo "::group::Ruff-Format"
+if ! ruff format --check src/trio; then
+    echo "* Ruff found issues" >> "$GITHUB_STEP_SUMMARY"
     EXIT_STATUS=1
-    black --diff src/trio
+    ruff format --diff src/trio
     echo "::endgroup::"
-    echo "::error:: Black found issues"
+    echo "::error:: Ruff found issues"
 else
     echo "::endgroup::"
 fi

src/trio/__init__.py

@@ -1,5 +1,4 @@
-"""Trio - A friendly Python library for async concurrency and I/O
-"""
+"""Trio - A friendly Python library for async concurrency and I/O"""
 
 from __future__ import annotations
 

src/trio/_channel.py

@@ -96,7 +96,8 @@ def _open_memory_channel(
     # Need to use Tuple instead of tuple due to CI check running on 3.8
     class open_memory_channel(Tuple["MemorySendChannel[T]", "MemoryReceiveChannel[T]"]):
         def __new__(  # type: ignore[misc]  # "must return a subtype"
-            cls, max_buffer_size: int | float  # noqa: PYI041
+            cls,
+            max_buffer_size: int | float,  # noqa: PYI041
         ) -> tuple[MemorySendChannel[T], MemoryReceiveChannel[T]]:
             return _open_memory_channel(max_buffer_size)
 

src/trio/_core/_generated_io_epoll.py

@@ -18,7 +18,7 @@
 __all__ = ["notify_closing", "wait_readable", "wait_writable"]
 
 
-async def wait_readable(fd: int | _HasFileNo) -> None:
+async def wait_readable(fd: (int | _HasFileNo)) -> None:
     """Block until the kernel reports that the given object is readable.
 
     On Unix systems, ``fd`` must either be an integer file descriptor,
@@ -47,7 +47,7 @@ async def wait_readable(fd: int | _HasFileNo) -> None:
         raise RuntimeError("must be called from async context") from None
 
 
-async def wait_writable(fd: int | _HasFileNo) -> None:
+async def wait_writable(fd: (int | _HasFileNo)) -> None:
     """Block until the kernel reports that the given object is writable.
 
     See `wait_readable` for the definition of ``fd``.
@@ -66,7 +66,7 @@ async def wait_writable(fd: int | _HasFileNo) -> None:
         raise RuntimeError("must be called from async context") from None
 
 
-def notify_closing(fd: int | _HasFileNo) -> None:
+def notify_closing(fd: (int | _HasFileNo)) -> None:
     """Notify waiters of the given object that it will be closed.
 
     Call this before closing a file descriptor (on Unix) or socket (on

src/trio/_core/_generated_io_kqueue.py

@@ -71,7 +71,7 @@ async def wait_kevent(
         raise RuntimeError("must be called from async context") from None
 
 
-async def wait_readable(fd: int | _HasFileNo) -> None:
+async def wait_readable(fd: (int | _HasFileNo)) -> None:
     """Block until the kernel reports that the given object is readable.
 
     On Unix systems, ``fd`` must either be an integer file descriptor,
@@ -100,7 +100,7 @@ async def wait_readable(fd: int | _HasFileNo) -> None:
         raise RuntimeError("must be called from async context") from None
 
 
-async def wait_writable(fd: int | _HasFileNo) -> None:
+async def wait_writable(fd: (int | _HasFileNo)) -> None:
     """Block until the kernel reports that the given object is writable.
 
     See `wait_readable` for the definition of ``fd``.
@@ -119,7 +119,7 @@ async def wait_writable(fd: int | _HasFileNo) -> None:
         raise RuntimeError("must be called from async context") from None
 
 
-def notify_closing(fd: int | _HasFileNo) -> None:
+def notify_closing(fd: (int | _HasFileNo)) -> None:
     """Notify waiters of the given object that it will be closed.
 
     Call this before closing a file descriptor (on Unix) or socket (on

src/trio/_core/_generated_io_windows.py

@@ -32,7 +32,7 @@
 ]
 
 
-async def wait_readable(sock: _HasFileNo | int) -> None:
+async def wait_readable(sock: (_HasFileNo | int)) -> None:
     """Block until the kernel reports that the given object is readable.
 
     On Unix systems, ``sock`` must either be an integer file descriptor,
@@ -61,7 +61,7 @@ async def wait_readable(sock: _HasFileNo | int) -> None:
         raise RuntimeError("must be called from async context") from None
 
 
-async def wait_writable(sock: _HasFileNo | int) -> None:
+async def wait_writable(sock: (_HasFileNo | int)) -> None:
     """Block until the kernel reports that the given object is writable.
 
     See `wait_readable` for the definition of ``sock``.
@@ -80,7 +80,7 @@ async def wait_writable(sock: _HasFileNo | int) -> None:
         raise RuntimeError("must be called from async context") from None
 
 
-def notify_closing(handle: Handle | int | _HasFileNo) -> None:
+def notify_closing(handle: (Handle | int | _HasFileNo)) -> None:
     """Notify waiters of the given object that it will be closed.
 
     Call this before closing a file descriptor (on Unix) or socket (on
@@ -112,7 +112,7 @@ def notify_closing(handle: Handle | int | _HasFileNo) -> None:
         raise RuntimeError("must be called from async context") from None
 
 
-def register_with_iocp(handle: int | CData) -> None:
+def register_with_iocp(handle: (int | CData)) -> None:
     """TODO: these are implemented, but are currently more of a sketch than
     anything real. See `#26
     <https://github.com/python-trio/trio/issues/26>`__ and `#52
@@ -125,7 +125,9 @@ def register_with_iocp(handle: int | CData) -> None:
         raise RuntimeError("must be called from async context") from None
 
 
-async def wait_overlapped(handle_: int | CData, lpOverlapped: CData | int) -> object:
+async def wait_overlapped(
+    handle_: (int | CData), lpOverlapped: (CData | int)
+) -> object:
     """TODO: these are implemented, but are currently more of a sketch than
     anything real. See `#26
     <https://github.com/python-trio/trio/issues/26>`__ and `#52
@@ -141,7 +143,7 @@ async def wait_overlapped(handle_: int | CData, lpOverlapped: CData | int) -> ob
 
 
 async def write_overlapped(
-    handle: int | CData, data: Buffer, file_offset: int = 0
+    handle: (int | CData), data: Buffer, file_offset: int = 0
 ) -> int:
     """TODO: these are implemented, but are currently more of a sketch than
     anything real. See `#26
@@ -158,7 +160,7 @@ async def write_overlapped(
 
 
 async def readinto_overlapped(
-    handle: int | CData, buffer: Buffer, file_offset: int = 0
+    handle: (int | CData), buffer: Buffer, file_offset: int = 0
 ) -> int:
     """TODO: these are implemented, but are currently more of a sketch than
     anything real. See `#26

src/trio/_core/_generated_run.py

@@ -130,7 +130,7 @@ def spawn_system_task(
     async_fn: Callable[[Unpack[PosArgT]], Awaitable[object]],
     *args: Unpack[PosArgT],
     name: object = None,
-    context: contextvars.Context | None = None,
+    context: (contextvars.Context | None) = None,
 ) -> Task:
     """Spawn a "system" task.
 

src/trio/_core/_parking_lot.py

@@ -182,7 +182,10 @@ def unpark_all(self) -> list[Task]:
 
     @_core.enable_ki_protection
     def repark(
-        self, new_lot: ParkingLot, *, count: int | float = 1  # noqa: PYI041
+        self,
+        new_lot: ParkingLot,
+        *,
+        count: int | float = 1,  # noqa: PYI041
     ) -> None:
         """Move parked tasks from one :class:`ParkingLot` object to another.
 

src/trio/_core/_traps.py

@@ -219,7 +219,7 @@ async def permanently_detach_coroutine_object(
 
 
 async def temporarily_detach_coroutine_object(
-    abort_func: Callable[[RaiseCancelT], Abort]
+    abort_func: Callable[[RaiseCancelT], Abort],
 ) -> Any:
     """Temporarily detach the current coroutine object from the Trio
     scheduler.

src/trio/_highlevel_open_tcp_stream.py

@@ -141,7 +141,7 @@ def reorder_for_rfc_6555_section_5_4(
             str,
             Any,
         ]
-    ]
+    ],
 ) -> None:
     # RFC 6555 section 5.4 says that if getaddrinfo returns multiple address
     # families (e.g. IPv4 and IPv6), then you should make sure that your first

src/trio/_path.py

@@ -31,7 +31,7 @@
 
 
 def _wraps_async(
-    wrapped: Callable[..., Any]
+    wrapped: Callable[..., Any],
 ) -> Callable[[Callable[P, T]], Callable[P, Awaitable[T]]]:
     def decorator(fn: Callable[P, T]) -> Callable[P, Awaitable[T]]:
         async def wrapper(*args: P.args, **kwargs: P.kwargs) -> T:

src/trio/_tests/check_type_completeness.py

@@ -7,6 +7,7 @@
 
 If this check is giving you false alarms, you can ignore them by adding logic to `has_docstring_at_runtime`, in the main loop in `check_type`, or by updating the json file.
 """
+
 from __future__ import annotations
 
 # this file is not run as part of the tests, instead it's run standalone from check.sh

src/trio/_tests/test_highlevel_open_tcp_stream.py

@@ -276,7 +276,9 @@ def socket(
         self.socket_count += 1
         return FakeSocket(self, family, type_, proto)
 
-    def _ip_to_gai_entry(self, ip: str) -> tuple[
+    def _ip_to_gai_entry(
+        self, ip: str
+    ) -> tuple[
         AddressFamily,
         SocketKind,
         int,

src/trio/_tests/test_socket.py

@@ -587,7 +587,7 @@ async def res(
                     | tuple[str, str]
                     | tuple[str, str, int]
                     | tuple[str, str, int, int]
-                )
+                ),
             ) -> Any:
                 return await sock._resolve_address_nocp(
                     args,

src/trio/_tests/test_ssl.py

@@ -409,7 +409,9 @@
 MemoryStapledStream: TypeAlias = StapledStream[MemorySendStream, MemoryReceiveStream]
 
 
-def ssl_memory_stream_pair(client_ctx: SSLContext, **kwargs: Any) -> tuple[
+def ssl_memory_stream_pair(
+    client_ctx: SSLContext, **kwargs: Any
+) -> tuple[
     SSLStream[MemoryStapledStream],
     SSLStream[MemoryStapledStream],
 ]:
@@ -420,7 +422,9 @@
 MyStapledStream: TypeAlias = StapledStream[SendStream, ReceiveStream]
 
 
-def ssl_lockstep_stream_pair(client_ctx: SSLContext, **kwargs: Any) -> tuple[
+def ssl_lockstep_stream_pair(
+    client_ctx: SSLContext, **kwargs: Any
+) -> tuple[
     SSLStream[MyStapledStream],
     SSLStream[MyStapledStream],
 ]:
@@ -837,20 +841,24 @@
 async def test_SSLStream_generic(
     client_ctx: SSLContext, https_compatible: bool
 ) -> None:
-    async def stream_maker() -> tuple[
-        SSLStream[MemoryStapledStream],
-        SSLStream[MemoryStapledStream],
-    ]:
+    async def stream_maker() -> (
+        tuple[
+            SSLStream[MemoryStapledStream],
+            SSLStream[MemoryStapledStream],
+        ]
+    ):
         return ssl_memory_stream_pair(
             client_ctx,
             client_kwargs={"https_compatible": https_compatible},
             server_kwargs={"https_compatible": https_compatible},
         )
 
-    async def clogged_stream_maker() -> tuple[
-        SSLStream[MyStapledStream],
-        SSLStream[MyStapledStream],
-    ]:
+    async def clogged_stream_maker() -> (
+        tuple[
+            SSLStream[MyStapledStream],
+            SSLStream[MyStapledStream],
+        ]
+    ):
         client, server = ssl_lockstep_stream_pair(client_ctx)
         # If we don't do handshakes up front, then we run into a problem in
         # the following situation:

src/trio/_tests/test_testing.py

@@ -602,10 +602,12 @@ async def one_way_stream_maker() -> tuple[MemorySendStream, MemoryReceiveStream]
 
     await check_one_way_stream(one_way_stream_maker, None)
 
-    async def half_closeable_stream_maker() -> tuple[
-        StapledStream[MemorySendStream, MemoryReceiveStream],
-        StapledStream[MemorySendStream, MemoryReceiveStream],
-    ]:
+    async def half_closeable_stream_maker() -> (
+        tuple[
+            StapledStream[MemorySendStream, MemoryReceiveStream],
+            StapledStream[MemorySendStream, MemoryReceiveStream],
+        ]
+    ):
         return memory_stream_pair()
 
     await check_half_closeable_stream(half_closeable_stream_maker, None)
@@ -617,10 +619,12 @@ async def one_way_stream_maker() -> tuple[SendStream, ReceiveStream]:
 
     await check_one_way_stream(one_way_stream_maker, one_way_stream_maker)
 
-    async def two_way_stream_maker() -> tuple[
-        StapledStream[SendStream, ReceiveStream],
-        StapledStream[SendStream, ReceiveStream],
-    ]:
+    async def two_way_stream_maker() -> (
+        tuple[
+            StapledStream[SendStream, ReceiveStream],
+            StapledStream[SendStream, ReceiveStream],
+        ]
+    ):
         return lockstep_stream_pair()
 
     await check_two_way_stream(two_way_stream_maker, two_way_stream_maker)

src/trio/_tests/tools/test_gen_exports.py

@@ -19,7 +19,6 @@
     create_passthrough_args,
     get_public_methods,
     process,
-    run_black,
     run_linters,
     run_ruff,
 )
@@ -93,12 +92,6 @@ def test_create_pass_through_args() -> None:
 @skip_lints
 @pytest.mark.parametrize("imports", [IMPORT_1, IMPORT_2, IMPORT_3])
 def test_process(tmp_path: Path, imports: str) -> None:
-    try:
-        import black  # noqa: F401
-    # there's no dedicated CI run that has astor+isort, but lacks black.
-    except ImportError as error:  # pragma: no cover
-        skip_if_optional_else_raise(error)
-
     modpath = tmp_path / "_module.py"
     genpath = tmp_path / "_generated_module.py"
     modpath.write_text(SOURCE, encoding="utf-8")
@@ -123,23 +116,6 @@ def test_process(tmp_path: Path, imports: str) -> None:
     assert excinfo.value.code == 1
 
 
-@skip_lints
-def test_run_black(tmp_path: Path) -> None:
-    """Test that processing properly fails if black does."""
-    try:
-        import black  # noqa: F401
-    except ImportError as error:  # pragma: no cover
-        skip_if_optional_else_raise(error)
-
-    file = File(tmp_path / "module.py", "module")
-
-    success, _ = run_black(file, "class not valid code ><")
-    assert not success
-
-    success, _ = run_black(file, "import waffle\n;import trio")
-    assert not success
-
-
 @skip_lints
 def test_run_ruff(tmp_path: Path) -> None:
     """Test that processing properly fails if ruff does."""
@@ -168,9 +144,8 @@ def test_run_ruff(tmp_path: Path) -> None:
 
 @skip_lints
 def test_lint_failure(tmp_path: Path) -> None:
-    """Test that processing properly fails if black or ruff does."""
+    """Test that processing properly fails if ruff does."""
     try:
-        import black  # noqa: F401
         import ruff  # noqa: F401
     except ImportError as error:  # pragma: no cover
         skip_if_optional_else_raise(error)