Added text-to-speech method

Author: djthorpe

pkg/client/clientopts.go

@@ -104,7 +104,7 @@ func OptSkipVerify() ClientOpt {
 func OptHeader(key, value string) ClientOpt {
 	return func(client *Client) error {
 		if client.headers == nil {
-			client.headers = make(map[string]string, 1)
+			client.headers = make(map[string]string, 2)
 		}
 		if key == "" {
 			return ErrBadParameter.With("OptHeader")

pkg/client/transport.go

@@ -7,6 +7,7 @@ import (
 	"io"
 	"net/http"
 	"time"
+	// Packages
 )
 
 ///////////////////////////////////////////////////////////////////////////////
@@ -62,15 +63,20 @@ func (transport *logtransport) RoundTrip(req *http.Request) (*http.Response, err
 		fmt.Fprintln(transport.w, "  => Error:", err)
 	} else {
 		fmt.Fprintln(transport.w, "  =>", resp.Status)
-
+		for k, v := range resp.Header {
+			fmt.Fprintf(transport.w, "  => %v: %q\n", k, v)
+		}
 		// If verbose is switched on, read the body
-		if transport.v && resp.Body != nil {
-			defer resp.Body.Close()
-			body, err := io.ReadAll(resp.Body)
-			if err == nil {
-				fmt.Fprintln(transport.w, "    ", string(body))
+		if transport.v && resp.Body != nil && resp.ContentLength > 0 {
+			contentType := resp.Header.Get("Content-Type")
+			if contentType == ContentTypeJson || contentType == ContentTypeTextPlain {
+				defer resp.Body.Close()
+				body, err := io.ReadAll(resp.Body)
+				if err == nil {
+					fmt.Fprintln(transport.w, "    ", string(body))
+				}
+				resp.Body = io.NopCloser(bytes.NewReader(body))
 			}
-			resp.Body = io.NopCloser(bytes.NewReader(body))
 		}
 	}
 

pkg/elevenlabs/client.go

@@ -4,8 +4,6 @@ elevenlabs implements an API client for elevenlabs (https://elevenlabs.io/docs/a
 package elevenlabs
 
 import (
-	"net/http"
-
 	// Packages
 	"github.com/mutablelogic/go-client/pkg/client"
 )
@@ -33,77 +31,16 @@ const (
 	SampleU8    = "ulaw_8000"     // μ-law format (sometimes written mu-law, often approximated as u-law) with 8kHz sample rate
 )
 
-///////////////////////////////////////////////////////////////////////////////
-// SCHEMA
-
-type Request struct {
-	client.Payload `json:"-"`
-	Model          string `json:"model_id"`
-	Text           string `json:"text"`
-	VoiceSettings  struct {
-		SimilarityBoost float64 `json:"similarity_boost"`
-		Stability       float64 `json:"stability"`
-		Style           string  `json:"style,omitempty"`
-		UseSpeakerBoost bool    `json:"use_speaker_boost"`
-	} `json:"voice_settings"`
-}
-
-func (r Request) Method() string {
-	return http.MethodGet
-}
-
-func (r Request) Type() string {
-	return ""
-}
-
-func (r Request) Accept() string {
-	return client.ContentTypeJson
-}
-
-type VoicesResponse struct {
-	Voices []Voice `json:"voices"`
-}
-
-type Voice struct {
-	Id          string `json:"voice_id"`
-	Name        string `json:"name"`
-	Description string `json:"description,omitempty"`
-	PreviewUrl  string `json:"preview_url,omitempty"`
-	Category    string `json:"category,omitempty"`
-}
-
 ///////////////////////////////////////////////////////////////////////////////
 // LIFECYCLE
 
 func New(ApiKey string, opts ...client.ClientOpt) (*Client, error) {
 	// Create client
-	client, err := client.New(append(opts, client.OptEndpoint(endPoint), client.OptHeader("Xi-Api-Key", ApiKey))...)
+	client, err := client.New(append(opts, client.OptEndpoint(endPoint), client.OptHeader("xi-api-key", ApiKey))...)
 	if err != nil {
 		return nil, err
 	}
 
 	// Return the client
 	return &Client{client}, nil
 }
-
-///////////////////////////////////////////////////////////////////////////////
-// PUBLIC METHODS
-
-// Return current set of voices
-func (c *Client) Voices() ([]Voice, error) {
-	var request Request
-	var response VoicesResponse
-	if err := c.Do(request, &response, client.OptPath("voices")); err != nil {
-		return nil, err
-	}
-	return response.Voices, nil
-}
-
-// Get returns the current IP address from the API
-func (c *Client) TextToSpeech(Text string) ([]byte, error) {
-	var request Request
-	if err := c.Do(request, nil, client.OptPath("text-to-speech", "test")); err != nil {
-		return nil, err
-	}
-	return nil, nil
-}

pkg/elevenlabs/client_test.go

@@ -1,7 +1,6 @@
 package elevenlabs_test
 
 import (
-	"encoding/json"
 	"os"
 	"testing"
 
@@ -11,28 +10,12 @@ import (
 	assert "github.com/stretchr/testify/assert"
 )
 
-func Test_elevenlabs_001(t *testing.T) {
+func Test_client_001(t *testing.T) {
 	assert := assert.New(t)
 	client, err := elevenlabs.New(GetApiKey(t), opts.OptTrace(os.Stderr, true))
 	assert.NoError(err)
 	assert.NotNil(client)
-	response, err := client.Voices()
-	assert.NoError(err)
-	assert.NotEmpty(response)
-	data, err := json.MarshalIndent(response, "", "  ")
-	assert.NoError(err)
-	t.Log(string(data))
-}
-
-func XX_Test_elevenlabs_002(t *testing.T) {
-	assert := assert.New(t)
-	client, err := elevenlabs.New(GetApiKey(t), opts.OptTrace(os.Stderr, true))
-	assert.NoError(err)
-	assert.NotNil(client)
-	response, err := client.TextToSpeech("test")
-	assert.NoError(err)
-	assert.NotEmpty(response)
-	t.Log(response)
+	t.Log(client)
 }
 
 ///////////////////////////////////////////////////////////////////////////////
@@ -44,5 +27,5 @@ func GetApiKey(t *testing.T) string {
 		t.Skip("ELEVENLABS_API_KEY not set")
 		t.SkipNow()
 	}
-	return ""
+	return key
 }

pkg/elevenlabs/opts.go

@@ -0,0 +1,62 @@
+package elevenlabs
+
+import (
+	"fmt"
+
+	"github.com/djthorpe/go-errors"
+)
+
+///////////////////////////////////////////////////////////////////////////////
+// TYPES
+
+type TextToSpeechOpt func(*textToSpeechRequest) error
+type TextToSpeechFormat string
+
+///////////////////////////////////////////////////////////////////////////////
+// GLOBALS
+
+const (
+	MP3_44100_64  TextToSpeechFormat = "mp3_44100_64"  // mp3 with 44.1kHz sample rate at 64kbps
+	MP3_44100_96  TextToSpeechFormat = "mp3_44100_96"  // mp3 with 44.1kHz sample rate at 96kbps
+	MP3_44100_128 TextToSpeechFormat = "mp3_44100_128" // default output format, mp3 with 44.1kHz sample rate at 128kbps
+	MP3_44100_192 TextToSpeechFormat = "mp3_44100_192" // mp3 with 44.1kHz sample rate at 192kbps
+	PCM_16000     TextToSpeechFormat = "pcm_16000"     // PCM format (S16LE) with 16kHz sample rate
+	PCM_22050     TextToSpeechFormat = "pcm_22050"     // PCM format (S16LE) with 22.05kHz sample rate
+	PCM_24000     TextToSpeechFormat = "pcm_24000"     // PCM format (S16LE) with 24kHz sample rate
+	PCM_44100     TextToSpeechFormat = "pcm_44100"     // PCM format (S16LE) with 44.1kHz sample rate
+	ULAW_8000     TextToSpeechFormat = "ulaw_8000"     // μ-law format (sometimes written mu-law, often approximated as u-law) with 8kHz sample rate
+)
+
+///////////////////////////////////////////////////////////////////////////////
+// PUBLIC METHODS
+
+func OptOutput(format TextToSpeechFormat) TextToSpeechOpt {
+	return func(req *textToSpeechRequest) error {
+		req.Query.Set("output_format", string(format))
+		return nil
+	}
+}
+
+func OptOptimizeStreamingLatency(value uint8) TextToSpeechOpt {
+	return func(req *textToSpeechRequest) error {
+		req.Query.Set("optimize_streaming_latency", fmt.Sprint(value))
+		return nil
+	}
+}
+
+func OptModel(id string) TextToSpeechOpt {
+	return func(req *textToSpeechRequest) error {
+		if id == "" {
+			return errors.ErrBadParameter.With("OptModel: id")
+		}
+		req.ModelId = id
+		return nil
+	}
+}
+
+func OptVoiceSettings(settings VoiceSettings) TextToSpeechOpt {
+	return func(req *textToSpeechRequest) error {
+		req.Settings = settings
+		return nil
+	}
+}

pkg/elevenlabs/text-to-speech.go

@@ -0,0 +1,93 @@
+package elevenlabs
+
+import (
+	"io"
+	"net/http"
+	"net/url"
+
+	"github.com/djthorpe/go-errors"
+	"github.com/mutablelogic/go-client/pkg/client"
+)
+
+///////////////////////////////////////////////////////////////////////////////
+// SCHEMA
+
+type textToSpeechRequest struct {
+	client.Payload `json:"-"`
+	Query          url.Values    `json:"-"`
+	Text           string        `json:"text"`
+	ModelId        string        `json:"model_id,omitempty"`
+	Settings       VoiceSettings `json:"voice_settings,omitempty"`
+}
+
+type textToSpeechResponse struct {
+	Type  string
+	Bytes []byte
+}
+
+///////////////////////////////////////////////////////////////////////////////
+// PUBLIC METHODS
+
+// Return speech audio as bytes for text and voice
+func (c *Client) TextToSpeech(text, Id string, opts ...TextToSpeechOpt) ([]byte, error) {
+	var request textToSpeechRequest
+	var response textToSpeechResponse
+
+	// Parse parameters
+	if text == "" {
+		return nil, errors.ErrBadParameter.With("text")
+	} else {
+		request.Text = text
+	}
+	if Id == "" {
+		return nil, errors.ErrBadParameter.With("Id")
+	}
+
+	// Apply options
+	request.Query = make(url.Values)
+	for _, opt := range opts {
+		if err := opt(&request); err != nil {
+			return nil, err
+		}
+	}
+
+	// Perform the request
+	requestopts := []client.RequestOpt{
+		client.OptPath("text-to-speech", Id),
+		client.OptQuery(request.Query),
+	}
+	if err := c.Do(request, &response, requestopts...); err != nil {
+		return nil, err
+	}
+
+	// Return success
+	return response.Bytes, nil
+}
+
+///////////////////////////////////////////////////////////////////////////////
+// REQUEST METHODS
+
+func (textToSpeechRequest) Method() string {
+	return http.MethodPost
+}
+
+func (textToSpeechRequest) Type() string {
+	return client.ContentTypeJson
+}
+
+func (textToSpeechRequest) Accept() string {
+	return client.ContentTypeBinary
+}
+
+///////////////////////////////////////////////////////////////////////////////
+// RESPONSE METHODS
+
+func (resp *textToSpeechResponse) Unmarshal(mimetype string, r io.Reader) error {
+	resp.Type = mimetype
+	if data, err := io.ReadAll(r); err != nil {
+		return err
+	} else {
+		resp.Bytes = data
+		return nil
+	}
+}

pkg/elevenlabs/text-to-speech_test.go

@@ -0,0 +1,40 @@
+package elevenlabs_test
+
+import (
+	"os"
+	"path"
+	"testing"
+
+	// Packages
+	opts "github.com/mutablelogic/go-client/pkg/client"
+	elevenlabs "github.com/mutablelogic/go-client/pkg/elevenlabs"
+	assert "github.com/stretchr/testify/assert"
+)
+
+func Test_tts_001(t *testing.T) {
+	assert := assert.New(t)
+	client, err := elevenlabs.New(GetApiKey(t), opts.OptTrace(os.Stderr, true))
+	assert.NoError(err)
+	assert.NotNil(client)
+
+	voices, err := client.Voices()
+	assert.NoError(err)
+	assert.NotEmpty(voices)
+
+	tmp := t.TempDir()
+	for n, voice := range voices {
+		data, err := client.TextToSpeech("The quick brown fox jumped over the lazy dog", voice.Id,
+			elevenlabs.OptOutput(elevenlabs.MP3_44100_64),
+			elevenlabs.OptOptimizeStreamingLatency(uint8(n)%5),
+		)
+		assert.NoError(err)
+		assert.NotEmpty(data)
+		filename := path.Join(tmp, voice.Id+".mp3")
+		t.Log(voice.Name, "=>", filename)
+		f, err := os.Create(filename)
+		assert.NoError(err)
+		defer f.Close()
+		_, err = f.Write(data)
+		assert.NoError(err)
+	}
+}