Merge pull request #19 from mutablelogic/v1

Updated command and added weatherapi

Author: djthorpe

README.md

@@ -22,6 +22,7 @@ There are also some example clients which use this library:
 * [NewsAPI client](https://github.com/mutablelogic/go-client/tree/main/pkg/newsapi)
 * [Ollama API client](https://github.com/mutablelogic/go-client/tree/main/pkg/ollama) for locally-hosted LLM's
 * [OpenAI API client](https://github.com/mutablelogic/go-client/tree/main/pkg/openai) for OpenAI LLM's
+* [WeatherAPI client](https://github.com/mutablelogic/go-client/tree/main/pkg/weatherapi)
 
 Aiming to have compatibility with go version 1.21 and above.
 

cmd/api/cmd.go

@@ -29,7 +29,32 @@ type Fn struct {
 ///////////////////////////////////////////////////////////////////////////////
 // PUBLIC METHODS
 
-func (c *Cmd) Get(args []string) (*Fn, []string, error) {
+func (c *Cmd) Get(name string) *Fn {
+	for _, fn := range c.Fn {
+		if fn.Name == name {
+			return &fn
+		}
+	}
+	return nil
+}
+
+func (fn *Fn) CheckArgs(args []string) error {
+	// Check number of arguments
+	if fn.MinArgs != 0 && uint(len(args)) < fn.MinArgs {
+		return fmt.Errorf("not enough arguments for %q (expected >= %d)", fn.Name, fn.MinArgs)
+	}
+	if fn.MaxArgs != 0 && uint(len(args)) > fn.MaxArgs {
+		return fmt.Errorf("too many arguments for %q  (expected <= %d)", fn.Name, fn.MaxArgs)
+	}
+	return nil
+}
+
+/*
+	if fn == nil {
+		return nil, fmt.Errorf("unknown command %q", name)
+	}
+
+	return c.getFn(name), nil
 	// Get the command function
 	var fn *Fn
 	var nargs uint
@@ -47,25 +72,18 @@ func (c *Cmd) Get(args []string) (*Fn, []string, error) {
 	}
 
 	// Check number of arguments
+	name := fn.Name
+	if name == "" {
+		name = c.Name
+	}
 	if fn.MinArgs != 0 && nargs < fn.MinArgs {
-		return nil, nil, fmt.Errorf("not enough arguments for %q", fn.Name)
+		return nil, nil, fmt.Errorf("not enough arguments for %q", name)
 	}
 	if fn.MaxArgs != 0 && nargs > fn.MaxArgs {
-		return nil, nil, fmt.Errorf("too many arguments for %q", fn.Name)
+		return nil, nil, fmt.Errorf("too many arguments for %q", name)
 	}
 
 	// Return the command
 	return fn, out, nil
 }
-
-///////////////////////////////////////////////////////////////////////////////
-// PRIVATE METHODS
-
-func (c *Cmd) getFn(name string) *Fn {
-	for _, fn := range c.Fn {
-		if fn.Name == name {
-			return &fn
-		}
-	}
-	return nil
-}
+*/

cmd/api/flags.go

@@ -23,6 +23,7 @@ type Flags struct {
 	cmds  []Cmd
 	cmd   *Cmd
 	root  string
+	fn    string
 	args  []string
 	names map[string]*Value
 }
@@ -92,15 +93,17 @@ func (flags *Flags) Parse(args []string) (*Fn, []string, error) {
 		}
 	}
 
-	// If the name of the command is the same as the name of the application
 	if cmd := flags.getCommandSet(flags.Name()); cmd != nil {
+		// If the name of the command is the same as the name of the application
 		flags.cmd = cmd
 		flags.root = cmd.Name
+		flags.fn = ""
 		flags.args = flags.Args()
 	} else if flags.NArg() > 0 {
 		if cmd := flags.getCommandSet(flags.Arg(0)); cmd != nil {
 			flags.cmd = cmd
 			flags.root = strings.Join([]string{flags.Name(), cmd.Name}, " ")
+			flags.fn = flags.Arg(1)
 			flags.args = flags.Args()[1:]
 		}
 	}
@@ -135,15 +138,18 @@ func (flags *Flags) Parse(args []string) (*Fn, []string, error) {
 	}
 
 	// Set the function to call
-	fn, args, err := flags.cmd.Get(flags.args)
-	if err != nil {
-		fmt.Fprintf(os.Stderr, "%v: %v\n", flags.cmd.Name, err)
-		return nil, nil, err
-	} else if fn == nil {
-		fmt.Fprintln(os.Stderr, "Unknown command, try -help")
+	fn := flags.cmd.Get(flags.fn)
+	if fn == nil {
+		fmt.Fprintf(os.Stderr, "Unknown command %q, try -help\n", flags.fn)
 		return nil, nil, ErrHelp
 	}
 
+	// Check the number of arguments
+	if err := fn.CheckArgs(flags.args); err != nil {
+		fmt.Fprintln(os.Stderr, err)
+		return nil, nil, err
+	}
+
 	// Return success
 	return fn, args, nil
 }

cmd/api/install.go

@@ -7,14 +7,18 @@ import (
 	"path/filepath"
 )
 
-func install(path, name string, flags *Flags) error {
+func install(flags *Flags) error {
 	var info os.FileInfo
+	var path string
 
-	// stat the api binary
-	if v, err := os.Stat(filepath.Join(path, name)); err != nil {
+	exec, err := os.Executable()
+	if err != nil {
+		return err
+	} else if v, err := os.Stat(exec); err != nil {
 		return err
 	} else {
 		info = v
+		path = filepath.Dir(exec)
 	}
 
 	// check for an existing symlink
@@ -31,7 +35,7 @@ func install(path, name string, flags *Flags) error {
 			result = errors.Join(result, fmt.Errorf("failed to install %q: %w", cmd.Name, err))
 		}
 		// Make symlink
-		if err := os.Symlink(filepath.Join(path, name), filepath.Join(path, cmd.Name)); err != nil {
+		if err := os.Symlink(exec, filepath.Join(path, cmd.Name)); err != nil {
 			result = errors.Join(result, fmt.Errorf("failed to install %q: %w", cmd.Name, err))
 		}
 	}

cmd/api/main.go

@@ -14,23 +14,22 @@ import (
 )
 
 func main() {
-	name := path.Base(os.Args[0])
-	path := path.Dir(os.Args[0])
-	flags := NewFlags(name)
+	flags := NewFlags(path.Base(os.Args[0]))
 
 	// Register commands
 	ipifyRegister(flags)
 	bwRegister(flags)
-	newsapiRegister(flags)
 	anthropicRegister(flags)
+	newsapiRegister(flags)
+	weatherapiRegister(flags)
 
 	// Parse command line and return function to run
 	fn, args, err := flags.Parse(os.Args[1:])
 	if errors.Is(err, ErrHelp) {
 		os.Exit(0)
 	}
 	if errors.Is(err, ErrInstall) {
-		if err := install(path, name, flags); err != nil {
+		if err := install(flags); err != nil {
 			fmt.Fprintln(os.Stderr, err)
 			os.Exit(-2)
 		}

cmd/api/weatherapi.go

@@ -0,0 +1,75 @@
+package main
+
+import (
+	"context"
+	"fmt"
+
+	"github.com/djthorpe/go-tablewriter"
+	"github.com/mutablelogic/go-client"
+	"github.com/mutablelogic/go-client/pkg/weatherapi"
+)
+
+///////////////////////////////////////////////////////////////////////////////
+// GLOBALS
+
+var (
+	weatherapiName   = "weatherapi"
+	weatherapiClient *weatherapi.Client
+)
+
+///////////////////////////////////////////////////////////////////////////////
+// LIFECYCLE
+
+func weatherapiRegister(flags *Flags) {
+	// Register flags required
+	flags.String(newsapiName, "weatherapi-key", "${WEATHERAPI_KEY}", "API Key")
+
+	flags.Register(Cmd{
+		Name:        weatherapiName,
+		Description: "Obtain weather information from https://www.weatherapi.com/",
+		Parse:       weatherapiParse,
+		Fn: []Fn{
+			{Call: weatherapiCurrent, Description: "Return current weather, given city, zip code, IP address or lat,long", MaxArgs: 1},
+		},
+	})
+}
+
+func weatherapiParse(flags *Flags, opts ...client.ClientOpt) error {
+	apiKey := flags.GetString("weatherapi-key")
+	if apiKey == "" {
+		return fmt.Errorf("missing -weatherapi-key flag")
+	}
+	if client, err := weatherapi.New(apiKey, opts...); err != nil {
+		return err
+	} else {
+		weatherapiClient = client
+	}
+
+	// Return success
+	return nil
+}
+
+///////////////////////////////////////////////////////////////////////////////
+// METHODS
+
+func weatherapiCurrent(_ context.Context, w *tablewriter.Writer, args []string) error {
+	var q string
+	if len(args) == 1 {
+		q = args[0]
+	} else {
+		q = "auto:ip"
+	}
+
+	// Request -> Response
+	weather, err := weatherapiClient.Current(q)
+	if err != nil {
+		return err
+	}
+
+	// Write table
+	w.Write(weather.Location)
+	w.Write(weather.Current)
+
+	// Return success
+	return nil
+}

pkg/weatherapi/client.go

@@ -0,0 +1,75 @@
+/*
+weatherapi implements an API client for WeatherAPI (https://www.weatherapi.com/docs/)
+*/
+package weatherapi
+
+import (
+	// Packages
+	"net/url"
+
+	"github.com/mutablelogic/go-client"
+
+	// Namespace imports
+	. "github.com/djthorpe/go-errors"
+)
+
+///////////////////////////////////////////////////////////////////////////////
+// TYPES
+
+type Client struct {
+	*client.Client
+	key string
+}
+
+///////////////////////////////////////////////////////////////////////////////
+// GLOBALS
+
+const (
+	endPoint = "https://api.weatherapi.com/v1"
+)
+
+///////////////////////////////////////////////////////////////////////////////
+// LIFECYCLE
+
+// Create a new client
+func New(ApiKey string, opts ...client.ClientOpt) (*Client, error) {
+	// Check for missing API key
+	if ApiKey == "" {
+		return nil, ErrBadParameter.With("missing API key")
+	}
+	// Create client
+	opts = append(opts, client.OptEndpoint(endPoint))
+	client, err := client.New(opts...)
+	if err != nil {
+		return nil, err
+	}
+
+	// Return the client
+	return &Client{
+		Client: client,
+		key:    ApiKey,
+	}, nil
+}
+
+///////////////////////////////////////////////////////////////////////////////
+// PUBLIC METHODS
+
+// Current weather
+func (c *Client) Current(q string) (Weather, error) {
+	var response Weather
+
+	// Set defaults
+	response.Query = q
+
+	// Set query parameters
+	query := url.Values{}
+	query.Set("key", c.key)
+	query.Set("q", q)
+
+	// Request -> Response
+	if err := c.Do(nil, &response, client.OptPath("current.json"), client.OptQuery(query)); err != nil {
+		return Weather{}, err
+	} else {
+		return response, nil
+	}
+}

pkg/weatherapi/client_test.go

@@ -0,0 +1,43 @@
+package weatherapi_test
+
+import (
+	"os"
+	"testing"
+
+	// Packages
+	opts "github.com/mutablelogic/go-client"
+	weatherapi "github.com/mutablelogic/go-client/pkg/weatherapi"
+	assert "github.com/stretchr/testify/assert"
+)
+
+func Test_client_001(t *testing.T) {
+	assert := assert.New(t)
+	client, err := weatherapi.New(GetApiKey(t), opts.OptTrace(os.Stderr, true))
+	assert.NoError(err)
+	assert.NotNil(client)
+	t.Log(client)
+}
+
+func Test_client_002(t *testing.T) {
+	assert := assert.New(t)
+	client, err := weatherapi.New(GetApiKey(t), opts.OptTrace(os.Stderr, true))
+	assert.NoError(err)
+
+	weather, err := client.Current("Berlin, Germany")
+	if !assert.NoError(err) {
+		t.SkipNow()
+	}
+	t.Log(weather)
+}
+
+///////////////////////////////////////////////////////////////////////////////
+// ENVIRONMENT
+
+func GetApiKey(t *testing.T) string {
+	key := os.Getenv("WEATHERAPI_KEY")
+	if key == "" {
+		t.Skip("WEATHERAPI_KEY not set")
+		t.SkipNow()
+	}
+	return key
+}