Migrating from Deepgram to Speech Revolutions

from deepgram import DeepgramClient, PrerecordedOptions

dg = DeepgramClient()  # DEEPGRAM_API_KEY

with open("meeting.mp3", "rb") as f:
    source = {"buffer": f.read(), "mimetype": "audio/mp3"}

options = PrerecordedOptions(model="nova-3", diarize=True, smart_format=True)
resp = dg.listen.rest.v("1").transcribe_file(source, options)

alt = resp["results"]["channels"][0]["alternatives"][0]
print(alt["transcript"])
for w in alt["words"]:
    print(w["speaker"], w["word"], w["start"], w["end"])

from speechrevolutions import SpeechRevolutions

client = SpeechRevolutions()  # SPEECHREVOLUTIONS_API_KEY
result = client.transcribe("meeting.mp3", diarize=True)  # same flag name

print(result.text)
for w in result.words:
    print(w.speaker, w.text, w.start, w.end)

# grouped speaker turns, no reconstruction needed
for u in result.utterances:
    print(f"{u.speaker}: {u.text}")

# keep your Deepgram parser working:
dg = result.to_deepgram()
print(dg["results"]["channels"][0]["alternatives"][0]["transcript"])

import { createClient } from "@deepgram/sdk";
import { readFileSync } from "node:fs";

const deepgram = createClient(process.env.DEEPGRAM_API_KEY);

const { result, error } = await deepgram.listen.prerecorded.transcribeFile(
  readFileSync("meeting.mp3"),
  { model: "nova-3", diarize: true, smart_format: true },
);
if (error) throw error;

const alt = result.results.channels[0].alternatives[0];
console.log(alt.transcript);
for (const w of alt.words) {
  console.log(w.speaker, w.word, w.start, w.end);
}

import { SpeechRevolutions } from "speechrevolutions";

const client = new SpeechRevolutions(); // SPEECHREVOLUTIONS_API_KEY
const result = await client.transcribe("meeting.mp3", { diarize: true }); // same flag name

console.log(result.text);
for (const w of result.words) {
  console.log(w.speaker, w.text, w.start, w.end);
}

// grouped speaker turns, no reconstruction needed
for (const u of result.utterances) {
  console.log(`${u.speaker}: ${u.text}`);
}

// keep your Deepgram parser working:
const dg = result.toDeepgram();
console.log(dg.results.channels[0].alternatives[0].transcript);

package main

import (
	"context"
	"fmt"
	"log"

	api "github.com/deepgram/deepgram-go-sdk/v3/pkg/api/listen/v1/rest"
	interfaces "github.com/deepgram/deepgram-go-sdk/v3/pkg/client/interfaces"
	client "github.com/deepgram/deepgram-go-sdk/v3/pkg/client/listen"
)

func main() {
	ctx := context.Background()
	client.InitWithDefault()

	dg := api.New(client.NewRESTWithDefaults()) // DEEPGRAM_API_KEY
	options := &interfaces.PreRecordedTranscriptionOptions{
		Model:       "nova-3",
		Diarize:     true,
		SmartFormat: true,
	}

	resp, err := dg.FromFile(ctx, "meeting.mp3", options)
	if err != nil {
		log.Fatal(err)
	}

	alt := resp.Results.Channels[0].Alternatives[0]
	fmt.Println(alt.Transcript)
	for _, w := range alt.Words {
		fmt.Println(*w.Speaker, w.Word, w.Start, w.End)
	}
}

package main

import (
	"context"
	"encoding/json"
	"fmt"
	"log"

	stt "github.com/speechrevolutions/speechrevolutions-go"
)

func main() {
	ctx := context.Background()
	client, err := stt.NewClient("") // SPEECHREVOLUTIONS_API_KEY
	if err != nil {
		log.Fatal(err)
	}

	result, err := client.Transcribe(ctx, "meeting.mp3", stt.TranscribeOptions{
		Diarize: stt.Bool(true), // same flag name
	}, nil)
	if err != nil {
		log.Fatal(err)
	}

	fmt.Println(result.Text())
	for _, w := range result.Words {
		if w.Start != nil && w.End != nil {
			fmt.Println(w.Speaker, w.Word, *w.Start, *w.End)
		}
	}

	// grouped speaker turns, no reconstruction needed
	for _, u := range result.Utterances {
		fmt.Printf("%s: %s\n", u.Speaker, u.Text)
	}

	// keep your Deepgram parser working: unmarshal this into the struct it reads
	dg, err := json.Marshal(result.ToDeepgram())
	if err != nil {
		log.Fatal(err)
	}
	fmt.Println(string(dg))
}

using Deepgram;
using Deepgram.Models.Listen.v1.REST;

Library.Initialize();
var dg = ClientFactory.CreateListenRESTClient(); // DEEPGRAM_API_KEY

var response = await dg.TranscribeFile(
    await File.ReadAllBytesAsync("meeting.mp3"),
    new PreRecordedSchema { Model = "nova-3", Diarize = true, SmartFormat = true });

var alt = response.Results!.Channels![0].Alternatives![0];
Console.WriteLine(alt.Transcript);
foreach (var w in alt.Words!)
    Console.WriteLine($"{w.Speaker} {w.HeardWord} {w.Start} {w.End}");
Library.Terminate();

using System.Text.Json;
using SpeechRevolutions;

using var client = new SpeechRevolutionsClient(); // SPEECHREVOLUTIONS_API_KEY
var result = await client.TranscribeAsync(
    "meeting.mp3",
    new TranscribeOptions { Diarize = true }); // same flag name

Console.WriteLine(result.Text);
foreach (var w in result.Words)
    Console.WriteLine($"{w.Speaker} {w.Text} {w.Start} {w.End}");

// grouped speaker turns, no reconstruction needed
foreach (var u in result.Utterances)
    Console.WriteLine($"{u.Speaker}: {u.Text}");

// keep your Deepgram parser working: feed it this JSON
Console.WriteLine(JsonSerializer.Serialize(result.ToDeepgram()));