Raise errors automatically (#69)

* Add auto errors

* change code

---------

Co-authored-by: Freddy Boulton <freddyboulton@hf-freddy.local>

docs/CNAME

@@ -0,0 +1 @@
+fastrtc.org

docs/index.md

@@ -63,56 +63,29 @@ The `Stream` has three main methods:
 === "LLM Voice Chat"
 
     ```py
-    from fastrtc import (
-        ReplyOnPause, AdditionalOutputs, Stream,
-        audio_to_bytes, aggregate_bytes_to_16bit
+    import os
+
+    from fastrtc import (ReplyOnPause, Stream, get_stt_model, get_tts_model)
+    from openai import OpenAI
+
+    sambanova_client = OpenAI(
+        api_key=os.getenv("SAMBANOVA_API_KEY"), base_url="https://api.sambanova.ai/v1"
     )
-    import gradio as gr
-    from groq import Groq
-    import anthropic
-    from elevenlabs import ElevenLabs
+    stt_model = get_stt_model()
+    tts_model = get_tts_model()
 
-    groq_client = Groq()
-    claude_client = anthropic.Anthropic()
-    tts_client = ElevenLabs()
-
-    
-    # See "Talk to Claude" in Cookbook for an example of how to keep 
-    # track of the chat history.
-    def response(
-        audio: tuple[int, np.ndarray],
-    ):
-        prompt = groq_client.audio.transcriptions.create(
-            file=("audio-file.mp3", audio_to_bytes(audio)),
-            model="whisper-large-v3-turbo",
-            response_format="verbose_json",
-        ).text
-        response = claude_client.messages.create(
-            model="claude-3-5-haiku-20241022",
-            max_tokens=512,
+    def echo(audio):
+        prompt = stt_model.stt(audio)
+        response = sambanova_client.chat.completions.create(
+            model="Meta-Llama-3.2-3B-Instruct",
             messages=[{"role": "user", "content": prompt}],
+            max_tokens=200,
         )
-        response_text = " ".join(
-            block.text
-            for block in response.content
-            if getattr(block, "type", None) == "text"
-        )
-        iterator = tts_client.text_to_speech.convert_as_stream(
-            text=response_text,
-            voice_id="JBFqnCBsd6RMkjVDRZzb",
-            model_id="eleven_multilingual_v2",
-            output_format="pcm_24000"
-            
-        )
-        for chunk in aggregate_bytes_to_16bit(iterator):
-            audio_array = np.frombuffer(chunk, dtype=np.int16).reshape(1, -1)
-            yield (24000, audio_array)
+        prompt = response.choices[0].message.content
+        for audio_chunk in tts_model.stream_tts_sync(prompt):
+            yield audio_chunk
 
-    stream = Stream(
-        modality="audio",
-        mode="send-receive",
-        handler=ReplyOnPause(response),
-    )
+    stream = Stream(ReplyOnPause(echo), modality="audio", mode="send-receive")
     ```
 
 === "Webcam Stream"

docs/userguide/audio.md

@@ -1,4 +1,3 @@
-# Audio Streaming
 
 ## Reply On Pause
 
@@ -133,18 +132,21 @@ The API is similar to `ReplyOnPause` with the addition of a `stop_words` paramet
     ```
 
     1. The `StreamHandler` class implements three methods: `receive`, `emit` and `copy`. The `receive` method is called when a new frame is received from the client, and the `emit` method returns the next frame to send to the client. The `copy` method is called at the beginning of the stream to ensure each user has a unique stream handler.
-    2. The `emit` method SHOULD NOT block. If a frame is not ready to be sent, the method should return `None`.
+    2. The `emit` method SHOULD NOT block. If a frame is not ready to be sent, the method should return `None`. If you need to wait for a frame, use [`wait_for_item`](../../utils#wait_for_item) from the `utils` module.
     3. The `shutdown` method is called when the stream is closed. It should be used to clean up any resources.
     4. The `start_up` method is called when the stream is first created. It should be used to initialize any resources. See [Talk To OpenAI](https://huggingface.co/spaces/fastrtc/talk-to-openai-gradio) or [Talk To Gemini](https://huggingface.co/spaces/fastrtc/talk-to-gemini-gradio) for an example of a `StreamHandler` that uses the `start_up` method to connect to an API.    
 === "Notes"
     1. The `StreamHandler` class implements three methods: `receive`, `emit` and `copy`. The `receive` method is called when a new frame is received from the client, and the `emit` method returns the next frame to send to the client. The `copy` method is called at the beginning of the stream to ensure each user has a unique stream handler.
-    2. The `emit` method SHOULD NOT block. If a frame is not ready to be sent, the method should return `None`.
+    2. The `emit` method SHOULD NOT block. If a frame is not ready to be sent, the method should return `None`. If you need to wait for a frame, use [`wait_for_item`](../../utils#wait_for_item) from the `utils` module.
     3. The `shutdown` method is called when the stream is closed. It should be used to clean up any resources.
     4. The `start_up` method is called when the stream is first created. It should be used to initialize any resources. See [Talk To OpenAI](https://huggingface.co/spaces/fastrtc/talk-to-openai-gradio) or [Talk To Gemini](https://huggingface.co/spaces/fastrtc/talk-to-gemini-gradio) for an example of a `StreamHandler` that uses the `start_up` method to connect to an API.
 
 !!! tip
     See this [Talk To Gemini](https://huggingface.co/spaces/fastrtc/talk-to-gemini-gradio) for a complete example of a more complex stream handler.
 
+!!! warning
+    The `emit` method should not block. If you need to wait for a frame, use [`wait_for_item`](../../utils#wait_for_item) from the `utils` module.
+
 ## Async Stream Handlers
 
 It is also possible to create asynchronous stream handlers. This is very convenient for accessing async APIs from major LLM developers, like Google and OpenAI. The main difference is that `receive`, `emit`, and `start_up` are now defined with `async def`.

docs/utils.md

@@ -97,4 +97,27 @@ Example
 >>>     print(chunk)
 ```
 
+## `wait_for_item`
 
+Wait for an item from an asyncio.Queue with a timeout.
+
+Parameters
+```
+queue : asyncio.Queue
+    The queue to wait for an item from
+timeout : float
+    The timeout in seconds
+```
+Returns
+```
+Any
+    The item from the queue or None if the timeout is reached
+```
+
+Example
+```python
+>>> queue = asyncio.Queue()
+>>> queue.put_nowait(1)
+>>> item = await wait_for_item(queue)
+>>> print(item)
+```