introduce Ruff formatting

src/pipecat/transports/network/fastapi_websocket.py

@@ -19,7 +19,7 @@ from pipecat.frames.frames import (
     Frame,
     InputAudioRawFrame,
     StartFrame,
-    StartInterruptionFrame
+    StartInterruptionFrame,
 )
 from pipecat.processors.frame_processor import FrameDirection
 from pipecat.serializers.base_serializer import FrameSerializer
@@ -35,7 +35,8 @@ try:
 except ModuleNotFoundError as e:
     logger.error(f"Exception: {e}")
     logger.error(
-        "In order to use FastAPI websockets, you need to `pip install pipecat-ai[websocket]`.")
+        "In order to use FastAPI websockets, you need to `pip install pipecat-ai[websocket]`."
+    )
     raise Exception(f"Missing module: {e}")
 
 
@@ -51,13 +52,13 @@ class FastAPIWebsocketCallbacks(BaseModel):
 
 
 class FastAPIWebsocketInputTransport(BaseInputTransport):
-
     def __init__(
-            self,
-            websocket: WebSocket,
-            params: FastAPIWebsocketParams,
-            callbacks: FastAPIWebsocketCallbacks,
-            **kwargs):
+        self,
+        websocket: WebSocket,
+        params: FastAPIWebsocketParams,
+        callbacks: FastAPIWebsocketCallbacks,
+        **kwargs,
+    ):
         super().__init__(params, **kwargs)
 
         self._websocket = websocket
@@ -87,17 +88,18 @@ class FastAPIWebsocketInputTransport(BaseInputTransport):
                 continue
 
             if isinstance(frame, AudioRawFrame):
-                await self.push_audio_frame(InputAudioRawFrame(
-                    audio=frame.audio,
-                    sample_rate=frame.sample_rate,
-                    num_channels=frame.num_channels)
+                await self.push_audio_frame(
+                    InputAudioRawFrame(
+                        audio=frame.audio,
+                        sample_rate=frame.sample_rate,
+                        num_channels=frame.num_channels,
+                    )
                 )
 
         await self._callbacks.on_client_disconnected(self._websocket)
 
 
 class FastAPIWebsocketOutputTransport(BaseOutputTransport):
-
     def __init__(self, websocket: WebSocket, params: FastAPIWebsocketParams, **kwargs):
         super().__init__(params, **kwargs)
 
@@ -115,10 +117,9 @@ class FastAPIWebsocketOutputTransport(BaseOutputTransport):
         self._websocket_audio_buffer += frames
         while len(self._websocket_audio_buffer):
             frame = AudioRawFrame(
-                audio=self._websocket_audio_buffer[:
-                                                   self._params.audio_frame_size],
+                audio=self._websocket_audio_buffer[: self._params.audio_frame_size],
                 sample_rate=self._params.audio_out_sample_rate,
-                num_channels=self._params.audio_out_channels
+                num_channels=self._params.audio_out_channels,
             )
 
             if self._params.add_wav_header:
@@ -131,9 +132,8 @@ class FastAPIWebsocketOutputTransport(BaseOutputTransport):
                 ww.close()
                 content.seek(0)
                 wav_frame = AudioRawFrame(
-                    content.read(),
-                    sample_rate=frame.sample_rate,
-                    num_channels=frame.num_channels)
+                    content.read(), sample_rate=frame.sample_rate, num_channels=frame.num_channels
+                )
                 frame = wav_frame
 
             payload = self._params.serializer.serialize(frame)
@@ -141,7 +141,8 @@ class FastAPIWebsocketOutputTransport(BaseOutputTransport):
                 await self._websocket.send_text(payload)
 
             self._websocket_audio_buffer = self._websocket_audio_buffer[
-                self._params.audio_frame_size:]
+                self._params.audio_frame_size :
+            ]
 
     async def _write_frame(self, frame: Frame):
         payload = self._params.serializer.serialize(frame)
@@ -150,26 +151,28 @@ class FastAPIWebsocketOutputTransport(BaseOutputTransport):
 
 
 class FastAPIWebsocketTransport(BaseTransport):
-
     def __init__(
-            self,
-            websocket: WebSocket,
-            params: FastAPIWebsocketParams,
-            input_name: str | None = None,
-            output_name: str | None = None,
-            loop: asyncio.AbstractEventLoop | None = None):
+        self,
+        websocket: WebSocket,
+        params: FastAPIWebsocketParams,
+        input_name: str | None = None,
+        output_name: str | None = None,
+        loop: asyncio.AbstractEventLoop | None = None,
+    ):
         super().__init__(input_name=input_name, output_name=output_name, loop=loop)
         self._params = params
 
         self._callbacks = FastAPIWebsocketCallbacks(
             on_client_connected=self._on_client_connected,
-            on_client_disconnected=self._on_client_disconnected
+            on_client_disconnected=self._on_client_disconnected,
         )
 
         self._input = FastAPIWebsocketInputTransport(
-            websocket, self._params, self._callbacks, name=self._input_name)
+            websocket, self._params, self._callbacks, name=self._input_name
+        )
         self._output = FastAPIWebsocketOutputTransport(
-            websocket, self._params, name=self._output_name)
+            websocket, self._params, name=self._output_name
+        )
 
         # Register supported handlers. The user will only be able to register
         # these handlers.