Added image method

Author: djthorpe

cmd/cli/flags.go

@@ -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/ipify.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)
 	}
 }

pkg/client/client.go

@@ -156,13 +156,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/requestopts.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/transport.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()

pkg/ipify/client.go

@@ -68,10 +68,32 @@ func New(opts ...client.ClientOpt) (*Client, error) {
 // PUBLIC METHODS
 
 // Get returns the current IP address from the API
-func (c *Client) Get() (string, error) {
+func (c *Client) Get() (Response, error) {
 	var response Response
 	if err := c.Do(nil, &response, client.OptQuery(url.Values{"format": []string{"json"}})); err != nil {
-		return "", err
+		return Response{}, err
 	}
-	return response.IP, nil
+	return response, nil
+}
+
+///////////////////////////////////////////////////////////////////////////////
+// WRITER IMPLEMENTATION
+
+func (Response) Columns() []string {
+	return []string{"IP"}
+}
+
+func (r Response) Count() int {
+	if r.IP == "" {
+		return 0
+	} else {
+		return 1
+	}
+}
+
+func (r Response) Row(n int) []any {
+	if n != 0 {
+		return nil
+	}
+	return []any{r.IP}
 }

pkg/openai/chat.go

@@ -1,25 +1,114 @@
 package openai
 
-import "github.com/mutablelogic/go-client/pkg/client"
+import (
+	"fmt"
+	"net/http"
+
+	// Packages
+	"github.com/mutablelogic/go-client/pkg/client"
+
+	// Namespace imports
+	. "github.com/djthorpe/go-errors"
+)
 
 ///////////////////////////////////////////////////////////////////////////////
 // SCHEMA
 
-type Message struct {
-	Name    string `json:"name,omitempty"`
-	Role    string `json:"role"`
-	Content string `json:"content"`
+type MessageChoice struct {
+	Index        int     `json:"index"`
+	Message      Message `json:"message"`
+	FinishReason string  `json:"finish_reason"`
+}
+
+type ChatCompletion struct {
+	Id                string           `json:"id"`
+	Object            string           `json:"object"`
+	Created           int64            `json:"created"`
+	Model             string           `json:"model"`
+	SystemFingerprint string           `json:"system_fingerprint"`
+	Choices           []*MessageChoice `json:"choices"`
+	Usage             struct {
+		PromptTokens     int `json:"prompt_tokens"`
+		CompletionTokens int `json:"completion_tokens"`
+		TotalTokens      int `json:"total_tokens"`
+	} `json:"usage"`
+}
+
+///////////////////////////////////////////////////////////////////////////////
+// REQUEST AND RESPONSE
+
+type chatResponseFormat struct {
+	Type string `json:"type"`
+}
+
+type chatRequest struct {
+	client.Payload   `json:"-"`
+	Model            string              `json:"model"`
+	Messages         []Message           `json:"messages"`
+	FrequencyPenalty float32             `json:"frequency_penalty,omitempty"`
+	PresencePenalty  float32             `json:"presence_penalty,omitempty"`
+	MaxTokens        int                 `json:"max_tokens,omitempty"`
+	Choices          int                 `json:"n,omitempty"`
+	ResponseFormat   *chatResponseFormat `json:"response_format,omitempty"`
+	Seed             int64               `json:"seed,omitempty"`
+	Stream           bool                `json:"stream,omitempty"`
+	Temperature      float32             `json:"temperature,omitempty"`
+	User             string              `json:"user,omitempty"`
+}
+
+func (r chatRequest) Method() string {
+	return http.MethodPost
+}
+
+func (r chatRequest) Type() string {
+	return client.ContentTypeJson
+}
+
+func (r chatRequest) Accept() string {
+	return client.ContentTypeJson
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // PUBLIC METHODS
 
-// Return current set of models
-func (c *Client) ChatCompletions(model string, messages ...Message) ([]Model, error) {
-	var request client.Payload
-	var response modelsResponse
-	if err := c.Do(request, &response, client.OptPath("models")); err != nil {
-		return nil, err
+// Chat completion response returned by a specific model, based on the provided input messages
+func (c *Client) ChatCompletions(model string, messages []Message, opts ...ChatCompletionOpt) (ChatCompletion, error) {
+	var request chatRequest
+	var response ChatCompletion
+
+	// Check parameters
+	if model == "" {
+		return response, ErrBadParameter.With("model")
+	}
+	if len(messages) == 0 {
+		return response, ErrBadParameter.With("messages")
+	}
+
+	// Set request
+	request.Model = model
+	request.Messages = messages
+
+	// Set chat options
+	for _, opt := range opts {
+		if err := opt(&request); err != nil {
+			return response, err
+		}
 	}
-	return response.Models, nil
+
+	// Perform request
+	if err := c.Do(request, &response, client.OptPath("chat", "completions")); err != nil {
+		return ChatCompletion{}, err
+	}
+
+	// Return success
+	return response, nil
+}
+
+///////////////////////////////////////////////////////////////////////////////
+// UNMARSHALL
+
+func (choice *MessageChoice) UnmarshalJSON(data []byte) error {
+	// TODO
+	fmt.Println("UnmarshalJSON", string(data))
+	return nil
 }

pkg/openai/chat_test.go

@@ -0,0 +1,29 @@
+package openai_test
+
+import (
+	"encoding/json"
+	"os"
+	"testing"
+
+	opts "github.com/mutablelogic/go-client/pkg/client"
+	openai "github.com/mutablelogic/go-client/pkg/openai"
+	assert "github.com/stretchr/testify/assert"
+)
+
+func Test_chat_001(t *testing.T) {
+	assert := assert.New(t)
+	client, err := openai.New(GetApiKey(t), opts.OptTrace(os.Stderr, true))
+	assert.NoError(err)
+	assert.NotNil(client)
+
+	response, err := client.ChatCompletions("gpt-3.5-turbo", []openai.Message{
+		openai.SystemMessage("You are a helpful assistant"),
+		openai.UserMessage("Hello, my name is John. I am a doctor"),
+	}, openai.OptMaxChoices(1))
+	assert.NoError(err)
+	assert.NotNil(response)
+
+	data, err := json.MarshalIndent(response, "", "  ")
+	assert.NoError(err)
+	t.Log(string(data))
+}

pkg/openai/embedding.go

@@ -0,0 +1,44 @@
+package openai
+
+import (
+	"net/http"
+
+	// Packages
+	"github.com/mutablelogic/go-client/pkg/client"
+)
+
+///////////////////////////////////////////////////////////////////////////////
+// SCHEMA
+
+type Embedding struct {
+	Object    string    `json:"object"`
+	Embedding []float32 `json:"embedding"`
+	Index     int       `json:"index"`
+}
+
+type EmbeddingResponse struct {
+	Object string      `json:"object"`
+	Data   []Embedding `json:"data"`
+	Model  string      `json:"model"`
+}
+
+///////////////////////////////////////////////////////////////////////////////
+// REQUEST AND RESPONSE
+
+type embeddingRequest struct {
+	Content        string `json:"input"`
+	Model          string `json:"model"`
+	EncodingFormat string `json:"encoding_format"`
+}
+
+func (r embeddingRequest) Method() string {
+	return http.MethodPost
+}
+
+func (r embeddingRequest) Type() string {
+	return client.ContentTypeJson
+}
+
+func (r embeddingRequest) Accept() string {
+	return client.ContentTypeJson
+}