Merge pull request #3 from mutablelogic/v1

Merged

Author: djthorpe

.github/workflows/merge.yaml

@@ -0,0 +1,43 @@
+
+name: "Merge to main"
+on:
+  push:
+    branches: [ main ]
+jobs:
+  analyze:
+    name: Analyze
+    runs-on: ubuntu-latest
+    permissions:
+      actions: read
+      contents: read
+      security-events: write
+    strategy:
+      fail-fast: false
+      matrix:
+        language: [ 'go' ]    
+    steps:
+    - name: Checkout repository
+      uses: actions/checkout@v4
+    - name: Initialize CodeQL
+      uses: github/codeql-action/init@v2
+      with:
+        languages: ${{ matrix.language }}
+    - name: Autobuild
+      uses: github/codeql-action/autobuild@v2
+    - name: Perform CodeQL Analysis
+      uses: github/codeql-action/analyze@v2
+  test:
+    name: Test
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        go-version: [ '1.19', '1.20', '1.21.x' ]  
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+      - name: Setup Go ${{ matrix.go-version }}
+        uses: actions/setup-go@v4
+        with:
+          go-version: ${{ matrix.go-version }}
+      - name: Run tests
+        run: make test

.gitignore

@@ -1,21 +1 @@
-# If you prefer the allow list template instead of the deny list, see community template:
-# https://github.com/github/gitignore/blob/main/community/Golang/Go.AllowList.gitignore
-#
-# Binaries for programs and plugins
-*.exe
-*.exe~
-*.dll
-*.so
-*.dylib
-
-# Test binary, built with `go test -c`
-*.test
-
-# Output of the go coverage tool, specifically when used with LiteIDE
-*.out
-
-# Dependency directories (remove the comment below to include it)
-# vendor/
-
-# Go workspace file
-go.work
+build

build/cli

@@ -5,14 +5,18 @@ import (
 	"os"
 	"time"
 
+	// Packages
 	"github.com/djthorpe/go-errors"
+	"github.com/mutablelogic/go-client/pkg/writer"
 )
 
 ///////////////////////////////////////////////////////////////////////////////
 // TYPES
 
 type Flags struct {
 	*flag.FlagSet
+
+	writer *writer.Writer
 }
 
 type FlagsRegister func(*Flags)
@@ -36,6 +40,13 @@ func NewFlags(name string, args []string, register ...FlagsRegister) (*Flags, er
 		return nil, err
 	}
 
+	// Create a writer
+	if w, err := writer.New(os.Stdout); err != nil {
+		return nil, err
+	} else {
+		flags.writer = w
+	}
+
 	// Return success
 	return flags, nil
 }
@@ -58,3 +69,7 @@ func (flags *Flags) GetString(key string) (string, error) {
 		return os.ExpandEnv(flag.Value.String()), nil
 	}
 }
+
+func (flags *Flags) Write(v writer.TableWriter) error {
+	return flags.writer.Write(v)
+}

cmd/cli/flags.go

@@ -1,7 +1,6 @@
 package main
 
 import (
-	"fmt"
 
 	// Packages
 	"github.com/mutablelogic/go-client/pkg/client"
@@ -29,11 +28,10 @@ func IpifyRegister(cmd []Client, opts []client.ClientOpt, flags *Flags) ([]Clien
 
 func IpifyGet(ipify *ipify.Client, flags *Flags) CommandFn {
 	return func() error {
-		if addr, err := ipify.Get(); err != nil {
+		addr, err := ipify.Get()
+		if err != nil {
 			return err
-		} else {
-			fmt.Printf("IP Address: %s\n", addr)
 		}
-		return nil
+		return flags.Write(addr)
 	}
 }

cmd/cli/ipify.go

@@ -11,7 +11,7 @@ import (
 
 func main() {
 	name := path.Base(os.Args[0])
-	flags, err := NewFlags(name, os.Args[1:], ElevenlabsFlags)
+	flags, err := NewFlags(name, os.Args[1:], ElevenlabsFlags, OpenAIFlags)
 	if err != nil {
 		if err != flag.ErrHelp {
 			fmt.Fprintln(os.Stderr, err)
@@ -42,6 +42,11 @@ func main() {
 		fmt.Fprintln(os.Stderr, err)
 		os.Exit(1)
 	}
+	cmd, err = OpenAIRegister(cmd, opts, flags)
+	if err != nil {
+		fmt.Fprintln(os.Stderr, err)
+		os.Exit(1)
+	}
 
 	// Run command
 	if err := Run(cmd, flags); err != nil {

cmd/cli/main.go

@@ -0,0 +1,66 @@
+package main
+
+import (
+	"encoding/json"
+	"fmt"
+
+	// Packages
+	"github.com/mutablelogic/go-client/pkg/client"
+	"github.com/mutablelogic/go-client/pkg/openai"
+)
+
+func OpenAIFlags(flags *Flags) {
+	flags.String("openai-api-key", "${OPENAI_API_KEY}", "OpenAI API key")
+}
+
+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...)
+	if err != nil {
+		return nil, err
+	}
+
+	// Register commands
+	cmd = append(cmd, Client{
+		ns: "openai",
+		cmd: []Command{
+			{Name: "models", Description: "Return registered models", MinArgs: 2, MaxArgs: 2, Fn: OpenAIModels(openai, flags)},
+			{Name: "model", Description: "Return model information", MinArgs: 3, MaxArgs: 3, Fn: OpenAIModel(openai, flags)},
+		},
+	})
+
+	// Return success
+	return cmd, nil
+}
+
+func OpenAIModels(client *openai.Client, flags *Flags) CommandFn {
+	return func() error {
+		if models, err := client.Models(); err != nil {
+			return err
+		} else if data, err := json.MarshalIndent(models, "", "  "); err != nil {
+			return err
+		} else {
+			fmt.Printf("Models: %s\n", data)
+		}
+		return nil
+	}
+}
+
+func OpenAIModel(client *openai.Client, flags *Flags) CommandFn {
+	return func() error {
+		if model, err := client.Model(flags.Arg(2)); err != nil {
+			return err
+		} else if data, err := json.MarshalIndent(model, "", "  "); err != nil {
+			return err
+		} else {
+			fmt.Printf("%s\n", data)
+		}
+		return nil
+	}
+}

cmd/cli/openai.go

@@ -58,6 +58,7 @@ const (
 	ContentTypeTextPlain      = "text/plain"
 	ContentTypeTextHTML       = "text/html"
 	ContentTypeBinary         = "application/octet-stream"
+	ContentTypeForm           = "multipart/form-data"
 )
 
 ///////////////////////////////////////////////////////////////////////////////
@@ -156,13 +157,41 @@ func (client *Client) Do(in Payload, out any, opts ...RequestOpt) error {
 	}
 
 	// If client token is set, then add to request
-	if client.token.Scheme != "" {
+	if client.token.Scheme != "" && client.token.Value != "" {
 		opts = append([]RequestOpt{OptToken(client.token)}, opts...)
 	}
 
 	return do(client.Client, req, accept, client.strict, out, opts...)
 }
 
+// Do a HTTP request and decode it into an object
+func (client *Client) Request(req *http.Request, out any, opts ...RequestOpt) error {
+	client.Mutex.Lock()
+	defer client.Mutex.Unlock()
+
+	// Check rate limit - sleep until next request can be made
+	now := time.Now()
+	if !client.ts.IsZero() && client.rate > 0.0 {
+		next := client.ts.Add(time.Duration(float32(time.Second) / client.rate))
+		if next.After(now) {
+			time.Sleep(next.Sub(now))
+		}
+	}
+
+	// Set timestamp at return
+	defer func(now time.Time) {
+		client.ts = now
+	}(now)
+
+	// If client token is set, then add to request, at the beginning so it can be
+	// overridden by any other options
+	if client.token.Scheme != "" && client.token.Value != "" {
+		opts = append([]RequestOpt{OptToken(client.token)}, opts...)
+	}
+
+	return do(client.Client, req, "", false, out, opts...)
+}
+
 ///////////////////////////////////////////////////////////////////////////////
 // PRIVATE METHODS
 

pkg/client/client.go

@@ -23,7 +23,11 @@ func OptPath(value ...string) RequestOpt {
 // OptToken adds an authorization header. The header format is "Authorization: Bearer <token>"
 func OptToken(value Token) RequestOpt {
 	return func(r *http.Request) error {
-		r.Header.Set("Authorization", value.String())
+		if value.Value != "" {
+			r.Header.Set("Authorization", value.String())
+		} else {
+			r.Header.Del("Authorization")
+		}
 		return nil
 	}
 }

pkg/client/requestopts.go

@@ -67,7 +67,7 @@ func (transport *logtransport) RoundTrip(req *http.Request) (*http.Response, err
 			fmt.Fprintf(transport.w, "  => %v: %q\n", k, v)
 		}
 		// If verbose is switched on, read the body
-		if transport.v && resp.Body != nil && resp.ContentLength > 0 {
+		if transport.v && resp.Body != nil {
 			contentType := resp.Header.Get("Content-Type")
 			if contentType == ContentTypeJson || contentType == ContentTypeTextPlain {
 				defer resp.Body.Close()