update voice to transcription

.gitignore

@@ -1,2 +1,3 @@
 /sb-voiceBot
 .env
+*.pyc

.vscode/launch.json

@@ -0,0 +1,16 @@
+{
+    // Use IntelliSense to learn about possible attributes.
+    // Hover to view descriptions of existing attributes.
+    // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
+    "version": "0.2.0",
+    "configurations": [
+    
+        {
+            "name": "Python Debugger: Current File",
+            "type": "debugpy",
+            "request": "launch",
+            "program": "${file}",
+            "console": "integratedTerminal"
+        }
+    ]
+}

README.md

@@ -11,3 +11,7 @@ short_description: NVIDIA RIVA based voiceBot
 ---
 
 Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+
+References used: 
+- https://www.gradio.app/guides/conversational-chatbot
+- Riva datamodel reference: https://docs.nvidia.com/deeplearning/riva/user-guide/docs/reference/protos/protos.html#

app-1.py

@@ -0,0 +1,8 @@
+import gradio as gr
+from test1 import foo
+
+def greet(name):
+    return "Hello " + name + "!!" + foo()
+
+demo = gr.Interface(fn=greet, inputs="text", outputs="text")
+demo.launch()

app.py

@@ -1,8 +1,59 @@
 import gradio as gr
-from test1 import foo
 
-def greet(name):
-    return "Hello " + name + "!!" + foo()
+import numpy as np
 
-demo = gr.Interface(fn=greet, inputs="text", outputs="text")
-demo.launch()
+import io
+import soundfile as sf
+import numpy as np
+from test1 import asr_transcribe
+
+
+def audio_to_bytes(audio_input) -> bytes:
+    """
+    Convert a Gradio audio input (numpy array or filepath) to WAV bytes.
+    
+    Parameters:
+        audio_input: tuple | str
+            - If tuple: (numpy_array, sample_rate)
+            - If str: path to an audio file
+
+    Returns:
+        bytes: The WAV file bytes.
+    """
+    if isinstance(audio_input, str):
+        # audio_input is a file path
+        samplerate, data = sf.read(audio_input)
+    elif isinstance(audio_input, (tuple, list)) and len(audio_input) == 2:
+        # audio_input is (numpy array, sample_rate)
+        samplerate, data = audio_input
+    else:
+        raise ValueError("Invalid audio input. Expected (numpy_array, sample_rate) or file path string.")
+
+    
+    # Ensure mono (channel count = 1)
+    if data.ndim > 1:
+        data = np.mean(data, axis=1)  # average channels to mono
+
+    # Write to an in-memory buffer
+    wav_buffer = io.BytesIO()
+    sf.write(wav_buffer, data, samplerate, format='WAV')
+    wav_bytes = wav_buffer.getvalue()
+    wav_buffer.close()
+    
+    return wav_bytes
+
+
+def transcribe(audio):
+    # convert the audio to bytes 
+    audio_bytes = audio_to_bytes(audio)
+    transcription = asr_transcribe(audio_bytes)
+    # transcribe
+    return transcription
+
+demo = gr.Interface(
+    transcribe,
+    gr.Audio(sources="microphone"),
+    "text",
+)
+
+demo.launch()

app3.py

@@ -0,0 +1,86 @@
+import os
+import io
+import numpy as np
+import gradio as gr
+import riva.client
+import riva.client as riva_client
+from dotenv import load_dotenv
+load_dotenv()
+
+# -------------------------------
+# Auth (your provided snippet)
+# -------------------------------
+uri = "grpc.nvcf.nvidia.com:443"
+
+auth = riva_client.Auth(
+    uri=uri,
+    use_ssl=True,
+    metadata_args=[
+        ["function-id", "b702f636-f60c-4a3d-a6f4-f3568c13bd7d"],
+        ["authorization", f"Bearer {os.environ['NVIDIA_API']}"],
+    ],
+)
+
+# Create Riva SpeechClient
+asr = riva_client.ASRService(auth)
+
+# -------------------------------
+# Helper: convert Gradio audio chunk to PCM16
+# -------------------------------
+def float_to_pcm16(audio_np: np.ndarray) -> bytes:
+    audio_np = np.clip(audio_np, -1.0, 1.0)
+    return (audio_np * 32767).astype(np.int16).tobytes()
+
+# -------------------------------
+# Streaming generator
+# ---------- Generator ----------
+def riva_stream_generator(audio_chunks, sample_rate=16000):
+    """
+    This uses the modern Riva API:
+      streaming_response_generator(audio_chunks, streaming_config)
+    """
+    offline_config = riva.client.RecognitionConfig(
+        language_code="en-US",
+        # model=args.model_name,
+        sample_rate_hertz=sample_rate,
+        max_alternatives=1,
+        # profanity_filter=args.profanity_filter,
+        enable_automatic_punctuation=True,
+        verbatim_transcripts=False,
+        # enable_word_time_offsets=args.word_time_offsets or args.speaker_diarization,
+    )
+    # Build RecognitionConfig and StreamingRecognitionConfig
+    streaming_config = riva.client.StreamingRecognitionConfig(config=offline_config, interim_results=True)
+
+    # Call the streaming generator directly with your audio iterator
+    # Gradio will yield numpy chunks via audio_chunks
+    def chunk_iterator():
+        for chunk in audio_chunks:
+            if chunk is None:
+                break
+            yield float_to_pcm16(chunk)
+
+    # Now call Riva streaming_response_generator
+    responses = asr.streaming_response_generator(chunk_iterator(), streaming_config)
+
+    # Parse responses and yield text updates to Gradio
+    for resp in responses:
+        for result in resp.results:
+            if result.alternatives:
+                transcript = result.alternatives[0].transcript
+                yield transcript
+
+# -------------------------------
+# Gradio UI
+# -------------------------------
+with gr.Blocks() as demo:
+    gr.Markdown("# 🎙️ NVIDIA Riva Realtime ASR — True Streaming Demo")
+
+    # This streams mic audio directly to backend in small chunks
+    mic = gr.Audio(sources=["microphone"], streaming=True)
+    transcript = gr.Textbox(label="Live Transcript", interactive=False, lines=6)
+
+    # Wire streaming callback
+    mic.stream(riva_stream_generator, inputs=mic, outputs=transcript)
+
+demo.launch()

requirements.txt

@@ -1,3 +1,4 @@
 gradio
 nvidia-riva-client
-python-dotenv
+python-dotenv
+soundfile

test1.py

@@ -1,4 +1,5 @@
 import riva.client
+import riva.client.realtime
 from riva.client.argparse_utils import add_asr_config_argparse_parameters, add_connection_argparse_parameters
 import os
 from dotenv import load_dotenv
@@ -42,6 +43,13 @@ with open("./en-US_sample.wav", 'rb') as fh:
     data = fh.read()
 
 
+def asr_transcribe(audio: bytes): 
+    global offline_config, asr_service 
+    response = asr_service.offline_recognize(audio, offline_config) 
+    transcript = " ".join([result.alternatives[0].transcript for result in response.results])
+    # print("Final transcript:", transcript)
+    return transcript  
+
 def foo():
     global data, offline_config, asr_service
     response = asr_service.offline_recognize(data, offline_config)

test2.py

@@ -0,0 +1,33 @@
+import riva.client
+from riva.client.argparse_utils import add_asr_config_argparse_parameters, add_connection_argparse_parameters
+import os
+from dotenv import load_dotenv
+
+
+# Load environment variables from .env file
+load_dotenv()
+
+uri = "grpc.nvcf.nvidia.com:443"
+
+auth = riva.client.Auth(
+    uri=uri,
+    use_ssl=True,
+    metadata_args=[
+        ["function-id", "b702f636-f60c-4a3d-a6f4-f3568c13bd7d"],
+        ["authorization", f"Bearer {os.environ['NVIDIA_API']}"],
+    ]
+)
+
+# assuming you already created `auth`
+asr = riva.client.ASRService(auth)
+
+# list all available ASR models
+models = asr.list_models()
+
+for m in models:
+    print("Model name:", m.name)
+    print("  Description:", m.description)
+    print("  Type:", m.type)  # 'online' or 'offline'
+    print("  Sample rates:", m.supported_sample_rates)
+    print("  Languages:", m.languages)
+    print()