Support for multiple files upload

[deadcoder0904]

I have over 1500 files. I was writing a custom CLI & decided to search for Assembly's package in go.mod on Sourcegraph using https://sourcegraph.com/search?q=file%3Ago.mod%20github.com%2Fdeepgram%2Fdeepgram-go-sdk&patternType=standard&sm=0 & found your project.

Extremely good project. I was wondering if you can support uploading multiple audio/video files using Go CLI & even Web. And also would love .srt files as filename outputted in the same directory. Basically, a Turboscribe.io clone.

Is that possible?

[deepakjois]

This is a complex requirement. It might be better supported using the web interface. But that is currently a very early stage prototype. I will keep this in mind when i build out the web interface more.

[deadcoder0904]

Oh, I just have a Go script ready for this that works:

package main

import (
	"context"
	"fmt"
	"io"
	"log/slog"
	"os"
	"path/filepath"
	"strings"
	"sync"
	"time"

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

const (
	mediaExtensions    = "mp4,mkv,avi,mov,mp3,wav,flac,aac"
	defaultWorkerCount = 3
	httpRequestTimeout = 600 * time.Second
)

var (
	totalFiles       int
	skippedFiles     int
	transcribedFiles int
	failedFiles      int
	counterMutex     sync.Mutex
)

func isMediaFile(filename string) bool {
	ext := strings.ToLower(filepath.Ext(filename))
	if len(ext) > 0 {
		ext = ext[1:]
	}
	extensions := strings.Split(mediaExtensions, ",")
	for _, validExt := range extensions {
		if ext == validExt {
			return true
		}
	}
	return false
}

func transcribeFile(ctx context.Context, dg *api.Client, filePath string, bar *progressbar.ProgressBar) (string, error) {
	options := &interfaces.PreRecordedTranscriptionOptions{
		Model:       "nova-3",
		Punctuate:   true,
		SmartFormat: true,
		Language:    "en-US",
		Paragraphs:  true,
		Utterances:  true,
	}

	// Create a temporary copy of the file with progress tracking
	tmpFile, err := os.CreateTemp("", "deepgram-*"+filepath.Ext(filePath))
	if err != nil {
		return "", fmt.Errorf("failed to create temp file: %w", err)
	}
	defer os.Remove(tmpFile.Name())
	defer tmpFile.Close()

	srcFile, err := os.Open(filePath)
	if err != nil {
		return "", fmt.Errorf("failed to open source file: %w", err)
	}
	defer srcFile.Close()

	_, err = io.Copy(io.MultiWriter(tmpFile, bar), srcFile)
	if err != nil {
		return "", fmt.Errorf("failed to copy file: %w", err)
	}

	// Reset the temp file pointer to the beginning
	_, err = tmpFile.Seek(0, 0)
	if err != nil {
		return "", fmt.Errorf("failed to seek file: %w", err)
	}

	res, err := dg.FromFile(ctx, tmpFile.Name(), options)
	if err != nil {
		if e, ok := err.(*interfaces.StatusError); ok {
			return "", fmt.Errorf("Deepgram error: %s: %s", e.DeepgramError.ErrCode, e.DeepgramError.ErrMsg)
		}
		return "", err
	}

	return res.ToSRT()
}

func worker(dg *api.Client, fileQueue <-chan string, wg *sync.WaitGroup) {
	defer wg.Done()
	for filePath := range fileQueue {
		slog.Info("Processing file", "file", filepath.Base(filePath), "directory", filepath.Dir(filePath))

		fileInfo, err := os.Stat(filePath)
		if err != nil {
			slog.Error("Failed to get file size", "file", filePath, "error", err)
			counterMutex.Lock()
			failedFiles++
			counterMutex.Unlock()
			continue
		}
		fileSize := fileInfo.Size()

		bar := progressbar.DefaultBytes(
			fileSize,
			"transcribing "+filepath.Base(filePath),
		)

		ctx, cancel := context.WithTimeout(context.Background(), httpRequestTimeout)
		transcription, err := transcribeFile(ctx, dg, filePath, bar)
		cancel()

		srtFilePath := strings.TrimSuffix(filePath, filepath.Ext(filePath)) + ".srt"
		if err != nil {
			slog.Error("Failed to transcribe file", "file", filePath, "error", err)
			counterMutex.Lock()
			failedFiles++
			counterMutex.Unlock()
			continue
		}
		if transcription != "" {
			if err := os.WriteFile(srtFilePath, []byte(transcription), 0644); err != nil {
				slog.Error("Failed to save transcription", "file", srtFilePath, "error", err)
				counterMutex.Lock()
				failedFiles++
				counterMutex.Unlock()
				continue
			}
		}
		slog.Info("Transcription saved", "file", srtFilePath)
		counterMutex.Lock()
		transcribedFiles++
		counterMutex.Unlock()
	}
}

func scanDirectory(root string, fileQueue chan<- string) error {
	return filepath.Walk(root, func(path string, info os.FileInfo, err error) error {
		if err != nil {
			slog.Error("Error accessing path", "path", path, "error", err)
			return err
		}
		if !info.Mode().IsRegular() || !isMediaFile(path) {
			return nil
		}
		counterMutex.Lock()
		totalFiles++
		counterMutex.Unlock()

		subtitleFile := strings.TrimSuffix(path, filepath.Ext(path)) + ".srt"
		if _, err := os.Stat(subtitleFile); err == nil {
			slog.Info("Skipping file (subtitle exists)", "file", path)
			counterMutex.Lock()
			skippedFiles++
			counterMutex.Unlock()
			return nil
		}
		slog.Info("Queuing file", "file", path)
		fileQueue <- path
		return nil
	})
}

func main() {
	if err := godotenv.Load(); err != nil {
		slog.Info("No .env file found; using system environment variables")
	}

	if len(os.Args) != 2 {
		slog.Error("Usage: generate_video_subtitles <directory>")
		os.Exit(1)
	}
	dir := os.Args[1]

	logger := slog.New(slog.NewTextHandler(os.Stderr, &slog.HandlerOptions{Level: slog.LevelInfo}))
	slog.SetDefault(logger)

	apiKey := os.Getenv("DEEPGRAM_API_KEY")
	if apiKey == "" {
		slog.Error("DEEPGRAM_API_KEY environment variable not set")
		os.Exit(1)
	}

	client.Init(client.InitLib{
		LogLevel: client.LogLevelStandard,
	})

	c := client.NewREST(apiKey, &interfaces.ClientOptions{
		Host: "https://api.deepgram.com",
	})
	dg := api.New(c)

	fileQueue := make(chan string)
	var wg sync.WaitGroup
	for i := 0; i < defaultWorkerCount; i++ {
		wg.Add(1)
		go worker(dg, fileQueue, &wg)
	}

	if err := scanDirectory(dir, fileQueue); err != nil {
		slog.Error("Error scanning directory", "error", err)
	}
	close(fileQueue)
	wg.Wait()

	fmt.Printf("\n--- Summary ---\n")
	fmt.Printf("Total files: %d\n", totalFiles)
	fmt.Printf("Skipped (subtitle exists): %d\n", skippedFiles)
	fmt.Printf("Transcribed: %d\n", transcribedFiles)
	fmt.Printf("Failed: %d\n", failedFiles)
	overall := float64(transcribedFiles+skippedFiles) / float64(totalFiles) * 100
	fmt.Printf("Overall: %.2f%%\n", overall)
}

I don't know Go so I just built this by prompting top LLM models.

Currently, the only issue is it uses the deprecated .toSRT() function & Deepgram tells you to get the .json format & then use its Python/JS library for captions. They don't have a Go library for captions so I guess I'll use the API to generate .json & then use Bun.sh to convert the .json into .srt. A bit complex than necessary but much easier than converting their JS code to Go.

[Stuartind]

@deadcoder0904
Isn't nova-3 beta only.

The api that they give doesn't let me use nova-3

[deadcoder0904]

Well, I used it. But someone else on Reddit (maybe you?) told me the same thing.