Go系列：cobra命令

for _, cmd := range RootCmd.Commands() {
    cmd.Flags().SetNormalizeFunc(func(f *pflag.FlagSet, name string) pflag.NormalizedName {
        return pflag.NormalizedName(strings.ReplaceAll(name, "_", "-"))
    })
}

parser.add_argument('--admin_state_up', choices=['True', 'False', 'true', 'false'], help=_('admin state of agent'))

type AdminStateUp string

var Choices = []string{"True", "true", "False", "false"}

func (f *AdminStateUp) Set(value string) error {
	for _, choice := range Choices {
		if value == choice {
			*f = AdminStateUp(choice)
		}
	}
	return fmt.Errorf("%s is ivalid, choice=%v", value, Choices)
}

func (f *AdminStateUp) String() string {
	return fmt.Sprintf("%v", *f)
}

func (f *AdminStateUp) Type() string {
	return "string"
}

adminStateUp := AdminStateUp("")
RootCmd.Flags().Var(&adminStateUp, "admin-state-up", "set admin state up")

Error: invalid argument "TRue" for "--admin-state-up" flag: TRue is ivalid, choice=[True true False false]

SetUsageTemplate

output formatters:
  output formatter options

  -f {csv,json,table,value,yaml}, --format {csv,json,table,value,yaml}
                        the output format, defaults to table

CSV Formatter:
  --quote {all,minimal,none,nonnumeric}
                        when to include quotes, defaults to nonnumeric

package main

import (
	"fmt"
	"os"
	"strings"
	"unicode"

	"github.com/spf13/cobra"
	"github.com/spf13/pflag"
)

type NameFlagSet struct {
	name string
	desc string
	fs   *pflag.FlagSet
}

var nameFlagSets []NameFlagSet

func main() {

	RootCmd := &cobra.Command{
		Use:   "hello",
		Short: fmt.Sprintf("Commands for Hello"),
		PersistentPreRun: func(cmd *cobra.Command, args []string) {
			if cmd.Flags().Changed("version") {
				os.Exit(0)
			}

		},
		Run: func(cmd *cobra.Command, args []string) {
			cmd.Help()
		},
		SilenceUsage: true,
	}

	fs1 := pflag.NewFlagSet("output formatters", pflag.ExitOnError)
	fs1.StringP("format", "p", "json", "the output format, defaults to table")

	fs2 := pflag.NewFlagSet("cvs formatter", pflag.ExitOnError)
	fs2.String("quote", "", "when to include quotes, defaults to nonnumeric")

	RootCmd.Flags().AddFlagSet(fs1)
	RootCmd.Flags().AddFlagSet(fs2)

	nameFlagSets = append(nameFlagSets, NameFlagSet{
		name: "output formatters",
		desc: "output formatter options",
		fs:   fs1,
	})
	nameFlagSets = append(nameFlagSets, NameFlagSet{
		name: "CSV Formatter",
		fs:   fs2,
	})

	RootCmd.SetUsageFunc(func(cmd *cobra.Command) error {
		if cmd == nil {
			return fmt.Errorf("nil command")
		}

		usage := []string{fmt.Sprintf("Usage: %s", cmd.UseLine())}

		if cmd.HasAvailableSubCommands() {
			usage = append(usage, "\nCommands:")
			for _, subCommand := range cmd.Commands() {
				usage = append(usage, fmt.Sprintf("  %-10s  %s", subCommand.Name(), subCommand.Short))
			}
		}

		for _, nfs := range nameFlagSets {
			usage = append(usage, fmt.Sprintf("\n\033[4m%s:\033[0m", nfs.name))
			if nfs.desc != "" {
				usage = append(usage, fmt.Sprintf("  %s", nfs.desc))
			}
			usage = append(usage, strings.TrimRightFunc(nfs.fs.FlagUsages(), unicode.IsSpace))
		}

		usage = append(usage,
			fmt.Sprintf("\nUse '%s [command] --help' for more information about a command.\n",
				cmd.CommandPath()))

		cmd.Println(strings.Join(usage, "\n"))

		return nil
	})

	if err := RootCmd.Execute(); err != nil {
		os.Exit(1)
	}
}

Usage: hello [flags]

output formatters:
  output formatter options
  -p, --format string   the output format, defaults to table (default "json")

CSV Formatter:
      --quote string   when to include quotes, defaults to nonnumeric

Use 'hello [command] --help' for more information about a command.