chore: format files with ruff 0.9 (#1360)

Author: davidzhao

livekit-agents/livekit/agents/ipc/job_thread_executor.py

@@ -140,9 +140,9 @@ async def initialize(self) -> None:
                 channel.arecv_message(self._pch, proto.IPC_MESSAGES),
                 timeout=self._opts.initialize_timeout,
             )
-            assert isinstance(
-                init_res, proto.InitializeResponse
-            ), "first message must be InitializeResponse"
+            assert isinstance(init_res, proto.InitializeResponse), (
+                "first message must be InitializeResponse"
+            )
         except asyncio.TimeoutError:
             self._initialize_fut.set_exception(
                 asyncio.TimeoutError("runner initialization timed out")

livekit-agents/livekit/agents/ipc/proc_client.py

@@ -53,9 +53,9 @@ def initialize(self) -> None:
             cch = aio.duplex_unix._Duplex.open(self._mp_cch)
             first_req = recv_message(cch, IPC_MESSAGES)
 
-            assert isinstance(
-                first_req, InitializeRequest
-            ), "first message must be proto.InitializeRequest"
+            assert isinstance(first_req, InitializeRequest), (
+                "first message must be proto.InitializeRequest"
+            )
 
             self._init_req = first_req
             self._initialize_fnc(self._init_req, self)

livekit-agents/livekit/agents/ipc/supervised_proc.py

@@ -165,9 +165,9 @@ async def initialize(self) -> None:
                 channel.arecv_message(self._pch, proto.IPC_MESSAGES),
                 timeout=self._opts.initialize_timeout,
             )
-            assert isinstance(
-                init_res, proto.InitializeResponse
-            ), "first message must be InitializeResponse"
+            assert isinstance(init_res, proto.InitializeResponse), (
+                "first message must be InitializeResponse"
+            )
         except asyncio.TimeoutError:
             self._initialize_fut.set_exception(
                 asyncio.TimeoutError("process initialization timed out")

livekit-agents/livekit/agents/pipeline/pipeline_agent.py

@@ -889,9 +889,9 @@ async def _execute_function_calls() -> None:
                 return
 
             assert isinstance(speech_handle.source, LLMStream)
-            assert (
-                not user_question or speech_handle.user_committed
-            ), "user speech should have been committed before using tools"
+            assert not user_question or speech_handle.user_committed, (
+                "user speech should have been committed before using tools"
+            )
 
             llm_stream = speech_handle.source
 
@@ -1040,9 +1040,9 @@ def _synthesize_agent_speech(
         speech_id: str,
         source: str | LLMStream | AsyncIterable[str],
     ) -> SynthesisHandle:
-        assert (
-            self._agent_output is not None
-        ), "agent output should be initialized when ready"
+        assert self._agent_output is not None, (
+            "agent output should be initialized when ready"
+        )
 
         tk = SpeechDataContextVar.set(SpeechData(speech_id))
 

livekit-agents/livekit/agents/stt/stt.py

@@ -248,9 +248,9 @@ async def _metrics_monitor_task(
 
         async for ev in event_aiter:
             if ev.type == SpeechEventType.RECOGNITION_USAGE:
-                assert (
-                    ev.recognition_usage is not None
-                ), "recognition_usage must be provided for RECOGNITION_USAGE event"
+                assert ev.recognition_usage is not None, (
+                    "recognition_usage must be provided for RECOGNITION_USAGE event"
+                )
 
                 duration = time.perf_counter() - start_time
                 stt_metrics = STTMetrics(

livekit-plugins/livekit-plugins-llama-index/livekit/plugins/llama_index/llm.py

@@ -74,9 +74,9 @@ async def _run(self) -> None:
                 "The last message in the chat context must be from the user"
             )
 
-        assert isinstance(
-            user_msg.content, str
-        ), "user message content must be a string"
+        assert isinstance(user_msg.content, str), (
+            "user message content must be a string"
+        )
 
         try:
             if not self._stream:

livekit-plugins/livekit-plugins-silero/livekit/plugins/silero/vad.py

@@ -86,7 +86,9 @@ async def entrypoint(ctx: JobContext):
 
 
             if __name__ == "__main__":
-                cli.run_app(WorkerOptions(entrypoint_fnc=entrypoint, prewarm_fnc=prewarm))
+                cli.run_app(
+                    WorkerOptions(entrypoint_fnc=entrypoint, prewarm_fnc=prewarm)
+                )
             ```
 
         Args:

livekit-plugins/livekit-plugins-turn-detector/livekit/plugins/turn_detector/eou.py

@@ -193,9 +193,9 @@ async def predict_end_of_turn(
             timeout=timeout,
         )
 
-        assert (
-            result is not None
-        ), "end_of_utterance prediction should always returns a result"
+        assert result is not None, (
+            "end_of_utterance prediction should always returns a result"
+        )
 
         result_json = json.loads(result.decode())
         return result_json["eou_probability"]

tests/test_create_func.py

@@ -16,9 +16,9 @@ def test_fn(
             pass
 
     fnc_ctx = TestFunctionContext()
-    assert (
-        "test_function" in fnc_ctx.ai_functions
-    ), "Function should be registered in ai_functions"
+    assert "test_function" in fnc_ctx.ai_functions, (
+        "Function should be registered in ai_functions"
+    )
 
     fnc_info = fnc_ctx.ai_functions["test_function"]
     build_info = _oai_api.build_oai_function_description(fnc_info)
@@ -69,9 +69,9 @@ def test_fn(self):
             pass
 
     fnc_ctx = TestFunctionContext()
-    assert (
-        "test_fn" in fnc_ctx.ai_functions
-    ), "Function should be registered in ai_functions"
+    assert "test_fn" in fnc_ctx.ai_functions, (
+        "Function should be registered in ai_functions"
+    )
 
     assert fnc_ctx.ai_functions["test_fn"].description == "A simple test function"
 
@@ -92,9 +92,9 @@ def optional_fn(
             pass
 
     fnc_ctx = TestFunctionContext()
-    assert (
-        "optional_function" in fnc_ctx.ai_functions
-    ), "Function should be registered in ai_functions"
+    assert "optional_function" in fnc_ctx.ai_functions, (
+        "Function should be registered in ai_functions"
+    )
 
     fnc_info = fnc_ctx.ai_functions["optional_function"]
     build_info = _oai_api.build_oai_function_description(fnc_info)
@@ -159,9 +159,9 @@ def list_fn(
             pass
 
     fnc_ctx = TestFunctionContext()
-    assert (
-        "list_function" in fnc_ctx.ai_functions
-    ), "Function should be registered in ai_functions"
+    assert "list_function" in fnc_ctx.ai_functions, (
+        "Function should be registered in ai_functions"
+    )
 
     fnc_info = fnc_ctx.ai_functions["list_function"]
     build_info = _oai_api.build_oai_function_description(fnc_info)
@@ -202,9 +202,9 @@ def enum_fn(
             pass
 
     fnc_ctx = TestFunctionContext()
-    assert (
-        "enum_function" in fnc_ctx.ai_functions
-    ), "Function should be registered in ai_functions"
+    assert "enum_function" in fnc_ctx.ai_functions, (
+        "Function should be registered in ai_functions"
+    )
 
     fnc_info = fnc_ctx.ai_functions["enum_function"]
     build_info = _oai_api.build_oai_function_description(fnc_info)

tests/test_ipc.py

@@ -354,9 +354,9 @@ async def test_shutdown_no_job():
 
     assert proc.exitcode == 0
     assert not proc.killed
-    assert (
-        start_args.shutdown_counter.value == 0
-    ), "shutdown_cb isn't called when there is no job"
+    assert start_args.shutdown_counter.value == 0, (
+        "shutdown_cb isn't called when there is no job"
+    )
 
 
 async def test_job_slow_shutdown():

tests/test_llm.py

@@ -194,9 +194,9 @@ async def test_cancelled_calls(llm_factory: Callable[[], llm.LLM]):
     await stream.aclose()
 
     assert len(calls) == 1
-    assert isinstance(
-        calls[0].exception, asyncio.CancelledError
-    ), "toggle_light should have been cancelled"
+    assert isinstance(calls[0].exception, asyncio.CancelledError), (
+        "toggle_light should have been cancelled"
+    )
 
 
 @pytest.mark.parametrize("llm_factory", LLMS)
@@ -219,9 +219,9 @@ async def test_calls_arrays(llm_factory: Callable[[], llm.LLM]):
     call = calls[0]
     currencies = call.call_info.arguments["currencies"]
     assert len(currencies) == 3, "select_currencies should have 3 currencies"
-    assert (
-        "eur" in currencies and "gbp" in currencies and "sek" in currencies
-    ), "select_currencies should have eur, gbp, sek"
+    assert "eur" in currencies and "gbp" in currencies and "sek" in currencies, (
+        "select_currencies should have eur, gbp, sek"
+    )
 
 
 @pytest.mark.parametrize("llm_factory", LLMS)
@@ -341,9 +341,9 @@ async def test_tool_choice_options(
     if tool_choice == "none" and isinstance(input_llm, anthropic.LLM):
         assert True
     else:
-        assert (
-            call_names == expected_calls
-        ), f"Test '{description}' failed: Expected calls {expected_calls}, but got {call_names}"
+        assert call_names == expected_calls, (
+            f"Test '{description}' failed: Expected calls {expected_calls}, but got {call_names}"
+        )
 
 
 async def _request_fnc_call(

tests/test_message_change.py

@@ -43,9 +43,9 @@ def test_find_longest_increasing_subsequence(indices, expected_seq, desc):
         assert result[0] == 0, f"First index not included in {desc}"
 
     # Verify sequence matches expected
-    assert (
-        result_seq == expected_seq
-    ), f"Wrong sequence in {desc}: expected {expected_seq}, got {result_seq}"
+    assert result_seq == expected_seq, (
+        f"Wrong sequence in {desc}: expected {expected_seq}, got {result_seq}"
+    )
 
 
 @pytest.mark.parametrize(

tests/test_stt.py

@@ -99,9 +99,9 @@ async def _stream_output():
 
         async for event in stream:
             if event.type == agents.stt.SpeechEventType.START_OF_SPEECH:
-                assert (
-                    recv_end
-                ), "START_OF_SPEECH recv but no END_OF_SPEECH has been sent before"
+                assert recv_end, (
+                    "START_OF_SPEECH recv but no END_OF_SPEECH has been sent before"
+                )
                 assert not recv_start
                 recv_end = False
                 recv_start = True

tests/test_tts.py

@@ -37,9 +37,9 @@ async def _assert_valid_synthesized_audio(
 
     merged_frame = merge_frames(frames)
     assert merged_frame.sample_rate == tts.sample_rate, "sample rate should be the same"
-    assert (
-        merged_frame.num_channels == tts.num_channels
-    ), "num channels should be the same"
+    assert merged_frame.num_channels == tts.num_channels, (
+        "num channels should be the same"
+    )
 
 
 SYNTHESIZE_TTS: list[Callable[[], tts.TTS]] = [