1
pip install requests pandas pydub

1
import requests
2
import pandas as pd
3
from pydub import AudioSegment
4
import io

1
SARVAM_AI_API="YOUR_SARVAM_AI_API_KEY"

1
# API endpoint for speech-to-text
2
api_url = "https://api.sarvam.ai/speech-to-text"
3
4
# Headers containing the API subscription key
5
headers = {
6
    "api-subscription-key": SARVAM_AI_API  # Replace with your API key
7
}
8
9
# Data payload for the transcription request
10
data = {
11
    "language_code": "hi-IN",  # Specify the language of the audio (e.g., 'hi-IN' for Hindi)
12
    "model": "saarika:v2",     # Specify the model to be used for transcription
13
    "with_timestamps": False   # Set to True if you want word-level timestamps
14
}

1
from google.colab import files
2
3
uploaded = files.upload()
4
audio_file_path = list(uploaded.keys())[0]  # Get the name of the uploaded file

1
def split_audio(audio_path, chunk_duration_ms):
2
    """
3
    Splits an audio file into smaller chunks of specified duration.
4
5
    Args:
6
        audio_path (str): Path to the audio file to be split.
7
        chunk_duration_ms (int): Duration of each chunk in milliseconds.
8
9
    Returns:
10
        list: A list of AudioSegment objects representing the audio chunks.
11
    """
12
    audio = AudioSegment.from_file(audio_path)  # Load the audio file
13
    chunks = []
14
    if len(audio) > chunk_duration_ms:
15
        # Split the audio into chunks of the specified duration
16
        for i in range(0, len(audio), chunk_duration_ms):
17
            chunks.append(audio[i:i + chunk_duration_ms])
18
    else:
19
        # If the audio is shorter than the chunk duration, use the entire audio
20
        chunks.append(audio)
21
    return chunks

1
def transcribe_audio_chunks(audio_file_path, api_url, headers, data, chunk_duration_ms=5*60*1000):
2
    """
3
    Transcribes audio chunks using the Speech-to-Text API.
4
5
    Args:
6
        audio_file_path (str): Path to the audio file.
7
        api_url (str): The API endpoint URL for Speech-to-Text.
8
        headers (dict): Headers containing authentication information.
9
        data (dict): Data payload for the transcription API.
10
        chunk_duration_ms (int): Duration of each audio chunk in milliseconds.
11
12
    Returns:
13
        dict: Collated response containing the transcript.
14
    """
15
    # Split the audio into chunks
16
    chunks = split_audio(audio_file_path, chunk_duration_ms)
17
    responses = []  # List to store the transcription results
18
19
    # Process each chunk
20
    for idx, chunk in enumerate(chunks):
21
        # Export the chunk to a BytesIO object (in-memory binary stream)
22
        chunk_buffer = io.BytesIO()
23
        chunk.export(chunk_buffer, format="wav")
24
        chunk_buffer.seek(0)  # Reset the pointer to the start of the stream
25
26
        # Prepare the file for the API request
27
        files = {'file': ('audiofile.wav', chunk_buffer, 'audio/wav')}
28
29
        try:
30
            # Make the POST request to the API
31
            response = requests.post(api_url, headers=headers, files=files, data=data)
32
            if response.status_code == 200 or response.status_code == 201:
33
                print(f"Chunk {idx} POST Request Successful!")
34
                response_data = response.json()
35
                transcript = response_data.get("transcript", "")
36
                responses.append({"transcript": transcript})
37
            else:
38
                # Handle failed requests
39
                print(f"Chunk {idx} POST Request failed with status code: {response.status_code}")
40
                print("Response:", response.text)
41
        except Exception as e:
42
            # Handle any exceptions during the request
43
            print(f"Error processing chunk {idx}: {e}")
44
        finally:
45
            # Ensure the buffer is closed after processing
46
            chunk_buffer.close()
47
48
    # Collate the transcriptions from all chunks
49
    collated_responses = {"collated_transcript": " ".join([i["transcript"] for i in responses])}
50
    return collated_responses

1
# Path to the audio file to be transcribed
2
# audio_file_path = "test.wav"  # Replace with your file path
3
4
# Transcribe the audio
5
transcriptions = transcribe_audio_chunks(audio_file_path, api_url, headers, data)
6
7
# Display the transcription results
8
transcriptions