Added transcribe and delete commands

Author: djthorpe

Makefile

@@ -16,11 +16,11 @@ BUILD_DIR := build
 
 # Build flags
 BUILD_MODULE := $(shell cat go.mod | head -1 | cut -d ' ' -f 2)
-BUILD_LD_FLAGS += -X $(BUILD_MODULE)/pkg/whisper/version.GitSource=${BUILD_MODULE}
-BUILD_LD_FLAGS += -X $(BUILD_MODULE)/pkg/whisper/version.GitTag=$(shell git describe --tags --always)
-BUILD_LD_FLAGS += -X $(BUILD_MODULE)/pkg/whisper/version.GitBranch=$(shell git name-rev HEAD --name-only --always)
-BUILD_LD_FLAGS += -X $(BUILD_MODULE)/pkg/whisper/version.GitHash=$(shell git rev-parse HEAD)
-BUILD_LD_FLAGS += -X $(BUILD_MODULE)/pkg/whisper/version.GoBuildTime=$(shell date -u '+%Y-%m-%dT%H:%M:%SZ')
+BUILD_LD_FLAGS += -X $(BUILD_MODULE)/pkg/version.GitSource=${BUILD_MODULE}
+BUILD_LD_FLAGS += -X $(BUILD_MODULE)/pkg/version.GitTag=$(shell git describe --tags --always)
+BUILD_LD_FLAGS += -X $(BUILD_MODULE)/pkg/version.GitBranch=$(shell git name-rev HEAD --name-only --always)
+BUILD_LD_FLAGS += -X $(BUILD_MODULE)/pkg/version.GitHash=$(shell git rev-parse HEAD)
+BUILD_LD_FLAGS += -X $(BUILD_MODULE)/pkg/version.GoBuildTime=$(shell date -u '+%Y-%m-%dT%H:%M:%SZ')
 BUILD_FLAGS = -ldflags "-s -w $(BUILD_LD_FLAGS)" 
 
 # If GGML_CUDA is set, then add a cuda tag for the go ${BUILD FLAGS}

README.md

@@ -2,7 +2,7 @@
 
 Speech-to-Text in golang. This is an early development version.
 
-* `cmd` contains an OpenAI-API compatible server
+* `cmd` contains an OpenAI-API compatible service
 * `pkg` contains the `whisper` service and client
 * `sys` contains the `whisper` bindings to the `whisper.cpp` library
 * `third_party` is a submodule for the whisper.cpp source
@@ -11,6 +11,7 @@ Speech-to-Text in golang. This is an early development version.
 
 (Note: Docker images are not created yet - this is some forward planning!)
 
+You can either run the whisper service as a CLI command or in a docker container.
 There are docker images for arm64 and amd64 (Intel). The arm64 image is built for
 Jetson GPU support specifically, but it will also run on Raspberry Pi's.
 
@@ -19,14 +20,15 @@ In order to utilize a NVIDIA GPU, you'll need to install the
 
 A docker volume should be created called "whisper" can be used for storing the Whisper language
 models. You can see which models are available to download locally [here](https://huggingface.co/ggerganov/whisper.cpp).
-The following command will run the server on port 8080:
+
+The following command will run the server on port 8080 for an NVIDIA GPU:
 
 ```bash
 docker run \
   --name whisper-server --rm \
   --runtime nvidia --gpus all \ # When using a NVIDIA GPU
   -v whisper:/models -p 8080:8080 -e WHISPER_DATA=/models \
-  ghcr.io/mutablelogic/go-whisper:latest
+  ghcr.io/mutablelogic/go-whisper
 ```
 
 If you include a `-debug` flag at the end, you'll get more verbose output. The API is then
@@ -92,6 +94,11 @@ The following `Makefile` targets can be used:
 
 See all the other targets in the `Makefile` for more information.
 
+## Developing
+
+The `cmd/examples` directory contains a simple example of how to use the `whisper` package
+in your own code.
+
 ## Status
 
 Still in development. See this [issue](https://github.com/mutablelogic/go-whisper/issues/1) for

cmd/server/main.go

@@ -14,8 +14,8 @@ import (
 	context "github.com/mutablelogic/go-server/pkg/context"
 	httpserver "github.com/mutablelogic/go-server/pkg/httpserver"
 	whisper "github.com/mutablelogic/go-whisper"
+	version "github.com/mutablelogic/go-whisper/pkg/version"
 	api "github.com/mutablelogic/go-whisper/pkg/whisper/api"
-	version "github.com/mutablelogic/go-whisper/pkg/whisper/version"
 )
 
 func main() {

cmd/whisper/delete.go

@@ -0,0 +1,14 @@
+package main
+
+// Packages
+
+type DeleteCmd struct {
+	Model string `arg:"" help:"Model id to delete"`
+}
+
+func (cmd *DeleteCmd) Run(ctx *Globals) error {
+	if err := ctx.service.DeleteModelById(cmd.Model); err != nil {
+		return err
+	}
+	return ModelsCmd{}.Run(ctx)
+}

cmd/whisper/download.go

@@ -2,6 +2,7 @@ package main
 
 import (
 	"log"
+	"time"
 
 	// Packages
 	"github.com/djthorpe/go-tablewriter"
@@ -12,8 +13,13 @@ type DownloadCmd struct {
 }
 
 func (cmd *DownloadCmd) Run(ctx *Globals) error {
+	t := time.Now()
 	model, err := ctx.service.DownloadModel(ctx.ctx, cmd.Model, func(curBytes, totalBytes uint64) {
-		log.Printf("Downloaded %d of %d bytes", curBytes, totalBytes)
+		if time.Since(t) > time.Second {
+			pct := float64(curBytes) / float64(totalBytes) * 100
+			log.Printf("Downloaded %.0f%%", pct)
+			t = time.Now()
+		}
 	})
 	if err != nil {
 		return err

cmd/whisper/main.go

@@ -2,6 +2,7 @@ package main
 
 import (
 	"context"
+	"log"
 	"os"
 	"path/filepath"
 	"syscall"
@@ -26,9 +27,12 @@ type Globals struct {
 
 type CLI struct {
 	Globals
-	Models   ModelsCmd   `cmd:"models" help:"List models"`
-	Download DownloadCmd `cmd:"download" help:"Download a model"`
-	Server   ServerCmd   `cmd:"server" help:"Run the whisper server"`
+	Transcribe TranscribeCmd `cmd:"transcribe" help:"Transcribe from file"`
+	Models     ModelsCmd     `cmd:"models" help:"List models"`
+	Download   DownloadCmd   `cmd:"download" help:"Download a model"`
+	Delete     DeleteCmd     `cmd:"delete" help:"Delete a model"`
+	Server     ServerCmd     `cmd:"server" help:"Run the whisper service"`
+	Version    VersionCmd    `cmd:"version" help:"Print version information"`
 }
 
 func main() {
@@ -53,7 +57,11 @@ func main() {
 	)
 
 	// Create a whisper server - set options
-	opts := []whisper.Opt{}
+	opts := []whisper.Opt{
+		whisper.OptLog(func(line string) {
+			log.Println(line)
+		}),
+	}
 	if cli.Globals.Debug {
 		opts = append(opts, whisper.OptDebug())
 	}

cmd/whisper/models.go

@@ -1,12 +1,19 @@
 package main
 
 import (
+	"errors"
+
 	// Packages
 	"github.com/djthorpe/go-tablewriter"
 )
 
 type ModelsCmd struct{}
 
-func (*ModelsCmd) Run(ctx *Globals) error {
-	return ctx.writer.Write(ctx.service.ListModels(), tablewriter.OptHeader())
+func (ModelsCmd) Run(ctx *Globals) error {
+	models := ctx.service.ListModels()
+	if len(models) == 0 {
+		return errors.New("no models found")
+	} else {
+		return ctx.writer.Write(ctx.service.ListModels(), tablewriter.OptHeader())
+	}
 }

cmd/whisper/server.go

@@ -2,7 +2,6 @@ package main
 
 import (
 	"log"
-	"net/http"
 
 	// Packages
 	"github.com/mutablelogic/go-server/pkg/httpserver"
@@ -15,17 +14,11 @@ type ServerCmd struct {
 }
 
 func (cmd *ServerCmd) Run(ctx *Globals) error {
-	// Create a mux for serving requests, then register the endpoints with the mux
-	mux := http.NewServeMux()
-
-	// Register the endpoints
-	api.RegisterEndpoints(cmd.Endpoint, mux, ctx.service)
-
 	// Create a new HTTP server
-	log.Println("List address", cmd.Listen)
+	log.Println("Listen address", cmd.Listen)
 	server, err := httpserver.Config{
 		Listen: cmd.Listen,
-		Router: mux,
+		Router: api.RegisterEndpoints(cmd.Endpoint, ctx.service, nil),
 	}.New()
 	if err != nil {
 		return err

cmd/whisper/transcribe.go

@@ -0,0 +1,71 @@
+package main
+
+import (
+	"os"
+	"time"
+
+	// Packages
+
+	whisper "github.com/mutablelogic/go-whisper"
+	"github.com/mutablelogic/go-whisper/pkg/whisper/schema"
+	segmenter "github.com/mutablelogic/go-whisper/pkg/whisper/segmenter"
+	task "github.com/mutablelogic/go-whisper/pkg/whisper/task"
+
+	// Namespace imports
+	. "github.com/djthorpe/go-errors"
+)
+
+type TranscribeCmd struct {
+	Model    string `arg:"" help:"Model to use"`
+	Path     string `arg:"" help:"Path to audio file"`
+	Language string `flag:"language" help:"Language to transcribe"`
+	Format   string `flag:"format" help:"Output format" default:"text" enum:"text,srt,vtt,json"`
+}
+
+func (cmd *TranscribeCmd) Run(ctx *Globals) error {
+	// Get the model
+	model := ctx.service.GetModelById(cmd.Model)
+	if model == nil {
+		return ErrNotFound.With(cmd.Model)
+	}
+
+	// Open the audio file
+	f, err := os.Open(cmd.Path)
+	if err != nil {
+		return err
+	}
+	defer f.Close()
+
+	// Create a segmenter - read segments based on requested segment size
+	segmenter, err := segmenter.New(f, 0, whisper.SampleRate)
+	if err != nil {
+		return err
+	}
+	defer segmenter.Close()
+
+	// Perform the transcription
+	return ctx.service.WithModel(model, func(taskctx *task.Context) error {
+		// Transcribe
+		taskctx.SetTranslate(false)
+		taskctx.SetDiarize(false)
+
+		// Set language
+		if cmd.Language != "" {
+			if err := taskctx.SetLanguage(cmd.Language); err != nil {
+				return err
+			}
+		}
+
+		// Read samples and transcribe them
+		if err := segmenter.Decode(ctx.ctx, func(ts time.Duration, buf []float32) error {
+			// Perform the transcription, return any errors
+			return taskctx.Transcribe(ctx.ctx, ts, buf, func(segment *schema.Segment) {
+				ctx.writer.Write(segment)
+			})
+		}); err != nil {
+			return err
+		}
+
+		return nil
+	})
+}

cmd/whisper/version.go

@@ -0,0 +1,37 @@
+package main
+
+import (
+	"runtime"
+
+	// Packages
+	"github.com/mutablelogic/go-whisper/pkg/version"
+)
+
+type VersionCmd struct{}
+
+func (cmd *VersionCmd) Run(ctx *Globals) error {
+	type kv struct {
+		Key   string `json:"name"`
+		Value string `json:"value" writer:",width:60"`
+	}
+	var metadata = []kv{}
+	if version.GitSource != "" {
+		metadata = append(metadata, kv{"source", version.GitSource})
+	}
+	if version.GitBranch != "" {
+		metadata = append(metadata, kv{"branch", version.GitBranch})
+	}
+	if version.GitTag != "" {
+		metadata = append(metadata, kv{"tag", version.GitTag})
+	}
+	if version.GitHash != "" {
+		metadata = append(metadata, kv{"hash", version.GitHash})
+	}
+	if version.GoBuildTime != "" {
+		metadata = append(metadata, kv{"build time", version.GoBuildTime})
+	}
+	metadata = append(metadata, kv{"go version", runtime.Version()})
+	metadata = append(metadata, kv{"os", runtime.GOOS + "/" + runtime.GOARCH})
+
+	return ctx.writer.Write(metadata)
+}