Added OpenAI speech

Author: djthorpe

cmd/cli/flags.go

@@ -6,6 +6,7 @@ import (
 	"os"
 	"path/filepath"
 	"strconv"
+	"strings"
 	"time"
 
 	// Packages
@@ -65,13 +66,24 @@ func (flags *Flags) Timeout() time.Duration {
 }
 
 func (flags *Flags) GetOut() string {
-	v, _ := flags.GetString("out")
-	return v
+	return flags.GetString("out")
+}
+
+func (flags *Flags) GetOutExt() string {
+	out := flags.GetOut()
+	if out == "" {
+		return ""
+	}
+	if ext := filepath.Ext(out); ext == "" {
+		return out
+	} else {
+		return strings.TrimPrefix(ext, ".")
+	}
 }
 
 // Return a filename for output, returns an empty string if the output
 // argument is not a filename (it requires an extension)
-func (flags *Flags) GetOutFilename(def string, n uint) string {
+func (flags *Flags) GetOutFilename(def string, n int) string {
 	filename := flags.GetOut()
 	if filename == "" {
 		filename = filepath.Base(def)
@@ -91,11 +103,11 @@ func (flags *Flags) GetOutFilename(def string, n uint) string {
 	return filepath.Clean(filename)
 }
 
-func (flags *Flags) GetString(key string) (string, error) {
+func (flags *Flags) GetString(key string) string {
 	if flag := flags.Lookup(key); flag == nil {
-		return "", ErrNotFound.With(key)
+		return ""
 	} else {
-		return os.ExpandEnv(flag.Value.String()), nil
+		return os.ExpandEnv(flag.Value.String())
 	}
 }
 
@@ -109,6 +121,26 @@ func (flags *Flags) GetUint(key string) (uint, error) {
 	}
 }
 
+func (flags *Flags) GetInt(key string) (int, error) {
+	if flag := flags.Lookup(key); flag == nil {
+		return 0, ErrNotFound.With(key)
+	} else if v, err := strconv.ParseInt(os.ExpandEnv(flag.Value.String()), 10, 64); err != nil {
+		return 0, ErrBadParameter.With(key)
+	} else {
+		return int(v), nil
+	}
+}
+
+func (flags *Flags) GetBool(key string) bool {
+	if flag := flags.Lookup(key); flag == nil {
+		return false
+	} else if v, err := strconv.ParseBool(os.ExpandEnv(flag.Value.String())); err != nil {
+		return false
+	} else {
+		return v
+	}
+}
+
 func (flags *Flags) Write(v any) error {
 	opts := []tablewriter.TableOpt{}
 

cmd/cli/homeassistant.go

@@ -15,20 +15,8 @@ func HomeAssistantFlags(flags *Flags) {
 }
 
 func HomeAssistantRegister(cmd []Client, opts []client.ClientOpt, flags *Flags) ([]Client, error) {
-	// Get API key
-	key, err := flags.GetString("ha-token")
-	if err != nil {
-		return nil, err
-	}
-
-	// Get endpoint
-	endPoint, err := flags.GetString("ha-endpoint")
-	if err != nil {
-		return nil, err
-	}
-
-	// Create ipify client
-	ha, err := homeassistant.New(endPoint, key, opts...)
+	// Create home assistant client
+	ha, err := homeassistant.New(flags.GetString("ha-endpoint"), flags.GetString("ha-token"), opts...)
 	if err != nil {
 		return nil, err
 	}

cmd/cli/open.go

@@ -0,0 +1,24 @@
+package main
+
+import (
+	"os/exec"
+	"runtime"
+)
+
+// open opens the specified files with the operating system
+func open(url ...string) error {
+	var cmd string
+	var args []string
+
+	switch runtime.GOOS {
+	case "windows":
+		cmd = "cmd"
+		args = []string{"/c", "start"}
+	case "darwin":
+		cmd = "open"
+	default: // "linux", "freebsd", "openbsd", "netbsd"
+		cmd = "xdg-open"
+	}
+	args = append(args, url...)
+	return exec.Command(cmd, args...).Start()
+}

cmd/cli/openai.go

@@ -1,28 +1,51 @@
 package main
 
 import (
+	"errors"
+	"fmt"
+	"net/url"
+	"os"
+	"path/filepath"
+	"regexp"
+	"strconv"
+
 	"github.com/mutablelogic/go-client/pkg/client"
 	"github.com/mutablelogic/go-client/pkg/openai"
 )
 
+/////////////////////////////////////////////////////////////////////
+// TYPES
+
+type openaiImageResponse struct {
+	Url   string `json:"-"`
+	Path  string `json:"path"`
+	Bytes uint   `json:"bytes_written"`
+}
+
+/////////////////////////////////////////////////////////////////////
+// GLOBALS
+
+var (
+	reOpenAISize = regexp.MustCompile(`^(\d+)x(\d+)$`)
+	defaultVoice = "alloy"
+)
+
 /////////////////////////////////////////////////////////////////////
 // REGISTER FUNCTIONS
 
 func OpenAIFlags(flags *Flags) {
 	flags.String("openai-api-key", "${OPENAI_API_KEY}", "OpenAI API key")
-	flags.String("openai-model", "", "OpenAI Model")
-	flags.Uint("openai-count", 0, "Number of results to return")
+	flags.String("model", "", "Model to use for generation")
+	flags.Uint("count", 0, "Number of results to return")
+	flags.Bool("natural", false, "Create more natural images")
+	flags.Bool("hd", false, "Create images with finer details and greater consistency across the image")
+	flags.String("size", "", "Size of output image (256x256, 512x512, 1024x1024, 1792x1024 or 1024x1792)")
+	flags.Bool("open", false, "Open images in default viewer")
 }
 
 func OpenAIRegister(cmd []Client, opts []client.ClientOpt, flags *Flags) ([]Client, error) {
-	// Get API key
-	key, err := flags.GetString("openai-api-key")
-	if err != nil {
-		return nil, err
-	}
-
 	// Create client
-	openai, err := openai.New(key, opts...)
+	openai, err := openai.New(flags.GetString("openai-api-key"), opts...)
 	if err != nil {
 		return nil, err
 	}
@@ -32,6 +55,9 @@ func OpenAIRegister(cmd []Client, opts []client.ClientOpt, flags *Flags) ([]Clie
 		ns: "openai",
 		cmd: []Command{
 			{Name: "models", Description: "Return registered models", MinArgs: 2, MaxArgs: 2, Fn: openaiModels(openai, flags)},
+			{Name: "model", Description: "Return model information", Syntax: "<model>", MinArgs: 3, MaxArgs: 3, Fn: openaiModel(openai, flags)},
+			{Name: "image", Description: "Create images from a prompt", Syntax: "<prompt>", MinArgs: 3, MaxArgs: 3, Fn: openaiImages(openai, flags)},
+			{Name: "speak", Description: "Create speech from a prompt", Syntax: "(<voice>) <prompt>", MinArgs: 3, MaxArgs: 4, Fn: openaiSpeak(openai, flags)},
 		},
 	})
 
@@ -52,3 +78,146 @@ func openaiModels(client *openai.Client, flags *Flags) CommandFn {
 		return nil
 	}
 }
+
+func openaiModel(client *openai.Client, flags *Flags) CommandFn {
+	return func() error {
+		if model, err := client.GetModel(flags.Arg(2)); err != nil {
+			return err
+		} else if err := flags.Write(model); err != nil {
+			return err
+		}
+		return nil
+	}
+}
+
+func openaiSpeak(client *openai.Client, flags *Flags) CommandFn {
+	return func() error {
+		// Set options
+		opts := []openai.Opt{}
+		if model := flags.GetString("model"); model != "" {
+			opts = append(opts, openai.OptModel(model))
+		}
+		if format := flags.GetOutExt(); format != "" {
+			opts = append(opts, openai.OptResponseFormat(format))
+		}
+		var voice, prompt string
+		if flags.NArg() == 4 {
+			voice = flags.Arg(2)
+			prompt = flags.Arg(3)
+		} else {
+			voice = defaultVoice
+			prompt = flags.Arg(2)
+		}
+
+		// Determine the filename
+		w, err := os.Create("output.mp3")
+		if err != nil {
+			return err
+		}
+		defer w.Close()
+
+		// Create the audio
+		response, err := client.Speech(w, voice, prompt, opts...)
+		if err != nil {
+			return err
+		}
+
+		// Open images
+		if flags.GetBool("open") {
+			if err := open("output.mp3"); err != nil {
+				return err
+			}
+		}
+
+		fmt.Println(response, "bytes written")
+
+		// Return any errors
+		return nil
+	}
+}
+
+func openaiImages(client *openai.Client, flags *Flags) CommandFn {
+	return func() error {
+		// Set options
+		opts := []openai.Opt{}
+		if model := flags.GetString("model"); model != "" {
+			opts = append(opts, openai.OptModel(model))
+		}
+		if count, err := flags.GetInt("count"); err != nil {
+			return err
+		} else if count > 0 {
+			opts = append(opts, openai.OptCount(count))
+		}
+		if flags.GetBool("hd") {
+			opts = append(opts, openai.OptQuality("hd"), openai.OptModel("dall-e-3"))
+		}
+		if flags.GetBool("natural") {
+			opts = append(opts, openai.OptStyle("natural"))
+		}
+		if size := flags.GetString("size"); size != "" {
+			if width, height, err := openaiSize(size); err != nil {
+				return err
+			} else {
+				opts = append(opts, openai.OptSize(width, height))
+			}
+		}
+		if format := flags.GetOutExt(); format != "" {
+			opts = append(opts, openai.OptResponseFormat(format))
+		}
+
+		// Create images
+		response, err := client.CreateImages(flags.Arg(2), opts...)
+		if err != nil {
+			return err
+		}
+
+		// Write out images
+		var result error
+		var written []openaiImageResponse
+		for _, image := range response {
+			if url, err := url.Parse(image.Url); err != nil {
+				result = errors.Join(result, err)
+			} else if w, err := os.Create(filepath.Base(url.Path)); err != nil {
+				result = errors.Join(result, err)
+			} else {
+				defer w.Close()
+				if n, err := client.WriteImage(w, image); err != nil {
+					result = errors.Join(result, err)
+				} else {
+					written = append(written, openaiImageResponse{Url: image.Url, Bytes: uint(n), Path: w.Name()})
+				}
+			}
+		}
+
+		// Open images
+		if flags.GetBool("open") {
+			var paths []string
+			for _, image := range written {
+				paths = append(paths, image.Path)
+			}
+			if err := open(paths...); err != nil {
+				result = errors.Join(result, err)
+			}
+		} else if err := flags.Write(written); err != nil {
+			result = errors.Join(result, err)
+		}
+
+		// Return any errors
+		return result
+	}
+}
+
+/////////////////////////////////////////////////////////////////////
+// PRIVATE METHODS
+
+func openaiSize(size string) (uint, uint, error) {
+	if n := reOpenAISize.FindStringSubmatch(size); n == nil || len(n) != 3 {
+		return 0, 0, errors.New("invalid size, should be <width>x<height>")
+	} else if w, err := strconv.ParseUint(n[1], 10, 64); err != nil {
+		return 0, 0, err
+	} else if h, err := strconv.ParseUint(n[2], 10, 64); err != nil {
+		return 0, 0, err
+	} else {
+		return uint(w), uint(h), nil
+	}
+}