pb: github.com/cheggaaa/pb/v3 Index | Files | Directories

package pb

import "github.com/cheggaaa/pb/v3"

Index

Package Files

element.go io.go pb.go preset.go speed.go template.go util.go

Constants

const (
    // Bytes means we're working with byte sizes. Numbers will print as Kb, Mb, etc
    // bar.Set(pb.Bytes, true)
    Bytes key = 1 << iota

    // Terminal means we're will print to terminal and can use ascii sequences
    // Also we're will try to use terminal width
    Terminal

    // Static means progress bar will not update automaticly
    Static

    // ReturnSymbol - by default in terminal mode it's '\r'
    ReturnSymbol

    // Color by default is true when output is tty, but you can set to false for disabling colors
    Color
)
const Version = "3.0.1"

Version of ProgressBar library

func CellCount Uses

func CellCount(s string) int

func RegisterElement Uses

func RegisterElement(name string, el Element, adaptive bool)

RegisterElement give you a chance to use custom elements

func StripString Uses

func StripString(s string, w int) string

func StripStringToBuffer Uses

func StripStringToBuffer(s string, w int, buf *bytes.Buffer)

type Element Uses

type Element interface {
    ProgressElement(state *State, args ...string) string
}

Element is an interface for bar elements

type ElementFunc Uses

type ElementFunc func(state *State, args ...string) string

ElementFunc type implements Element interface and created for simplify elements

var ElementBar ElementFunc = func(state *State, args ...string) string {
    // init
    var p = getProgressObj(state, args...)

    total, value := state.Total(), state.Value()
    if total < 0 {
        total = -total
    }
    if value < 0 {
        value = -value
    }

    if total != 0 && value > total {
        total = value
    }

    p.buf.Reset()

    var widthLeft = state.AdaptiveElWidth()
    if widthLeft <= 0 || !state.IsAdaptiveWidth() {
        widthLeft = 30
    }

    if p.cc[0] < widthLeft {
        widthLeft -= p.write(state, 0, p.cc[0])
    } else {
        p.write(state, 0, widthLeft)
        return p.buf.String()
    }

    if p.cc[4] < widthLeft {

        widthLeft -= p.cc[4]
    } else {
        p.write(state, 4, widthLeft)
        return p.buf.String()
    }

    var curCount int

    if total > 0 {

        curCount = int(math.Ceil((float64(value) / float64(total)) * float64(widthLeft)))
    }

    if total == value && state.IsFinished() {
        widthLeft -= p.write(state, 1, curCount)
    } else if toWrite := curCount - p.cc[2]; toWrite > 0 {
        widthLeft -= p.write(state, 1, toWrite)
        widthLeft -= p.write(state, 2, p.cc[2])
    } else if curCount > 0 {
        widthLeft -= p.write(state, 2, curCount)
    }
    if widthLeft > 0 {
        widthLeft -= p.write(state, 3, widthLeft)
    }

    p.write(state, 4, p.cc[4])

    return p.buf.String()
}

ElementBar make progress bar view [-->__] Optionally can take up to 5 string arguments. Defaults is "[", "-", ">", "_", "]" In template use as follows: {{bar . }} or {{bar . "<" "oOo" "|" "~" ">"}} Color args: {{bar . (red "[") (green "-") ...

var ElementCounters ElementFunc = func(state *State, args ...string) string {
    var f string
    if state.Total() > 0 {
        f = argsHelper(args).getNotEmptyOr(0, "%s / %s")
    } else {
        f = argsHelper(args).getNotEmptyOr(1, "%[1]s")
    }
    return fmt.Sprintf(f, state.Format(state.Value()), state.Format(state.Total()))
}

ElementCounters shows current and total values. Optionally can take one or two string arguments. First string will be used as format value when Total is present (>0). Default is "%s / %s" Second string will be used when total <= 0. Default is "%[1]s" In template use as follows: {{counters .}} or {{counters . "%s/%s"}} or {{counters . "%s/%s" "%s/?"}}

var ElementCycle ElementFunc = func(state *State, args ...string) string {
    if len(args) == 0 {
        return ""
    }
    n, _ := state.Get(cycleObj).(int)
    if n >= len(args) {
        n = 0
    }
    state.Set(cycleObj, n+1)
    return args[n]
}

ElementCycle return next argument for every call In template use as follows: {{cycle . "1" "2" "3"}} Or mix width other elements: {{ bar . "" "" (cycle . "↖" "↗" "↘" "↙" )}}

var ElementElapsedTime ElementFunc = func(state *State, args ...string) string {
    etm := state.Time().Truncate(time.Second).Sub(state.StartTime().Truncate(time.Second))
    return fmt.Sprintf(argsHelper(args).getOr(0, "%s"), etm.String())
}

ElementElapsedTime shows elapsed time Optionally cat take one argument - it's format for time string. In template use as follows: {{etime .}} or {{etime . "%s elapsed"}}

var ElementPercent ElementFunc = func(state *State, args ...string) string {
    argsh := argsHelper(args)
    if state.Total() > 0 {
        return fmt.Sprintf(
            argsh.getNotEmptyOr(0, "%.02f%%"),
            float64(state.Value())/(float64(state.Total())/float64(100)),
        )
    }
    return argsh.getOr(1, "?%")
}

ElementPercent shows current percent of progress. Optionally can take one or two string arguments. First string will be used as value for format float64, default is "%.02f%%". Second string will be used when percent can't be calculated, default is "?%" In template use as follows: {{percent .}} or {{percent . "%.03f%%"}} or {{percent . "%.03f%%" "?"}}

var ElementRemainingTime ElementFunc = func(state *State, args ...string) string {
    var rts string
    sp := getSpeedObj(state).value(state)
    if !state.IsFinished() {
        if sp > 0 {
            remain := float64(state.Total() - state.Value())
            remainDur := time.Duration(remain/sp) * time.Second
            rts = remainDur.String()
        } else {
            return argsHelper(args).getOr(2, "?")
        }
    } else {
        rts = state.Time().Truncate(time.Second).Sub(state.StartTime().Truncate(time.Second)).String()
        return fmt.Sprintf(argsHelper(args).getOr(1, "%s"), rts)
    }
    return fmt.Sprintf(argsHelper(args).getOr(0, "%s"), rts)
}

ElementRemainingTime calculates remaining time based on speed (EWMA) Optionally can take one or two string arguments. First string will be used as value for format time duration string, default is "%s". Second string will be used when bar finished and value indicates elapsed time, default is "%s" Third string will be used when value not available, default is "?" In template use as follows: {{rtime .}} or {{rtime . "%s remain"}} or {{rtime . "%s remain" "%s total" "???"}}

var ElementSpeed ElementFunc = func(state *State, args ...string) string {
    sp := getSpeedObj(state).value(state)
    if sp == 0 {
        return argsHelper(args).getNotEmptyOr(1, "? p/s")
    }
    return fmt.Sprintf(argsHelper(args).getNotEmptyOr(0, "%s p/s"), state.Format(int64(round(sp))))
}

ElementSpeed calculates current speed by EWMA Optionally can take one or two string arguments. First string will be used as value for format speed, default is "%s p/s". Second string will be used when speed not available, default is "? p/s" In template use as follows: {{speed .}} or {{speed . "%s per second"}} or {{speed . "%s ps" "..."}

var ElementString ElementFunc = func(state *State, args ...string) string {
    if len(args) == 0 {
        return ""
    }
    v := state.Get(args[0])
    if v == nil {
        return ""
    }
    return fmt.Sprint(v)
}

ElementString get value from bar by given key and print them bar.Set("myKey", "string to print") In template use as follows: {{string . "myKey"}}

func (ElementFunc) ProgressElement Uses

func (e ElementFunc) ProgressElement(state *State, args ...string) string

ProgressElement just call self func

type ProgressBar Uses

type ProgressBar struct {
    // contains filtered or unexported fields
}

ProgressBar is the main object of bar

func New Uses

func New(total int) *ProgressBar

New creates new ProgressBar object

func New64 Uses

func New64(total int64) *ProgressBar

New64 creates new ProgressBar object using int64 as total

func Start64 Uses

func Start64(total int64) *ProgressBar

Start64 starts new ProgressBar with Default template. Using int64 as total.

func StartNew Uses

func StartNew(total int) *ProgressBar

StartNew starts new ProgressBar with Default template

func (*ProgressBar) Add Uses

func (pb *ProgressBar) Add(value int) *ProgressBar

Add adding given int value to bar value

func (*ProgressBar) Add64 Uses

func (pb *ProgressBar) Add64(value int64) *ProgressBar

Add adding given int64 value to bar value

func (*ProgressBar) Current Uses

func (pb *ProgressBar) Current() int64

Current return current bar value

func (*ProgressBar) Err Uses

func (pb *ProgressBar) Err() error

Err return possible error When all ok - will be nil May contain template.Execute errors

func (*ProgressBar) Finish Uses

func (pb *ProgressBar) Finish() *ProgressBar

Finish stops the bar

func (*ProgressBar) Format Uses

func (pb *ProgressBar) Format(v int64) string

Format convert int64 to string according to the current settings

func (*ProgressBar) Get Uses

func (pb *ProgressBar) Get(key interface{}) interface{}

Get return value by key

func (*ProgressBar) GetBool Uses

func (pb *ProgressBar) GetBool(key interface{}) bool

GetBool return value by key and try to convert there to boolean If value doesn't set or not boolean - return false

func (*ProgressBar) Increment Uses

func (pb *ProgressBar) Increment() *ProgressBar

Increment atomically increments the progress

func (*ProgressBar) IsStarted Uses

func (pb *ProgressBar) IsStarted() bool

IsStarted indicates progress bar state

func (*ProgressBar) NewProxyReader Uses

func (pb *ProgressBar) NewProxyReader(r io.Reader) *Reader

NewProxyReader creates a wrapper for given reader, but with progress handle Takes io.Reader or io.ReadCloser Also, it automatically switches progress bar to handle units as bytes

func (*ProgressBar) NewProxyWriter Uses

func (pb *ProgressBar) NewProxyWriter(r io.Writer) *Writer

NewProxyWriter creates a wrapper for given writer, but with progress handle Takes io.Writer or io.WriteCloser Also, it automatically switches progress bar to handle units as bytes

func (*ProgressBar) ProgressElement Uses

func (pb *ProgressBar) ProgressElement(s *State, args ...string) string

ProgressElement implements Element interface

func (*ProgressBar) Set Uses

func (pb *ProgressBar) Set(key, value interface{}) *ProgressBar

Set sets any value by any key

func (*ProgressBar) SetCurrent Uses

func (pb *ProgressBar) SetCurrent(value int64) *ProgressBar

SetCurrent sets the current bar value

func (*ProgressBar) SetErr Uses

func (pb *ProgressBar) SetErr(err error) *ProgressBar

SetErr sets error to the ProgressBar Error will be available over Err()

func (*ProgressBar) SetRefreshRate Uses

func (pb *ProgressBar) SetRefreshRate(dur time.Duration) *ProgressBar

func (*ProgressBar) SetTemplate Uses

func (pb *ProgressBar) SetTemplate(tmpl ProgressBarTemplate) *ProgressBar

SetTemplateString sets ProgressBarTempate and parse it

func (*ProgressBar) SetTemplateString Uses

func (pb *ProgressBar) SetTemplateString(tmpl string) *ProgressBar

SetTemplateString sets ProgressBar tempate string and parse it

func (*ProgressBar) SetTotal Uses

func (pb *ProgressBar) SetTotal(value int64) *ProgressBar

SetTotal sets the total bar value

func (*ProgressBar) SetWidth Uses

func (pb *ProgressBar) SetWidth(width int) *ProgressBar

SetWidth sets the bar width When given value <= 0 would be using the terminal width (if possible) or default value.

func (*ProgressBar) SetWriter Uses

func (pb *ProgressBar) SetWriter(w io.Writer) *ProgressBar

SetWriter sets the io.Writer. Bar will write in this writer By default this is os.Stderr

func (*ProgressBar) Start Uses

func (pb *ProgressBar) Start() *ProgressBar

Start starts the bar

func (*ProgressBar) StartTime Uses

func (pb *ProgressBar) StartTime() time.Time

StartTime return the time when bar started

func (*ProgressBar) String Uses

func (pb *ProgressBar) String() string

String return currrent string representation of ProgressBar

func (*ProgressBar) Total Uses

func (pb *ProgressBar) Total() int64

Total return current total bar value

func (*ProgressBar) Width Uses

func (pb *ProgressBar) Width() (width int)

Width return the bar width It's current terminal width or settled over 'SetWidth' value.

func (*ProgressBar) Write Uses

func (pb *ProgressBar) Write() *ProgressBar

Write performs write to the output

type ProgressBarTemplate Uses

type ProgressBarTemplate string

ProgressBarTemplate that template string

var (
    // Full - preset with all default available elements
    // Example: 'Prefix 20/100 [-->______] 20% 1 p/s ETA 1m Suffix'
    Full ProgressBarTemplate = `{{string . "prefix"}}{{counters . }} {{bar . }} {{percent . }} {{speed . }} {{rtime . "ETA %s"}}{{string . "suffix"}}`

    // Default - preset like Full but without elapsed time
    // Example: 'Prefix 20/100 [-->______] 20% 1 p/s ETA 1m Suffix'
    Default ProgressBarTemplate = `{{string . "prefix"}}{{counters . }} {{bar . }} {{percent . }} {{speed . }}{{string . "suffix"}}`

    // Simple - preset without speed and any timers. Only counters, bar and percents
    // Example: 'Prefix 20/100 [-->______] 20% Suffix'
    Simple ProgressBarTemplate = `{{string . "prefix"}}{{counters . }} {{bar . }} {{percent . }}{{string . "suffix"}}`
)

func (ProgressBarTemplate) New Uses

func (pbt ProgressBarTemplate) New(total int) *ProgressBar

New creates new bar from template

func (ProgressBarTemplate) Start Uses

func (pbt ProgressBarTemplate) Start(total int) *ProgressBar

Start create and start new bar with given int total value

func (ProgressBarTemplate) Start64 Uses

func (pbt ProgressBarTemplate) Start64(total int64) *ProgressBar

Start64 create and start new bar with given int64 total value

type Reader Uses

type Reader struct {
    io.Reader
    // contains filtered or unexported fields
}

Reader it's a wrapper for given reader, but with progress handle

func (*Reader) Close Uses

func (r *Reader) Close() (err error)

Close the wrapped reader when it implements io.Closer

func (*Reader) Read Uses

func (r *Reader) Read(p []byte) (n int, err error)

Read reads bytes from wrapped reader and add amount of bytes to progress bar

type State Uses

type State struct {
    *ProgressBar
    // contains filtered or unexported fields
}

State represents the current state of bar Need for bar elements

func (*State) AdaptiveElWidth Uses

func (s *State) AdaptiveElWidth() int

AdaptiveElWidth - adaptive elements must return string with given cell count (when AdaptiveElWidth > 0)

func (*State) Id Uses

func (s *State) Id() uint64

Id it's the current state identifier - incremental - starts with 1 - resets after finish/start

func (*State) IsAdaptiveWidth Uses

func (s *State) IsAdaptiveWidth() bool

IsAdaptiveWidth returns true when element must be shown as adaptive

func (*State) IsFinished Uses

func (s *State) IsFinished() bool

IsFinished return true when bar is finished

func (*State) IsFirst Uses

func (s *State) IsFirst() bool

IsFirst return true only in first render

func (*State) Time Uses

func (s *State) Time() time.Time

Time when state was created

func (*State) Total Uses

func (s *State) Total() int64

Total it's bar int64 total

func (*State) Value Uses

func (s *State) Value() int64

Value it's current value

func (*State) Width Uses

func (s *State) Width() int

Width of bar

type Writer Uses

type Writer struct {
    io.Writer
    // contains filtered or unexported fields
}

Writer it's a wrapper for given writer, but with progress handle

func (*Writer) Close Uses

func (r *Writer) Close() (err error)

Close the wrapped reader when it implements io.Closer

func (*Writer) Write Uses

func (r *Writer) Write(p []byte) (n int, err error)

Write writes bytes to wrapped writer and add amount of bytes to progress bar

Directories

PathSynopsis
termutil

Package pb imports 19 packages (graph) and is imported by 7 packages. Updated 2019-07-02. Refresh now. Tools for package owners.