chore: format

Author: sysid

.pre-commit-config.yaml

@@ -1,6 +1,6 @@
 repos:
   - repo: https://github.com/astral-sh/ruff-pre-commit
-    rev: v0.8.4
+    rev: v0.14.13
     hooks:
       - id: ruff-format
         files: ^(sse_starlette|tests)/

Makefile

@@ -107,18 +107,18 @@ QUALITY:  ## ############################################################
 
 .PHONY: format
 format:  ## perform ruff formatting
-	@ruff format $(pkg_src) $(tests_src)
+	@pre-commit run ruff-format --all-files
 
-.PHONY: format-check
-format-check:  ## perform black formatting
-	@ruff format --check $(pkg_src) $(tests_src)
+# .PHONY: format-check
+# format-check:  ## check ruff formatting
+# 	@ruff format --check $(pkg_src) $(tests_src)
 
 .PHONY: style
 style: format  ## perform code style format
 
 .PHONY: lint
 lint:  ## check style with ruff
-	ruff check $(pkg_src) $(tests_src)
+	ruff check --fix $(pkg_src) $(tests_src)
 
 .PHONY: mypy
 mypy:  ## check type hint annotations

tests/experimentation/test_multiple_consumers_asyncio.py

@@ -197,9 +197,9 @@ async def test_sse_multiple_consumers(
 
                 # Verify expectations
                 for i, client in enumerate(clients):
-                    assert (
-                        client.received_lines == expected_lines
-                    ), f"Client {i} received {client.received_lines} lines, expected {expected_lines}"
+                    assert client.received_lines == expected_lines, (
+                        f"Client {i} received {client.received_lines} lines, expected {expected_lines}"
+                    )
 
                 assert not errors, f"Consumers encountered errors: {errors}"
 

tests/experimentation/test_multiple_consumers_threads.py

@@ -115,9 +115,7 @@ async def make_arequest(url, expected_lines=2):
         except httpcore.RemoteProtocolError as e:
             _log.error(e)
         finally:
-            assert (
-                i == expected_lines
-            ), (
+            assert i == expected_lines, (
                 f"Expected {expected_lines} lines"
             )  # not part of test runner, failure is not reported
 
@@ -128,9 +126,7 @@ async def make_arequest(url, expected_lines=2):
         # i=0, line='data: 1'
         # i=1, line=''
         # ...
-        assert (
-            i == expected_lines
-        ), (
+        assert i == expected_lines, (
             f"Expected {expected_lines} lines"
         )  # not part of test runner, failure is not reported
 

tests/integration/test_multiple_consumers.py

@@ -85,9 +85,9 @@ async def test_sse_server_termination(caplog, app_path, expected_lines):
 
         # Check error count: one connection error per client
         error_count = sum(1 for _, error in results if error is not None)
-        assert (
-            error_count == N_CONSUMERS
-        ), f"Expected {N_CONSUMERS} errors, got {error_count}"
+        assert error_count == N_CONSUMERS, (
+            f"Expected {N_CONSUMERS} errors, got {error_count}"
+        )
 
         # Verify error messages
         for _, error in results:
@@ -102,9 +102,9 @@ async def test_sse_server_termination(caplog, app_path, expected_lines):
         _log.info(f"Message counts received: {message_counts}")
 
         # Since we're killing the server early, we expect incomplete message counts
-        assert all(
-            count < expected_lines for count in message_counts
-        ), f"Expected all counts to be less than {expected_lines}, got {message_counts}"
+        assert all(count < expected_lines for count in message_counts), (
+            f"Expected all counts to be less than {expected_lines}, got {message_counts}"
+        )
 
     finally:
         # Cleanup container if it's still around

tests/test_issue152.py

@@ -124,9 +124,9 @@ async def tracking_watcher():
 
             await asyncio.sleep(0.1)
 
-            assert (
-                len(watcher_starts) == 1
-            ), f"Rapid calls spawned {len(watcher_starts)} watchers, expected 1"
+            assert len(watcher_starts) == 1, (
+                f"Rapid calls spawned {len(watcher_starts)} watchers, expected 1"
+            )
         finally:
             sse_module._shutdown_watcher = original_watcher
 

tests/test_multi_loop.py

@@ -84,9 +84,9 @@ async def get_state():
 
         assert not errors, f"Errors occurred: {errors}"
         assert len(states) == 3
-        assert (
-            len(set(id(s) for s in states)) == 3
-        ), "States should be unique per thread"
+        assert len(set(id(s) for s in states)) == 3, (
+            "States should be unique per thread"
+        )
 
 
 class TestIssue149HandleExitSignaling:
@@ -162,9 +162,9 @@ async def wait_for_exit(task_id: int):
             except asyncio.CancelledError:
                 pass
 
-        assert (
-            len(exited) == num_tasks
-        ), f"Only {len(exited)}/{num_tasks} tasks woke up."
+        assert len(exited) == num_tasks, (
+            f"Only {len(exited)}/{num_tasks} tasks woke up."
+        )
 
     @pytest.mark.asyncio
     async def test_manual_shutdown_ignores_signal(self):
@@ -184,14 +184,14 @@ async def wait_for_exit():
             AppStatus.original_handler = None
             AppStatus.handle_exit()
             await asyncio.sleep(1.0)
-            assert (
-                not task_exited.is_set()
-            ), "Task woke up despite automatic signaling being disabled."
+            assert not task_exited.is_set(), (
+                "Task woke up despite automatic signaling being disabled."
+            )
             AppStatus.should_exit = True  # Manually signal shutdown
             await asyncio.wait([task], timeout=1.0)
-            assert (
-                task_exited.is_set()
-            ), "Task did not wake up after manual shutdown signal."
+            assert task_exited.is_set(), (
+                "Task did not wake up after manual shutdown signal."
+            )
         finally:
             AppStatus.enable_automatic_graceful_drain = original_drain
             AppStatus.original_handler = original_handler
@@ -258,7 +258,9 @@ async def wait_for_exit():
             # If the uvicorn check weren't bypassed, task would wake up
             await asyncio.sleep(1.0)
 
-            assert not task_exited.is_set(), "Task woke up from uvicorn.should_exit despite auto-drain being disabled."
+            assert not task_exited.is_set(), (
+                "Task woke up from uvicorn.should_exit despite auto-drain being disabled."
+            )
 
             # Now manually signal shutdown
             AppStatus.should_exit = True