switch to llama demo space, remove short prompt

app.py

@@ -1,32 +1,44 @@
+import inspect
 import gradio as gr
+
 from gradio_client import Client, handle_file
 
 import src.generate as generate
 import src.process as process
 
-# ------------------- Globals -------------------
 global client
 
-
-# ------------------- UI helper functions -------------------
+# TODO: Ideally, instead of the Client method we're using for an external voice cloning app, we use the .load() function and pass in arguments to it directly while displaying the developer's desired UI.
+#chatterbox_space = gr.load("spaces/ResembleAI/Chatterbox")
+# ------------------- UI printing functions -------------------
 def clear_all():
-    """Reset all displayed fields."""
-    return "", "", "", "", "", "", "", None,
+    # target, user_transcript, score_html, result_html, diff_html, tts_ui
+    return "", "", "", "", "", gr.Row.update(visible=False)
 
 
 def make_result_html(pass_threshold, passed, ratio):
-    """Returns HTML summarizing results."""
+    """Returns HTML summarizing results.
+    Parameters:
+        pass_threshold: Minimum percentage of match between target and recognized user utterance that counts as passing.
+        passed: Whether the recognized user utterance is >= `pass_threshold`.
+        ratio: Sequence match ratio.
+    """
     summary = (
         f"✅ Correct (≥ {int(pass_threshold * 100)}%)"
-        if passed
-        else f"❌ Not a match (need ≥ {int(pass_threshold * 100)}%)"
+        if passed else
+        f"❌ Not a match (need ≥ {int(pass_threshold * 100)}%)"
     )
     score = f"Similarity: {ratio * 100:.1f}%"
     return summary, score
 
 
 def make_alignment_html(ref_tokens, hyp_tokens, alignments):
-    """Returns HTML showing alignment between target and recognized user audio."""
+    """Returns HTML showing alignment between the target and recognized user audio.
+    Parameters:
+        ref_tokens: Target sentence for the user to say, tokenized.
+        hyp_tokens: Recognized utterance from the user, tokenized.
+        alignments: Tuples of alignment pattern (equal, delete, insert) and corresponding indices in `hyp_tokens`.
+    """
     out = []
     no_match_html = ' <span style="background:#ffe0e0;text-decoration:line-through;">'
     match_html = ' <span style="background:#e0ffe0;">'
@@ -43,118 +55,148 @@ def make_alignment_html(ref_tokens, hyp_tokens, alignments):
         elif op == "replace":
             out.append(no_match_html + ref_string + "</span>")
             out.append(match_html + hyp_string + "</span>")
-    html = '<div style="line-height:1.6;font-size:1rem;">' + "".join(out).strip() + "</div>"
+    html = '<div style="line-height:1.6;font-size:1rem;">' + "".join(
+        out).strip() + "</div>"
     return html
 
 
 def make_html(sentence_match):
-    """Creates the HTML for UI based on the sentence match."""
-    diff_html = make_alignment_html(
-        sentence_match.target_tokens,
-        sentence_match.user_tokens,
-        sentence_match.alignments,
-    )
-    result_html, score_html = make_result_html(
-        sentence_match.pass_threshold, sentence_match.passed, sentence_match.ratio
-    )
+    """Creates the HTML written out to the UI based on the results.
+    Parameters:
+        sentence_match: Class that stores the features of the target - user utterance alignment
+    Returns:
+        diff_html: An HTML string showing how the target sentence and recognized user utterance matches.
+        result_html: An HTML string summarizing the results of the match between target and user utterance.
+    """
+    diff_html = make_alignment_html(sentence_match.target_tokens,
+                                    sentence_match.user_tokens,
+                                    sentence_match.alignments)
+    result_html, score_html = make_result_html(sentence_match.pass_threshold,
+                                               sentence_match.passed,
+                                               sentence_match.ratio)
+
     return score_html, result_html, diff_html
 
 
 # ------------------- Core Check (English-only) -------------------
+# @spaces.GPU
 def get_user_transcript(audio_path: gr.Audio, target_sentence: str,
-                        model_id: str, device_pref: str):
-    """Runs ASR for the input audio."""
+                        model_id: str, device_pref: str) -> (str, str):
+    """ASR for the input audio and basic validation.
+    Uses the selected ASR model `model_id` to recognize words in the input `audio_path`.
+    Parameters:
+        audio_path: Processed audio file returned from gradio Audio component.
+        target_sentence: Sentence the user needs to say.
+        model_id: Desired ASR model.
+        device_pref: Preferred ASR processing device. Can be "auto", "cpu", "cuda".
+    Returns:
+        error_msg: If there's an error, a string describing what happened.
+        user_transcript: The recognized user utterance.
+    """
+    # Handles user interaction errors.
     if not target_sentence:
         return "Please generate a sentence first.", ""
+    # TODO: Automatically stop the recording if someone presses the Transcribe & Check button.
     if audio_path is None:
-        return (
-            "Please start, record, then stop the audio recording before trying to transcribe.",
-            "",
-        )
+        return "Please start, record, then stop the audio recording before trying to transcribe.", ""
 
+    # Runs the automatic speech recognition
     user_transcript = process.run_asr(audio_path, model_id, device_pref)
 
+    # Handles processing errors.
     if isinstance(user_transcript, Exception):
         return f"Transcription failed: {user_transcript}", ""
     return "", user_transcript
 
 
-def transcribe_check(audio_path, target_sentence, model_id, device_pref, pass_threshold):
-    """Transcribe user audio, compare with target, and generate HTML."""
+def transcribe_check(audio_path, target_sentence, model_id, device_pref,
+                     pass_threshold):
+    """Transcribe user, calculate match to target sentence, create results HTML.
+    Parameters:
+        audio_path: Local path to recorded audio.
+        target_sentence: Sentence the user needs to say.
+        model_id: Desired ASR model.
+        device_pref: Preferred ASR processing device. Can be "auto", "cpu", "cuda".
+    Returns:
+        user_transcript: The recognized user utterance
+        score_html: HTML string to display the score
+        diff_html: HTML string for displaying the differences between target and user utterance
+        result_html: HTML string describing the results, or an error message
+        clone_audio: Bool for whether to allow audio cloning: This makes the audio cloning components visible
+    """
     clone_audio = False
-
-    error_msg, user_transcript = get_user_transcript(
-        audio_path, target_sentence, model_id, device_pref
-    )
+    # Transcribe user input
+    error_msg, user_transcript = get_user_transcript(audio_path,
+                                                     target_sentence, model_id,
+                                                     device_pref)
     if error_msg:
         score_html = ""
         diff_html = ""
         result_html = error_msg
     else:
-        sentence_match = process.SentenceMatcher(
-            target_sentence, user_transcript, pass_threshold
-        )
+        # Calculate match details between the target and recognized user input
+        sentence_match = process.SentenceMatcher(target_sentence,
+                                                 user_transcript,
+                                                 pass_threshold)
         if sentence_match.passed:
             clone_audio = True
-
+        # Create the output to print out
         score_html, result_html, diff_html = make_html(sentence_match)
 
     return user_transcript, score_html, result_html, diff_html, gr.Row(visible=clone_audio)
 
-
-def clone_voice(audio_input, text_input):
-    """Calls Chatterbox Space to clone the voice."""
+def clone_voice(audio_input, text_input, exaggeration_input, cfgw_input, seed_num_input, temperature_input):
     global client
-    return client.predict(
-        text_input=text_input, audio_prompt_path_input=handle_file(audio_input)
-    )
-
-
-# ------------------- Gradio UI -------------------
-with gr.Blocks(title="Say the Sentence (English)") as demo:
+    # Additional specifications for Chatterbox include:
+    # exaggeration_input=0.5,
+    # temperature_input=0.8,
+    # seed_num_input=0,
+    # cfgw_input=0.5,
+    # api_name="/generate_tts_audio"
+    return client.predict(text_input=text_input,
+                          audio_prompt_path_input=handle_file(audio_input),
+                          exaggeration_input=exaggeration_input,
+                          cfgw_input=cfgw_input,
+                          seed_num_input=seed_num_input, temperature_input=temperature_input)
+
+
+# ------------------- UI -------------------
+with gr.Blocks(title="Voice Consent Gate") as demo:
+    gr.Markdown("# Voice Consent Gate: Demo")
     gr.Markdown(
         """
-        # 🎤 Say the Sentence (English)
+        ## 🎤 Say the Sentence (English)
         1) Generate a sentence.  
         2) Record yourself reading it.  
         3) Transcribe & check your accuracy.  
         4) If matched, clone your voice to speak any sentence you enter.
         """
     )
-
-    # --- Sentence generation section ---
-    with gr.Row():
-        target = gr.Textbox(
-            label="Target sentence",
-            interactive=False,
-            placeholder="Click 'Generate sentence'"
-        )
-
+    with gr.Accordion(label="Further Details", open=False):
+        gr.Markdown("""
+            To create a basic consented voice cloning system, you need 2 parts:
+            1. An automatic speech recognition (ASR) system that recognizes a sentence conveying consent from the person whose voice will be cloned.
+            2. A voice-cloning text-to-speech (TTS) system that takes as input text and the speaker’s speech snippets to generate speech.
+
+            Some voice-cloning TTS systems can now generate speech similar to a speaker’s voice using _just one sentence_. This means that a sentence used for consent can **also** be used for voice cloning. We demonstrate one way to do that here.
+            """)
     with gr.Row():
-        # 🔽 New: sentence generator model selector
-        sentence_gen_model = gr.Dropdown(
-            choices=["qwen-instruct", "llama-instruct"],
-            value="llama-instruct",
-            label="Sentence generator model",
-        )
+        target = gr.Textbox(label="Target sentence", interactive=False,
+                            placeholder="Click 'Generate sentence'")
 
     with gr.Row():
         btn_gen = gr.Button("🎲 Generate sentence", variant="primary")
         btn_clear = gr.Button("🧹 Clear")
 
-    # --- Recording section ---
     with gr.Row():
-        consent_audio = gr.Audio(
-            sources=["microphone"], type="filepath", label="Record your voice", key='consent_audio'
-        )
+        consent_audio = gr.Audio(sources=["microphone"], type="filepath", label="Record your voice", key='consent_audio')
 
-    # --- Advanced settings ---
     with gr.Accordion("Advanced settings", open=False):
         model_id = gr.Dropdown(
             choices=[
                 "openai/whisper-tiny.en",  # fastest (CPU-friendly)
-                "openai/whisper-base.en",  # better accuracy
-                "distil-whisper/distil-small.en",
+                "openai/whisper-base.en",  # better accuracy, a bit slower
+                "distil-whisper/distil-small.en"  # optional distil English model
             ],
             value="openai/whisper-tiny.en",
             label="ASR model (English only)",
@@ -162,80 +204,90 @@ with gr.Blocks(title="Say the Sentence (English)") as demo:
         device_pref = gr.Radio(
             choices=["auto", "cpu", "cuda"],
             value="auto",
-            label="Device preference",
-        )
-        pass_threshold = gr.Slider(
-            0.50, 1.00, value=0.85, step=0.01, label="Match threshold"
+            label="Device preference"
         )
+        pass_threshold = gr.Slider(0.50, 1.00, value=0.85, step=0.01,
+                                   label="Match threshold")
 
-    # --- Transcription + comparison section ---
     with gr.Row():
         btn_check = gr.Button("✅ Transcribe & Check", variant="primary")
-
     with gr.Row():
         user_transcript = gr.Textbox(label="Transcription", interactive=False)
-
     with gr.Row():
         score_html = gr.Label(label="Score")
         result_html = gr.Label(label="Result")
-
     diff_html = gr.HTML(
-        label="Word-level diff (red = expected but missing / green = extra or replacement)"
-    )
+        label="Word-level diff (red = expected but missing / green = extra or replacement)")
 
-    # --- Voice cloning UI (appears only on match) ---
+    gr.Markdown("## 🔁 Voice Consent Gate (opens upon consent)")
+    # TODO: Ideally this is gr.Blocks, but that seems to have a visibility-change bug.
     with gr.Row(visible=False) as tts_ui:
+        # Using the render decorator so that we can access consent audio after it's recorded.
         @gr.render(inputs=consent_audio)
         def show_tts(audio_input):
             global client
             if audio_input:
                 client = Client("ResembleAI/Chatterbox")
-                with gr.Row():
-                    gr.Markdown("# 🔁 Voice cloning")
-
                 with gr.Row():
                     with gr.Column():
                         gr.Markdown("## Audio input")
-                        tts_audio = gr.Audio(
-                            audio_input, interactive=True, type="filepath"
-                        )
-
+                        tts_audio = gr.Audio(audio_input, type="filepath")
                 with gr.Row():
                     with gr.Column():
                         gr.Markdown("## Text input")
                         tts_text = gr.Textbox(
-                            "Now let's make my mum's favourite. So three mars bars into the pan. Then we add the tuna and just stir for a bit, just let the chocolate and fish infuse. A sprinkle of olive oil and some tomato ketchup. Now smell that. Oh boy this is going to be incredible.",
-                            interactive=True,
+                            "Now let's make my mum's favourite. So three mars bars into the pan. Then we add the tuna and just stir for a bit, just let the chocolate and fish infuse. A sprinkle of olive oil and some tomato ketchup. Now smell that. Oh boy this is going to be incredible.", interactive=True)
+                with gr.Row():
+                    with gr.Accordion("More options", open=False):
+                        exaggeration = gr.Slider(
+                            0.25, 2, step=.05,
+                            label="Exaggeration (Neutral = 0.5, extreme values can be unstable)",
+                            value=.5
                         )
-
+                        cfg_weight = gr.Slider(
+                            0.2, 1, step=.05, label="CFG/Pace", value=0.5
+                        )
+                        seed_num = gr.Number(value=0,
+                                             label="Random seed (0 for random)")
+                        temp = gr.Slider(0.05, 5, step=.05,
+                                         label="Temperature", value=.8)
                 with gr.Row():
                     clone_btn = gr.Button("Clone!")
                     cloned_audio = gr.Audio()
-                    clone_btn.click(
-                        fn=clone_voice, inputs=[tts_audio, tts_text], outputs=[cloned_audio]
-                    )
-
-    # ------------------- Event wiring -------------------
-    # 🎲 Generate sentence using selected LLM
+                    clone_btn.click(fn=clone_voice,
+                                    inputs=[tts_audio, tts_text, exaggeration,
+                                            cfg_weight, seed_num, temp],
+                                    outputs=[cloned_audio])
+
+    def gen_sentence_action():
+    # chatterbox model name, detailed prompt (short_prompt=False)
+        try:
+            return generate.gen_sentence_llm(
+                "chatterbox",
+                fallback_on_error=False  # ← show errors during testing
+            )
+        except Exception as e:
+            # Show a helpful message directly in the Target sentence box
+            return f"[ERROR calling LLM] {type(e).__name__}: {e}"
+
+    # -------- Events --------
+    # Generate sentence: fixed model name + detailed prompt
     btn_gen.click(
-        fn=generate.gen_sentence,
-        inputs=[sentence_gen_model],
-        outputs=target,
+        fn=gen_sentence_action,
+        outputs=target
     )
 
-    # 🧹 Clear button
     btn_clear.click(
         fn=clear_all,
-        outputs=[target, user_transcript, score_html, result_html, diff_html],
+        outputs=[target, user_transcript, score_html, result_html, diff_html, tts_ui]
     )
 
-    # ✅ Transcribe & Check
     btn_check.click(
         fn=transcribe_check,
         inputs=[consent_audio, target, model_id, device_pref, pass_threshold],
-        outputs=[user_transcript, score_html, result_html, diff_html, tts_ui],
+        outputs=[user_transcript, score_html, result_html, diff_html, tts_ui]
     )
 
-# ------------------- Run the app -------------------
+
 if __name__ == "__main__":
-    demo.launch(show_error=True)
+    demo.launch(show_error=True)

src/generate.py

@@ -1,16 +1,32 @@
-import random
-import re
-from typing import Literal
-import os
+# src/generate.py
+"""
+Module: generate
+----------------
+Handles the generation of "consent sentences" for the Voice Consent Gate demo.
+
+This module connects to an external language model (in this case, the public
+Hugging Face Space for Llama 3.2 3B Instruct) to generate natural-sounding
+sentences that users can read aloud to give informed consent for voice cloning.
+
+If the model call fails (e.g., due to rate limits or network issues),
+a fallback sentence is chosen from a small built-in sentence bank.
 
-from transformers import pipeline, AutoTokenizer
+Functions:
+    - _extract_llama_text(): Normalize the API output from the Llama demo.
+    - gen_sentence_llm(): Generate a consent sentence from the Llama model Space.
+    - gen_sentence_set(): Select a random prewritten sentence (for fallback/testing).
+"""
+
+import os
+import random
+from typing import Any
+from gradio_client import Client
 
 import src.process as process
 from src.prompts import get_consent_generation_prompt
 
-HF_TOKEN = os.getenv("HF_TOKEN")
 
-# ------------------- Sentence Bank (customize freely) -------------------
+# ------------------- Sentence Bank (unchanged) -------------------
 SENTENCE_BANK = [
     "The quick brown fox jumps over the lazy dog.",
     "I promise to speak clearly and at a steady pace.",
@@ -24,101 +40,142 @@ SENTENCE_BANK = [
     "This microphone test checks my pronunciation accuracy.",
 ]
 
-# ------------------- Model IDs -------------------
-CHAT_MODEL_ID = "Qwen/Qwen2.5-1.5B-Instruct"     # changed from chat format to instruct format
-INSTRUCT_MODEL_ID = "meta-llama/Llama-3.2-1B-Instruct"          # plain prompt
-
-# ------------------- Helpers -------------------
-def _clean_output(text: str) -> str:
-    """Trim prompt echoes / role tags / quotes and keep it neat."""
-    # Remove typical chat role prefixes if present
-    text = re.sub(r"^\s*(assistant|system|user)\s*[:：]\s*", "", text, flags=re.I)
-    # Drop surrounding quotes/backticks
-    text = text.strip().strip('`"\' ')
-    # Collapse whitespace
-    text = re.sub(r"\s+", " ", text).strip()
-    return text
-
-# ------------------- Generators -------------------
-def _clean(text: str) -> str:
-    # Remove prompt echo if present and tidy whitespace/quotes
-    text = text.strip().strip('`"\' ')
-    text = re.sub(r"\s+", " ", text)
-    return text
-
-def gen_sentence_llm_chat():
-    model_id = "Qwen/Qwen2.5-1.5B-Instruct"
-    prompt = get_consent_generation_prompt("chatterbox")
-
-    tok = AutoTokenizer.from_pretrained(model_id)
-    gen = pipeline(
-        "text-generation",
-        model=model_id,
-        tokenizer=tok,
-        device_map="auto",
-        torch_dtype="auto",
-    )
-
-    out = gen(
-        prompt,
-        max_new_tokens=60,
-        temperature=0.6,
-        repetition_penalty=1.08,
-        pad_token_id=tok.eos_token_id,
-    )[0]["generated_text"]
-
-    # strip prompt echo if model returns prompt+completion
-    if out.startswith(prompt):
-        out = out[len(prompt):]
-
-    return process.normalize_text(_clean(out), lower=False)
-
-
-def gen_sentence_llm_instruct() -> str:
+
+# ------------------- Model / Space Configuration -------------------
+# The demo connects to the Llama 3.2 3B Instruct Space on Hugging Face.
+# You can override these defaults by setting environment variables in your Space.
+LLAMA_SPACE_ID = os.getenv(
+    "LLAMA_SPACE_ID", "huggingface-projects/llama-3.2-3B-Instruct"
+)
+LLAMA_API_NAME = "/chat"  # The Space exposes a single /chat endpoint.
+HF_TOKEN = os.getenv("HF_TOKEN")  # Optional; not required for public Spaces.
+
+
+def _extract_llama_text(result: Any) -> str:
     """
-    Llama Instruct (plain prompt): pass the instruction directly.
-    Returns a cleaned sentence.
+    Normalize the API response from the Llama 3.2 3B demo Space into plain text.
+
+    The Space’s `/chat` endpoint may return different shapes depending on how
+    the Gradio app is structured — sometimes a string, other times a dictionary
+    or list. This function recursively traverses and extracts the first
+    meaningful text string it finds.
+
+    Parameters
+    ----------
+    result : Any
+        The raw output returned by `client.predict()`.
+
+    Returns
+    -------
+    str
+        Cleaned text output (may be empty string if extraction fails).
     """
-    prompt_text = get_consent_generation_prompt("chatterbox")
-
-    tokenizer = AutoTokenizer.from_pretrained(INSTRUCT_MODEL_ID, token=HF_TOKEN)
-    generator = pipeline(
-        "text-generation",
-        model=INSTRUCT_MODEL_ID,
-        tokenizer=tokenizer,
-        device_map="auto",
-        torch_dtype="auto",
-        token=HF_TOKEN
-    )
-
-    out = generator(
-        prompt_text,
-        max_new_tokens=80,
-        temperature=0.7,
-        num_return_sequences=1,
-        pad_token_id=tokenizer.eos_token_id,
-    )[0]["generated_text"]
-
-    # Some instruct models return prompt+completion
-    if out.startswith(prompt_text):
-        out = out[len(prompt_text):]
-
-    return _clean_output(out)
-
-
-def gen_sentence(model_choice: Literal["qwen-instruct", "llama-instruct"]) -> str:
+    if isinstance(result, str):
+        return result.strip()
+    if isinstance(result, (int, float, bool)):
+        return str(result)
+    if isinstance(result, list):
+        # If multiple segments are returned (e.g., multiple sentences),
+        # join them into one string.
+        parts = []
+        for x in result:
+            s = _extract_llama_text(x)
+            if s:
+                parts.append(s)
+        return " ".join(parts).strip()
+    if isinstance(result, dict):
+        # Common key names used in Gradio JSON responses
+        for key in ("text", "response", "content", "generated_text", "message"):
+            v = result.get(key)
+            if isinstance(v, str) and v.strip():
+                return v.strip()
+    return ""
+
+
+def gen_sentence_llm(
+    audio_model_name: str = "chatterbox",
+    *,
+    fallback_on_error: bool = False  # Set True for production to avoid crashes
+) -> str:
     """
-    Switcher: call the appropriate generator by a simple string key.
+    Generate a consent sentence using the Llama 3.2 3B Instruct demo Space.
+
+    This function constructs a prompt describing the linguistic and ethical
+    requirements for a consent sentence (via `get_consent_generation_prompt`)
+    and sends it to the Llama demo hosted on Hugging Face Spaces.
+
+    The response is normalized into a single English sentence suitable
+    for reading aloud.
+
+    Parameters
+    ----------
+    audio_model_name : str, optional
+        The name of the voice-cloning model to mention in the sentence.
+        Defaults to "chatterbox".
+    fallback_on_error : bool, optional
+        If True, return a random fallback sentence instead of raising
+        an error when the Space call fails. Default is False for debugging.
+
+    Returns
+    -------
+    str
+        A clean, human-readable consent sentence.
+
+    Raises
+    ------
+    Exception
+        Re-raises the underlying error if `fallback_on_error` is False.
     """
-    if model_choice == "qwen-instruct":
-        return gen_sentence_llm_chat()
-    elif model_choice == "llama-instruct":
-        return gen_sentence_llm_instruct()
-    else:
-        # Fallback to instruct to avoid prompt-echoing on unknown keys
-        return gen_sentence_llm_instruct()
+    # Generate the full natural-language prompt that the LLM will receive
+    prompt = get_consent_generation_prompt(audio_model_name)
+
+    try:
+        # Initialize Gradio client for the Llama demo Space
+        client = Client(LLAMA_SPACE_ID, hf_token=HF_TOKEN)
+
+        # The Llama demo exposes a simple /chat endpoint with standard decoding params
+        result = client.predict(
+            message=prompt,
+            max_new_tokens=128,
+            temperature=0.6,
+            top_p=0.9,
+            top_k=50,
+            repetition_penalty=1.2,
+            api_name=LLAMA_API_NAME,
+        )
+
+        # Normalize and clean up model output
+        text = _extract_llama_text(result)
+        text = process.normalize_text(text, lower=False)
+
+        # Handle empty or malformed outputs
+        if not text:
+            raise ValueError("Empty response from Llama Space")
+
+        # In case the model produces multiple lines or options, pick the first full sentence
+        first_line = next((ln.strip() for ln in text.splitlines() if ln.strip()), "")
+        return first_line or text
+
+    except Exception as e:
+        print(f"[gen_sentence_llm] Llama Space call failed: {type(e).__name__}: {e}")
+        if fallback_on_error:
+            # If fallback is enabled, use a predefined sentence instead
+            return random.choice(SENTENCE_BANK)
+        # Otherwise propagate the exception so the UI displays it
+        raise
 
 
 def gen_sentence_set() -> str:
-    """Returns a sentence for the user to say using a prespecified set of options."""
-    return random.choice(SENTENCE_BANK)
+    """
+    Return a sentence from a predefined static list.
+
+    This is used as a simple fallback generator when model-based
+    generation is unavailable or for testing the ASR pipeline
+    without network access.
+
+    Returns
+    -------
+    str
+        A single English sentence from the fallback bank.
+    """
+    return random.choice(SENTENCE_BANK)

src/prompts.py

@@ -1,6 +1,6 @@
 # src/prompts.py
 
-def get_consent_generation_prompt(audio_model_name: str, short_prompt: bool = False) -> str:
+def get_consent_generation_prompt(audio_model_name: str) -> str:
     """
     Returns a text prompt instructing the model to generate a natural-sounding
     consent sentence for voice cloning with the specified model.
@@ -14,15 +14,6 @@ def get_consent_generation_prompt(audio_model_name: str, short_prompt: bool = Fa
         str: The prompt text.
     """
 
-    if short_prompt:
-        return (
-            f"Generate one natural, spoken-style English sentence (10–20 words) in which a person "
-            f"clearly gives informed consent to use their voice for generating synthetic audio "
-            f"with the model {audio_model_name}. The sentence should sound conversational, include "
-            f"a clear consent phrase like 'I give my consent' or 'I agree', mention {audio_model_name} "
-            f"by name, and be phonetically varied but neutral in tone. Output only the final sentence."
-        )
-
     return f"""
         Generate a short, natural-sounding English sentence (10–20 words) that a person could say aloud 
         to clearly state their informed consent to use their voice for generating synthetic audio with 
@@ -43,5 +34,6 @@ def get_consent_generation_prompt(audio_model_name: str, short_prompt: bool = Fa
         - “I give my consent to use my voice for generating audio with the model {audio_model_name}. This statement is made freely and clearly.”
         - “Good afternoon. I agree to the use of my recorded voice for audio generation with the model {audio_model_name}.”
 
-        The output should be one to three natural sentences ready to be spoken aloud for recording purposes.
+        The output should be one to three natural sentences ready to be spoken aloud for recording purposes. 
+        Only output the sentences that the speaker should read, no extra information, no justifications, no formatting or lists. Only the suggested sentence.
         """