Commit 0588ea3db913790a5c8d37c37d8efd81fb965e8c - golang-github-vbauerster-mpb

+4

-10

.travis.yml less more

0	0	language: go
1		sudo: false
	1
2	2	go:
3		- 1.10.x
4		- tip
5
6		before_install:
7		- go get -t -v ./...
	3	- 1.14.x
8	4
9	5	script:
10		- go test -race -coverprofile=coverage.txt -covermode=atomic
11
12		after_success:
13		- bash <(curl -s https://codecov.io/bash)
	6	- go test -race ./...
	7	- for i in _examples//; do go build $i/.go \|\| exit 1; done

+0

-29

~~LICENSE~~ less more

0		BSD 3-Clause License
1
2		Copyright (C) 2016-2018 Vladimir Bauer
3		All rights reserved.
4
5		Redistribution and use in source and binary forms, with or without
6		modification, are permitted provided that the following conditions are met:
7
8		* Redistributions of source code must retain the above copyright notice, this
9		list of conditions and the following disclaimer.
10
11		* Redistributions in binary form must reproduce the above copyright notice,
12		this list of conditions and the following disclaimer in the documentation
13		and/or other materials provided with the distribution.
14
15		* Neither the name of the copyright holder nor the names of its
16		contributors may be used to endorse or promote products derived from
17		this software without specific prior written permission.
18
19		THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
20		AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
21		IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
22		DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
23		FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
24		DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
25		SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
26		CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
27		OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
28		OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

+36

-35

README.md less more

2	2	[![GoDoc](https://godoc.org/github.com/vbauerster/mpb?status.svg)](https://godoc.org/github.com/vbauerster/mpb)
3	3	[![Build Status](https://travis-ci.org/vbauerster/mpb.svg?branch=master)](https://travis-ci.org/vbauerster/mpb)
4	4	[![Go Report Card](https://goreportcard.com/badge/github.com/vbauerster/mpb)](https://goreportcard.com/report/github.com/vbauerster/mpb)
5		[![codecov](https://codecov.io/gh/vbauerster/mpb/branch/master/graph/badge.svg)](https://codecov.io/gh/vbauerster/mpb)
6	5
7	6	mpb is a Go lib for rendering progress bars in terminal applications.
8	7
9	8	## Features
10	9
11	10	* __Multiple Bars__: Multiple progress bars are supported
12		* __Dynamic Total__: [Set total](https://github.com/vbauerster/mpb/issues/9#issuecomment-344448984) while bar is running
	11	* __Dynamic Total__: Set total while bar is running
13	12	* __Dynamic Add/Remove__: Dynamically add or remove bars
14	13	* __Cancellation__: Cancel whole rendering process
15	14	* __Predefined Decorators__: Elapsed time, [ewma](https://github.com/VividCortex/ewma) based ETA, Percentage, Bytes counter
16	15	* __Decorator's width sync__: Synchronized decorator's width among multiple bars
17	16
18		## Installation
19
20		```sh
21		go get github.com/vbauerster/mpb
22		```
23
24		_Note:_ it is preferable to go get from github.com, rather than gopkg.in. See issue [#11](https://github.com/vbauerster/mpb/issues/11).
25
26	17	## Usage
27	18
28		#### [Rendering single bar](examples/singleBar/main.go)
	19	#### [Rendering single bar](_examples/singleBar/main.go)
29	20	```go
30		p := mpb.New(
31		// override default (80) width
32		mpb.WithWidth(64),
33		// override default 120ms refresh rate
34		mpb.WithRefreshRate(180*time.Millisecond),
35		)
	21	package main
	22
	23	import (
	24	"math/rand"
	25	"time"
	26
	27	"github.com/vbauerster/mpb/v5"
	28	"github.com/vbauerster/mpb/v5/decor"
	29	)
	30
	31	func main() {
	32	// initialize progress container, with custom width
	33	p := mpb.New(mpb.WithWidth(64))
36	34
37	35	total := 100
38	36	name := "Single Bar:"
39		// adding a single bar
	37	// adding a single bar, which will inherit container's width
40	38	bar := p.AddBar(int64(total),
41		// override default "[=>-]" style
	39	// override DefaultBarStyle, which is "[=>-]<+"
42	40	mpb.BarStyle("╢▌▌░╟"),
43	41	mpb.PrependDecorators(
44	42	// display our name with one space on the right
45	43	decor.Name(name, decor.WC{W: len(name) + 1, C: decor.DidentRight}),
46	44	// replace ETA decorator with "done" message, OnComplete event
47	45	decor.OnComplete(
48		// ETA decorator with ewma age of 60, and width reservation of 4
49		decor.EwmaETA(decor.ET_STYLE_GO, 60, decor.WC{W: 4}), "done",
	46	decor.AverageETA(decor.ET_STYLE_GO, decor.WC{W: 4}), "done",
50	47	),
51	48	),
52	49	mpb.AppendDecorators(decor.Percentage()),

54	51	// simulating some work
55	52	max := 100 * time.Millisecond
56	53	for i := 0; i < total; i++ {
57		start := time.Now()
58	54	time.Sleep(time.Duration(rand.Intn(10)+1) * max / 10)
59		// ewma based decorators require work duration measurement
60		bar.IncrBy(1, time.Since(start))
	55	bar.Increment()
61	56	}
62	57	// wait for our bar to complete and flush
63	58	p.Wait()
	59	}
64	60	```
65	61
66		#### [Rendering multiple bars](examples/simple/main.go)
	62	#### [Rendering multiple bars](_examples/multiBars/main.go)
67	63	```go
68	64	var wg sync.WaitGroup
	65	// pass &wg (optional), so p will wait for it eventually
69	66	p := mpb.New(mpb.WithWaitGroup(&wg))
70	67	total, numBars := 100, 3
71	68	wg.Add(numBars)

90	87	// simulating some work
91	88	go func() {
92	89	defer wg.Done()
	90	rng := rand.New(rand.NewSource(time.Now().UnixNano()))
93	91	max := 100 * time.Millisecond
94	92	for i := 0; i < total; i++ {
	93	// start variable is solely for EWMA calculation
	94	// EWMA's unit of measure is an iteration's duration
95	95	start := time.Now()
96		time.Sleep(time.Duration(rand.Intn(10)+1) * max / 10)
97		// ewma based decorators require work duration measurement
98		bar.IncrBy(1, time.Since(start))
	96	time.Sleep(time.Duration(rng.Intn(10)+1) * max / 10)
	97	bar.Increment()
	98	// we need to call DecoratorEwmaUpdate to fulfill ewma decorator's contract
	99	bar.DecoratorEwmaUpdate(time.Since(start))
99	100	}
100	101	}()
101	102	}
102		// wait for all bars to complete and flush
	103	// Waiting for passed &wg and for all bars to complete and flush
103	104	p.Wait()
104	105	```
105	106
106		#### [Dynamic total](examples/dynTotal/main.go)
	107	#### [Dynamic total](_examples/dynTotal/main.go)
107	108
108		![dynamic total](examples/gifs/godEMrCZmJkHYH1X9dN4Nm0U7.svg)
	109	![dynamic total](_svg/godEMrCZmJkHYH1X9dN4Nm0U7.svg)
109	110
110		#### [Complex example](examples/complex/main.go)
	111	#### [Complex example](_examples/complex/main.go)
111	112
112		![complex](examples/gifs/wHzf1M7sd7B3zVa2scBMnjqRf.svg)
	113	![complex](_svg/wHzf1M7sd7B3zVa2scBMnjqRf.svg)
113	114
114		#### [Bytes counters](examples/io/single/main.go)
	115	#### [Bytes counters](_examples/io/main.go)
115	116
116		![byte counters](examples/gifs/hIpTa3A5rQz65ssiVuRJu87X6.svg)
	117	![byte counters](_svg/hIpTa3A5rQz65ssiVuRJu87X6.svg)

+24

-0

UNLICENSE less more

	0	This is free and unencumbered software released into the public domain.
	1
	2	Anyone is free to copy, modify, publish, use, compile, sell, or
	3	distribute this software, either in source code form or as a compiled
	4	binary, for any purpose, commercial or non-commercial, and by any
	5	means.
	6
	7	In jurisdictions that recognize copyright laws, the author or authors
	8	of this software dedicate any and all copyright interest in the
	9	software to the public domain. We make this dedication for the benefit
	10	of the public at large and to the detriment of our heirs and
	11	successors. We intend this dedication to be an overt act of
	12	relinquishment in perpetuity of all present and future rights to this
	13	software under copyright law.
	14
	15	THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
	16	EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
	17	MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
	18	IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
	19	OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
	20	ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
	21	OTHER DEALINGS IN THE SOFTWARE.
	22
	23	For more information, please refer to <http://unlicense.org/>

+1

-0

_examples/.gitignore less more

0

go.sum

+5

-0

_examples/barExtender/go.mod less more

	0	module github.com/vbauerster/mpb/_examples/barExtender
	1
	2	go 1.14
	3
	4	require github.com/vbauerster/mpb/v5 v5.0.3

+60

-0

_examples/barExtender/main.go less more

	0	package main
	1
	2	import (
	3	"fmt"
	4	"io"
	5	"math/rand"
	6	"sync"
	7	"time"
	8
	9	"github.com/vbauerster/mpb/v5"
	10	"github.com/vbauerster/mpb/v5/decor"
	11	)
	12
	13	func main() {
	14	var wg sync.WaitGroup
	15	p := mpb.New(mpb.WithWaitGroup(&wg))
	16	total, numBars := 100, 3
	17	wg.Add(numBars)
	18
	19	for i := 0; i < numBars; i++ {
	20	name := fmt.Sprintf("Bar#%d:", i)
	21	efn := func(w io.Writer, width int, s *decor.Statistics) {
	22	if s.Completed {
	23	fmt.Fprintf(w, "Bar id: %d has been completed\n", s.ID)
	24	}
	25	}
	26	bar := p.AddBar(int64(total), mpb.BarExtender(mpb.BarFillerFunc(efn)),
	27	mpb.PrependDecorators(
	28	// simple name decorator
	29	decor.Name(name),
	30	// decor.DSyncWidth bit enables column width synchronization
	31	decor.Percentage(decor.WCSyncSpace),
	32	),
	33	mpb.AppendDecorators(
	34	// replace ETA decorator with "done" message, OnComplete event
	35	decor.OnComplete(
	36	// ETA decorator with ewma age of 60
	37	decor.EwmaETA(decor.ET_STYLE_GO, 60), "done",
	38	),
	39	),
	40	)
	41	// simulating some work
	42	go func() {
	43	defer wg.Done()
	44	rng := rand.New(rand.NewSource(time.Now().UnixNano()))
	45	max := 100 * time.Millisecond
	46	for i := 0; i < total; i++ {
	47	// start variable is solely for EWMA calculation
	48	// EWMA's unit of measure is an iteration's duration
	49	start := time.Now()
	50	time.Sleep(time.Duration(rng.Intn(10)+1) * max / 10)
	51	bar.Increment()
	52	// since EWMA based decorator is used, DecoratorEwmaUpdate should be called
	53	bar.DecoratorEwmaUpdate(time.Since(start))
	54	}
	55	}()
	56	}
	57	// wait for all bars to complete and flush
	58	p.Wait()
	59	}

+5

-0

_examples/cancel/go.mod less more

	0	module github.com/vbauerster/mpb/_examples/cancel
	1
	2	go 1.14
	3
	4	require github.com/vbauerster/mpb/v5 v5.0.3

+54

-0

_examples/cancel/main.go less more

	0	package main
	1
	2	import (
	3	"context"
	4	"fmt"
	5	"math/rand"
	6	"sync"
	7	"time"
	8
	9	"github.com/vbauerster/mpb/v5"
	10	"github.com/vbauerster/mpb/v5/decor"
	11	)
	12
	13	func main() {
	14	ctx, cancel := context.WithTimeout(context.Background(), 3*time.Second)
	15	defer cancel()
	16
	17	var wg sync.WaitGroup
	18	p := mpb.NewWithContext(ctx, mpb.WithWaitGroup(&wg))
	19	total := 300
	20	numBars := 3
	21	wg.Add(numBars)
	22
	23	for i := 0; i < numBars; i++ {
	24	name := fmt.Sprintf("Bar#%d:", i)
	25	bar := p.AddBar(int64(total),
	26	mpb.PrependDecorators(
	27	decor.Name(name),
	28	decor.EwmaETA(decor.ET_STYLE_GO, 60, decor.WCSyncSpace),
	29	),
	30	mpb.AppendDecorators(
	31	// note that OnComplete will not be fired, because of cancel
	32	decor.OnComplete(decor.Percentage(decor.WC{W: 5}), "done"),
	33	),
	34	)
	35
	36	go func() {
	37	defer wg.Done()
	38	rng := rand.New(rand.NewSource(time.Now().UnixNano()))
	39	max := 100 * time.Millisecond
	40	for !bar.Completed() {
	41	// start variable is solely for EWMA calculation
	42	// EWMA's unit of measure is an iteration's duration
	43	start := time.Now()
	44	time.Sleep(time.Duration(rng.Intn(10)+1) * max / 10)
	45	bar.Increment()
	46	// since EWMA based decorator is used, DecoratorEwmaUpdate should be called
	47	bar.DecoratorEwmaUpdate(time.Since(start))
	48	}
	49	}()
	50	}
	51
	52	p.Wait()
	53	}

+5

-0

_examples/complex/go.mod less more

	0	module github.com/vbauerster/mpb/_examples/complex
	1
	2	go 1.14
	3
	4	require github.com/vbauerster/mpb/v5 v5.0.3

+82

-0

_examples/complex/main.go less more

	0	package main
	1
	2	import (
	3	"fmt"
	4	"math/rand"
	5	"sync"
	6	"time"
	7
	8	"github.com/vbauerster/mpb/v5"
	9	"github.com/vbauerster/mpb/v5/decor"
	10	)
	11
	12	func init() {
	13	rand.Seed(time.Now().UnixNano())
	14	}
	15
	16	func main() {
	17	doneWg := new(sync.WaitGroup)
	18	p := mpb.New(mpb.WithWidth(64), mpb.WithWaitGroup(doneWg))
	19	numBars := 4
	20
	21	var bars []*mpb.Bar
	22	var downloadWgg []*sync.WaitGroup
	23	for i := 0; i < numBars; i++ {
	24	wg := new(sync.WaitGroup)
	25	wg.Add(1)
	26	downloadWgg = append(downloadWgg, wg)
	27	task := fmt.Sprintf("Task#%02d:", i)
	28	job := "downloading"
	29	b := p.AddBar(rand.Int63n(201)+100,
	30	mpb.PrependDecorators(
	31	decor.Name(task, decor.WC{W: len(task) + 1, C: decor.DidentRight}),
	32	decor.Name(job, decor.WCSyncSpaceR),
	33	decor.CountersNoUnit("%d / %d", decor.WCSyncWidth),
	34	),
	35	mpb.AppendDecorators(decor.Percentage(decor.WC{W: 5})),
	36	)
	37	go newTask(wg, b, i+1)
	38	bars = append(bars, b)
	39	}
	40
	41	for i := 0; i < numBars; i++ {
	42	doneWg.Add(1)
	43	i := i
	44	go func() {
	45	task := fmt.Sprintf("Task#%02d:", i)
	46	job := "\x1b[31;1;4minstalling\x1b[0m"
	47	// preparing delayed bars
	48	b := p.AddBar(rand.Int63n(101)+100,
	49	mpb.BarQueueAfter(bars[i]),
	50	mpb.BarFillerClearOnComplete(),
	51	mpb.PrependDecorators(
	52	decor.Name(task, decor.WC{W: len(task) + 1, C: decor.DidentRight}),
	53	decor.OnComplete(decor.Name(job, decor.WCSyncSpaceR), "done!"),
	54	decor.OnComplete(decor.EwmaETA(decor.ET_STYLE_MMSS, 0, decor.WCSyncWidth), ""),
	55	),
	56	mpb.AppendDecorators(
	57	decor.OnComplete(decor.Percentage(decor.WC{W: 5}), ""),
	58	),
	59	)
	60	// waiting for download to complete, before starting install job
	61	downloadWgg[i].Wait()
	62	go newTask(doneWg, b, numBars-i)
	63	}()
	64	}
	65
	66	p.Wait()
	67	}
	68
	69	func newTask(wg sync.WaitGroup, bar mpb.Bar, incrBy int) {
	70	defer wg.Done()
	71	max := 100 * time.Millisecond
	72	for !bar.Completed() {
	73	// start variable is solely for EWMA calculation
	74	// EWMA's unit of measure is an iteration's duration
	75	start := time.Now()
	76	time.Sleep(time.Duration(rand.Intn(10)+1) * max / 10)
	77	bar.IncrBy(incrBy)
	78	// we need to call DecoratorEwmaUpdate to fulfill ewma decorator's contract
	79	bar.DecoratorEwmaUpdate(time.Since(start))
	80	}
	81	}

+5

-0

_examples/differentWidth/go.mod less more

	0	module github.com/vbauerster/mpb/_examples/differentWidth
	1
	2	go 1.14
	3
	4	require github.com/vbauerster/mpb/v5 v5.0.3

+60

-0

_examples/differentWidth/main.go less more

	0	package main
	1
	2	import (
	3	"fmt"
	4	"math/rand"
	5	"sync"
	6	"time"
	7
	8	"github.com/vbauerster/mpb/v5"
	9	"github.com/vbauerster/mpb/v5/decor"
	10	)
	11
	12	func main() {
	13	var wg sync.WaitGroup
	14	p := mpb.New(
	15	mpb.WithWaitGroup(&wg),
	16	// container's width.
	17	mpb.WithWidth(60),
	18	)
	19	total, numBars := 100, 3
	20	wg.Add(numBars)
	21
	22	for i := 0; i < numBars; i++ {
	23	name := fmt.Sprintf("Bar#%d:", i)
	24	bar := p.AddBar(int64(total),
	25	// set BarWidth 40 for bar 1 and 2
	26	mpb.BarOptOn(mpb.BarWidth(40), func() bool { return i > 0 }),
	27	mpb.PrependDecorators(
	28	// simple name decorator
	29	decor.Name(name),
	30	// decor.DSyncWidth bit enables column width synchronization
	31	decor.Percentage(decor.WCSyncSpace),
	32	),
	33	mpb.AppendDecorators(
	34	// replace ETA decorator with "done" message, OnComplete event
	35	decor.OnComplete(
	36	// ETA decorator with ewma age of 60
	37	decor.EwmaETA(decor.ET_STYLE_GO, 60), "done",
	38	),
	39	),
	40	)
	41	// simulating some work
	42	go func() {
	43	defer wg.Done()
	44	rng := rand.New(rand.NewSource(time.Now().UnixNano()))
	45	max := 100 * time.Millisecond
	46	for i := 0; i < total; i++ {
	47	// start variable is solely for EWMA calculation
	48	// EWMA's unit of measure is an iteration's duration
	49	start := time.Now()
	50	time.Sleep(time.Duration(rng.Intn(10)+1) * max / 10)
	51	bar.Increment()
	52	// we need to call DecoratorEwmaUpdate to fulfill ewma decorator's contract
	53	bar.DecoratorEwmaUpdate(time.Since(start))
	54	}
	55	}()
	56	}
	57	// wait for all bars to complete and flush
	58	p.Wait()
	59	}

+5

-0

_examples/dynTotal/go.mod less more

	0	module github.com/vbauerster/mpb/_examples/dynTotal
	1
	2	go 1.14
	3
	4	require github.com/vbauerster/mpb/v5 v5.0.3

+55

-0

_examples/dynTotal/main.go less more

	0	package main
	1
	2	import (
	3	"io"
	4	"math/rand"
	5	"time"
	6
	7	"github.com/vbauerster/mpb/v5"
	8	"github.com/vbauerster/mpb/v5/decor"
	9	)
	10
	11	func init() {
	12	rand.Seed(time.Now().UnixNano())
	13	}
	14
	15	func main() {
	16	p := mpb.New(mpb.WithWidth(64))
	17
	18	var total int64
	19	bar := p.AddBar(total,
	20	mpb.PrependDecorators(decor.Counters(decor.UnitKiB, "% .1f / % .1f")),
	21	mpb.AppendDecorators(decor.Percentage()),
	22	)
	23
	24	maxSleep := 100 * time.Millisecond
	25	read := makeStream(200)
	26	for {
	27	n, err := read()
	28	total += int64(n)
	29	if err == io.EOF {
	30	break
	31	}
	32	// while total is unknown,
	33	// set it to a positive number which is greater than current total,
	34	// to make sure no complete event is triggered by next IncrBy call.
	35	bar.SetTotal(total+2048, false)
	36	bar.IncrBy(n)
	37	time.Sleep(time.Duration(rand.Intn(10)+1) * maxSleep / 10)
	38	}
	39
	40	// force bar complete event, note true flag
	41	bar.SetTotal(total, true)
	42
	43	p.Wait()
	44	}
	45
	46	func makeStream(limit int) func() (int, error) {
	47	return func() (int, error) {
	48	if limit <= 0 {
	49	return 0, io.EOF
	50	}
	51	limit--
	52	return rand.Intn(1024) + 1, nil
	53	}
	54	}

+5

-0

_examples/io/go.mod less more

	0	module github.com/vbauerster/mpb/_examples/io
	1
	2	go 1.14
	3
	4	require github.com/vbauerster/mpb/v5 v5.0.3

+41

-0

_examples/io/main.go less more

	0	package main
	1
	2	import (
	3	"crypto/rand"
	4	"io"
	5	"io/ioutil"
	6	"time"
	7
	8	"github.com/vbauerster/mpb/v5"
	9	"github.com/vbauerster/mpb/v5/decor"
	10	)
	11
	12	func main() {
	13	var total int64 = 1024 * 1024 * 500
	14	reader := io.LimitReader(rand.Reader, total)
	15
	16	p := mpb.New(
	17	mpb.WithWidth(60),
	18	mpb.WithRefreshRate(180*time.Millisecond),
	19	)
	20
	21	bar := p.AddBar(total, mpb.BarStyle("[=>-\|"),
	22	mpb.PrependDecorators(
	23	decor.CountersKibiByte("% .2f / % .2f"),
	24	),
	25	mpb.AppendDecorators(
	26	decor.EwmaETA(decor.ET_STYLE_GO, 90),
	27	decor.Name(" ] "),
	28	decor.EwmaSpeed(decor.UnitKiB, "% .2f", 60),
	29	),
	30	)
	31
	32	// create proxy reader
	33	proxyReader := bar.ProxyReader(reader)
	34	defer proxyReader.Close()
	35
	36	// copy from proxyReader, ignoring errors
	37	io.Copy(ioutil.Discard, proxyReader)
	38
	39	p.Wait()
	40	}

+5

-0

_examples/merge/go.mod less more

	0	module github.com/vbauerster/mpb/_examples/merge
	1
	2	go 1.14
	3
	4	require github.com/vbauerster/mpb/v5 v5.0.3

+70

-0

_examples/merge/main.go less more

	0	package main
	1
	2	import (
	3	"math/rand"
	4	"strings"
	5	"sync"
	6	"time"
	7
	8	"github.com/vbauerster/mpb/v5"
	9	"github.com/vbauerster/mpb/v5/decor"
	10	)
	11
	12	func main() {
	13	var wg sync.WaitGroup
	14	// pass &wg (optional), so p will wait for it eventually
	15	p := mpb.New(mpb.WithWaitGroup(&wg), mpb.WithWidth(60))
	16	total, numBars := 100, 3
	17	wg.Add(numBars)
	18
	19	for i := 0; i < numBars; i++ {
	20	var pdecorators mpb.BarOption
	21	if i == 0 {
	22	pdecorators = mpb.PrependDecorators(
	23	decor.Merge(
	24	decor.OnComplete(
	25	newVariadicSpinner(decor.WCSyncSpace),
	26	"done",
	27	),
	28	decor.WCSyncSpace, // Placeholder
	29	),
	30	)
	31	} else {
	32	pdecorators = mpb.PrependDecorators(
	33	decor.CountersNoUnit("% .1d / % .1d", decor.WCSyncSpace),
	34	decor.OnComplete(decor.Spinner(nil, decor.WCSyncSpace), "done"),
	35	)
	36	}
	37	bar := p.AddBar(int64(total),
	38	pdecorators,
	39	mpb.AppendDecorators(
	40	decor.OnComplete(decor.EwmaETA(decor.ET_STYLE_GO, 60), "done"),
	41	),
	42	)
	43	// simulating some work
	44	go func() {
	45	defer wg.Done()
	46	rng := rand.New(rand.NewSource(time.Now().UnixNano()))
	47	max := 100 * time.Millisecond
	48	for i := 0; i < total; i++ {
	49	// start variable is solely for EWMA calculation
	50	// EWMA's unit of measure is an iteration's duration
	51	start := time.Now()
	52	time.Sleep(time.Duration(rng.Intn(10)+1) * max / 10)
	53	bar.Increment()
	54	// we need to call DecoratorEwmaUpdate to fulfill ewma decorator's contract
	55	bar.DecoratorEwmaUpdate(time.Since(start))
	56	}
	57	}()
	58	}
	59	// Waiting for passed &wg and for all bars to complete and flush
	60	p.Wait()
	61	}
	62
	63	func newVariadicSpinner(wc decor.WC) decor.Decorator {
	64	spinner := decor.Spinner(nil)
	65	f := func(s *decor.Statistics) string {
	66	return strings.Repeat(spinner.Decor(s), int(s.Current/3))
	67	}
	68	return decor.Any(f, wc)
	69	}

+5

-0

_examples/multiBars/go.mod less more

	0	module github.com/vbauerster/mpb/_examples/multiBars
	1
	2	go 1.14
	3
	4	require github.com/vbauerster/mpb/v5 v5.0.3

+55

-0

_examples/multiBars/main.go less more

	0	package main
	1
	2	import (
	3	"fmt"
	4	"math/rand"
	5	"sync"
	6	"time"
	7
	8	"github.com/vbauerster/mpb/v5"
	9	"github.com/vbauerster/mpb/v5/decor"
	10	)
	11
	12	func main() {
	13	var wg sync.WaitGroup
	14	// pass &wg (optional), so p will wait for it eventually
	15	p := mpb.New(mpb.WithWaitGroup(&wg))
	16	total, numBars := 100, 3
	17	wg.Add(numBars)
	18
	19	for i := 0; i < numBars; i++ {
	20	name := fmt.Sprintf("Bar#%d:", i)
	21	bar := p.AddBar(int64(total),
	22	mpb.PrependDecorators(
	23	// simple name decorator
	24	decor.Name(name),
	25	// decor.DSyncWidth bit enables column width synchronization
	26	decor.Percentage(decor.WCSyncSpace),
	27	),
	28	mpb.AppendDecorators(
	29	// replace ETA decorator with "done" message, OnComplete event
	30	decor.OnComplete(
	31	// ETA decorator with ewma age of 60
	32	decor.EwmaETA(decor.ET_STYLE_GO, 60), "done",
	33	),
	34	),
	35	)
	36	// simulating some work
	37	go func() {
	38	defer wg.Done()
	39	rng := rand.New(rand.NewSource(time.Now().UnixNano()))
	40	max := 100 * time.Millisecond
	41	for i := 0; i < total; i++ {
	42	// start variable is solely for EWMA calculation
	43	// EWMA's unit of measure is an iteration's duration
	44	start := time.Now()
	45	time.Sleep(time.Duration(rng.Intn(10)+1) * max / 10)
	46	bar.Increment()
	47	// we need to call DecoratorEwmaUpdate to fulfill ewma decorator's contract
	48	bar.DecoratorEwmaUpdate(time.Since(start))
	49	}
	50	}()
	51	}
	52	// Waiting for passed &wg and for all bars to complete and flush
	53	p.Wait()
	54	}

+5

-0

_examples/panic/go.mod less more

	0	module github.com/vbauerster/mpb/_examples/panic
	1
	2	go 1.14
	3
	4	require github.com/vbauerster/mpb/v5 v5.0.3

+44

-0

_examples/panic/main.go less more

	0	package main
	1
	2	import (
	3	"fmt"
	4	"os"
	5	"sync"
	6	"time"
	7
	8	"github.com/vbauerster/mpb/v5"
	9	"github.com/vbauerster/mpb/v5/decor"
	10	)
	11
	12	func main() {
	13	var wg sync.WaitGroup
	14	p := mpb.New(mpb.WithWaitGroup(&wg), mpb.WithDebugOutput(os.Stderr))
	15
	16	wantPanic := "Some really long panic panic panic panic panic panic panic, really it is very long"
	17	numBars := 3
	18	wg.Add(numBars)
	19
	20	for i := 0; i < numBars; i++ {
	21	name := fmt.Sprintf("b#%02d:", i)
	22	bar := p.AddBar(100, mpb.BarID(i), mpb.PrependDecorators(panicDecorator(name, wantPanic)))
	23
	24	go func() {
	25	defer wg.Done()
	26	for i := 0; i < 100; i++ {
	27	time.Sleep(50 * time.Millisecond)
	28	bar.Increment()
	29	}
	30	}()
	31	}
	32
	33	p.Wait()
	34	}
	35
	36	func panicDecorator(name, panicMsg string) decor.Decorator {
	37	return decor.Any(func(s *decor.Statistics) string {
	38	if s.ID == 1 && s.Current >= 42 {
	39	panic(panicMsg)
	40	}
	41	return name
	42	})
	43	}

+5

-0

_examples/poplog/go.mod less more

	0	module github.com/vbauerster/mpb/_examples/poplog
	1
	2	go 1.14
	3
	4	require github.com/vbauerster/mpb/v5 v5.0.3

+70

-0

_examples/poplog/main.go less more

	0	package main
	1
	2	import (
	3	"fmt"
	4	"io"
	5	"math/rand"
	6	"sync"
	7	"time"
	8
	9	"github.com/vbauerster/mpb/v5"
	10	"github.com/vbauerster/mpb/v5/decor"
	11	)
	12
	13	func main() {
	14	p := mpb.New(mpb.PopCompletedMode())
	15
	16	total, numBars := 100, 2
	17	for i := 0; i < numBars; i++ {
	18	name := fmt.Sprintf("Bar#%d:", i)
	19	bar := p.AddBar(int64(total),
	20	mpb.BarNoPop(),
	21	mpb.PrependDecorators(
	22	decor.Name(name),
	23	decor.Percentage(decor.WCSyncSpace),
	24	),
	25	mpb.AppendDecorators(
	26	decor.OnComplete(
	27	decor.EwmaETA(decor.ET_STYLE_GO, 60), "done!",
	28	),
	29	),
	30	)
	31	// simulating some work
	32	go func() {
	33	rng := rand.New(rand.NewSource(time.Now().UnixNano()))
	34	max := 100 * time.Millisecond
	35	for i := 0; i < total; i++ {
	36	// start variable is solely for EWMA calculation
	37	// EWMA's unit of measure is an iteration's duration
	38	start := time.Now()
	39	time.Sleep(time.Duration(rng.Intn(10)+1) * max / 10)
	40	bar.Increment()
	41	// we need to call DecoratorEwmaUpdate to fulfill ewma decorator's contract
	42	bar.DecoratorEwmaUpdate(time.Since(start))
	43	}
	44	}()
	45	}
	46
	47	var wg sync.WaitGroup
	48	wg.Add(1)
	49	go func() {
	50	defer wg.Done()
	51	rng := rand.New(rand.NewSource(time.Now().UnixNano()))
	52	max := 3000 * time.Millisecond
	53	for i := 0; i < 10; i++ {
	54	filler := makeLogBar(fmt.Sprintf("some log: %d", i))
	55	p.Add(0, filler).SetTotal(0, true)
	56	time.Sleep(time.Duration(rng.Intn(10)+1) * max / 10)
	57	}
	58	}()
	59
	60	wg.Wait()
	61	p.Wait()
	62	}
	63
	64	func makeLogBar(msg string) mpb.BarFiller {
	65	limit := "%%.%ds"
	66	return mpb.BarFillerFunc(func(w io.Writer, width int, st *decor.Statistics) {
	67	fmt.Fprintf(w, fmt.Sprintf(limit, width), msg)
	68	})
	69	}

+5

-0

_examples/quietMode/go.mod less more

	0	module github.com/vbauerster/mpb/_examples/quietMode
	1
	2	go 1.14
	3
	4	require github.com/vbauerster/mpb/v5 v5.0.3

+74

-0

_examples/quietMode/main.go less more

	0	package main
	1
	2	import (
	3	"flag"
	4	"fmt"
	5	"math/rand"
	6	"sync"
	7	"time"
	8
	9	"github.com/vbauerster/mpb/v5"
	10	"github.com/vbauerster/mpb/v5/decor"
	11	)
	12
	13	var quietMode bool
	14
	15	func init() {
	16	flag.BoolVar(&quietMode, "q", false, "quiet mode")
	17	}
	18
	19	func main() {
	20	flag.Parse()
	21	var wg sync.WaitGroup
	22	// pass &wg (optional), so p will wait for it eventually
	23	p := mpb.New(
	24	mpb.WithWaitGroup(&wg),
	25	mpb.ContainerOptOn(
	26	// setting to nil will:
	27	// set output to ioutil.Discard and disable internal refresh rate
	28	// cycling, in order to not consume much CPU, hovewer a single refresh
	29	// still will be triggered on bar complete event, per each bar.
	30	mpb.WithOutput(nil),
	31	func() bool { return quietMode },
	32	),
	33	)
	34	total, numBars := 100, 3
	35	wg.Add(numBars)
	36
	37	for i := 0; i < numBars; i++ {
	38	name := fmt.Sprintf("Bar#%d:", i)
	39	bar := p.AddBar(int64(total),
	40	mpb.PrependDecorators(
	41	// simple name decorator
	42	decor.Name(name),
	43	// decor.DSyncWidth bit enables column width synchronization
	44	decor.Percentage(decor.WCSyncSpace),
	45	),
	46	mpb.AppendDecorators(
	47	// replace ETA decorator with "done" message, OnComplete event
	48	decor.OnComplete(
	49	// ETA decorator with ewma age of 60
	50	decor.EwmaETA(decor.ET_STYLE_GO, 60), "done",
	51	),
	52	),
	53	)
	54	// simulating some work
	55	go func() {
	56	defer wg.Done()
	57	rng := rand.New(rand.NewSource(time.Now().UnixNano()))
	58	max := 100 * time.Millisecond
	59	for i := 0; i < total; i++ {
	60	// start variable is solely for EWMA calculation
	61	// EWMA's unit of measure is an iteration's duration
	62	start := time.Now()
	63	time.Sleep(time.Duration(rng.Intn(10)+1) * max / 10)
	64	bar.Increment()
	65	// we need to call DecoratorEwmaUpdate to fulfill ewma decorator's contract
	66	bar.DecoratorEwmaUpdate(time.Since(start))
	67	}
	68	}()
	69	}
	70	// Waiting for passed &wg and for all bars to complete and flush
	71	p.Wait()
	72	fmt.Println("done")
	73	}

+5

-0

_examples/remove/go.mod less more

	0	module github.com/vbauerster/mpb/_examples/remove
	1
	2	go 1.14
	3
	4	require github.com/vbauerster/mpb/v5 v5.0.3

+52

-0

_examples/remove/main.go less more

	0	package main
	1
	2	import (
	3	"fmt"
	4	"math/rand"
	5	"sync"
	6	"time"
	7
	8	"github.com/vbauerster/mpb/v5"
	9	"github.com/vbauerster/mpb/v5/decor"
	10	)
	11
	12	func main() {
	13	var wg sync.WaitGroup
	14	p := mpb.New(mpb.WithWaitGroup(&wg))
	15	total := 100
	16	numBars := 3
	17	wg.Add(numBars)
	18
	19	for i := 0; i < numBars; i++ {
	20	name := fmt.Sprintf("Bar#%d:", i)
	21	bar := p.AddBar(int64(total),
	22	mpb.BarID(i),
	23	mpb.BarOptOn(mpb.BarRemoveOnComplete(), func() bool { return i == 0 }),
	24	mpb.PrependDecorators(
	25	decor.Name(name),
	26	decor.EwmaETA(decor.ET_STYLE_GO, 60, decor.WCSyncSpace),
	27	),
	28	mpb.AppendDecorators(decor.Percentage()),
	29	)
	30	go func() {
	31	defer wg.Done()
	32	rng := rand.New(rand.NewSource(time.Now().UnixNano()))
	33	max := 100 * time.Millisecond
	34	for i := 0; !bar.Completed(); i++ {
	35	// start variable is solely for EWMA calculation
	36	// EWMA's unit of measure is an iteration's duration
	37	start := time.Now()
	38	if bar.ID() == 2 && i >= 42 {
	39	// aborting and removing while bar is running
	40	bar.Abort(true)
	41	}
	42	time.Sleep(time.Duration(rng.Intn(10)+1) * max / 10)
	43	bar.Increment()
	44	// we need to call DecoratorEwmaUpdate to fulfill ewma decorator's contract
	45	bar.DecoratorEwmaUpdate(time.Since(start))
	46	}
	47	}()
	48	}
	49
	50	p.Wait()
	51	}

+5

-0

_examples/reverseBar/go.mod less more

	0	module github.com/vbauerster/mpb/_examples/reverseBar
	1
	2	go 1.14
	3
	4	require github.com/vbauerster/mpb/v5 v5.0.3

+57

-0

_examples/reverseBar/main.go less more

	0	package main
	1
	2	import (
	3	"fmt"
	4	"math/rand"
	5	"sync"
	6	"time"
	7
	8	"github.com/vbauerster/mpb/v5"
	9	"github.com/vbauerster/mpb/v5/decor"
	10	)
	11
	12	func main() {
	13	var wg sync.WaitGroup
	14	// pass &wg (optional), so p will wait for it eventually
	15	p := mpb.New(mpb.WithWaitGroup(&wg))
	16	total, numBars := 100, 3
	17	wg.Add(numBars)
	18
	19	for i := 0; i < numBars; i++ {
	20	name := fmt.Sprintf("Bar#%d:", i)
	21	bar := p.AddBar(int64(total),
	22	// reverse Bar#1
	23	mpb.BarOptOn(mpb.BarReverse(), func() bool { return i == 1 }),
	24	mpb.PrependDecorators(
	25	// simple name decorator
	26	decor.Name(name),
	27	// decor.DSyncWidth bit enables column width synchronization
	28	decor.Percentage(decor.WCSyncSpace),
	29	),
	30	mpb.AppendDecorators(
	31	// replace ETA decorator with "done" message, OnComplete event
	32	decor.OnComplete(
	33	// ETA decorator with ewma age of 60
	34	decor.EwmaETA(decor.ET_STYLE_GO, 60), "done",
	35	),
	36	),
	37	)
	38	// simulating some work
	39	go func() {
	40	defer wg.Done()
	41	rng := rand.New(rand.NewSource(time.Now().UnixNano()))
	42	max := 100 * time.Millisecond
	43	for i := 0; i < total; i++ {
	44	// start variable is solely for EWMA calculation
	45	// EWMA's unit of measure is an iteration's duration
	46	start := time.Now()
	47	time.Sleep(time.Duration(rng.Intn(10)+1) * max / 10)
	48	bar.Increment()
	49	// we need to call DecoratorEwmaUpdate to fulfill ewma decorator's contract
	50	bar.DecoratorEwmaUpdate(time.Since(start))
	51	}
	52	}()
	53	}
	54	// Waiting for passed &wg and for all bars to complete and flush
	55	p.Wait()
	56	}

+5

-0

_examples/singleBar/go.mod less more

	0	module github.com/vbauerster/mpb/_examples/singleBar
	1
	2	go 1.14
	3
	4	require github.com/vbauerster/mpb/v5 v5.0.3

+39

-0

_examples/singleBar/main.go less more

	0	package main
	1
	2	import (
	3	"math/rand"
	4	"time"
	5
	6	"github.com/vbauerster/mpb/v5"
	7	"github.com/vbauerster/mpb/v5/decor"
	8	)
	9
	10	func main() {
	11	// initialize progress container, with custom width
	12	p := mpb.New(mpb.WithWidth(64))
	13
	14	total := 100
	15	name := "Single Bar:"
	16	// adding a single bar, which will inherit container's width
	17	bar := p.AddBar(int64(total),
	18	// override DefaultBarStyle, which is "[=>-]<+"
	19	mpb.BarStyle("╢▌▌░╟"),
	20	mpb.PrependDecorators(
	21	// display our name with one space on the right
	22	decor.Name(name, decor.WC{W: len(name) + 1, C: decor.DidentRight}),
	23	// replace ETA decorator with "done" message, OnComplete event
	24	decor.OnComplete(
	25	decor.AverageETA(decor.ET_STYLE_GO, decor.WC{W: 4}), "done",
	26	),
	27	),
	28	mpb.AppendDecorators(decor.Percentage()),
	29	)
	30	// simulating some work
	31	max := 100 * time.Millisecond
	32	for i := 0; i < total; i++ {
	33	time.Sleep(time.Duration(rand.Intn(10)+1) * max / 10)
	34	bar.Increment()
	35	}
	36	// wait for our bar to complete and flush
	37	p.Wait()
	38	}

+5

-0

_examples/spinnerBar/go.mod less more

	0	module github.com/vbauerster/mpb/_examples/spinnerBar
	1
	2	go 1.14
	3
	4	require github.com/vbauerster/mpb/v5 v5.0.3

+77

-0

_examples/spinnerBar/main.go less more

	0	package main
	1
	2	import (
	3	"fmt"
	4	"math/rand"
	5	"sync"
	6	"time"
	7
	8	"github.com/vbauerster/mpb/v5"
	9	"github.com/vbauerster/mpb/v5/decor"
	10	)
	11
	12	func main() {
	13	var wg sync.WaitGroup
	14	p := mpb.New(
	15	mpb.WithWaitGroup(&wg),
	16	mpb.WithWidth(13),
	17	)
	18	total, numBars := 101, 3
	19	wg.Add(numBars)
	20
	21	for i := 0; i < numBars; i++ {
	22	name := fmt.Sprintf("Bar#%d:", i)
	23	var bar *mpb.Bar
	24	if i == 0 {
	25	bar = p.AddBar(int64(total),
	26	// override mpb.DefaultBarStyle, which is "[=>-]<+"
	27	mpb.BarStyle("╢▌▌░╟"),
	28	mpb.PrependDecorators(
	29	// simple name decorator
	30	decor.Name(name),
	31	),
	32	mpb.AppendDecorators(
	33	// replace ETA decorator with "done" message, OnComplete event
	34	decor.OnComplete(
	35	// ETA decorator with ewma age of 60
	36	decor.EwmaETA(decor.ET_STYLE_GO, 60), "done",
	37	),
	38	),
	39	)
	40	} else {
	41	bar = p.AddSpinner(int64(total), mpb.SpinnerOnMiddle,
	42	// override mpb.DefaultSpinnerStyle
	43	mpb.SpinnerStyle([]string{"∙∙∙", "●∙∙", "∙●∙", "∙∙●", "∙∙∙"}),
	44	mpb.PrependDecorators(
	45	// simple name decorator
	46	decor.Name(name),
	47	),
	48	mpb.AppendDecorators(
	49	// replace ETA decorator with "done" message, OnComplete event
	50	decor.OnComplete(
	51	// ETA decorator with ewma age of 60
	52	decor.EwmaETA(decor.ET_STYLE_GO, 60), "done",
	53	),
	54	),
	55	)
	56	}
	57
	58	// simulating some work
	59	go func() {
	60	defer wg.Done()
	61	rng := rand.New(rand.NewSource(time.Now().UnixNano()))
	62	max := 100 * time.Millisecond
	63	for i := 0; i < total; i++ {
	64	// start variable is solely for EWMA calculation
	65	// EWMA's unit of measure is an iteration's duration
	66	start := time.Now()
	67	time.Sleep(time.Duration(rng.Intn(10)+1) * max / 10)
	68	bar.Increment()
	69	// we need to call DecoratorEwmaUpdate to fulfill ewma decorator's contract
	70	bar.DecoratorEwmaUpdate(time.Since(start))
	71	}
	72	}()
	73	}
	74	// wait for all bars to complete and flush
	75	p.Wait()
	76	}

+5

-0

_examples/spinnerDecorator/go.mod less more

	0	module github.com/vbauerster/mpb/_examples/spinnerDecorator
	1
	2	go 1.14
	3
	4	require github.com/vbauerster/mpb/v5 v5.0.3

+49

-0

_examples/spinnerDecorator/main.go less more

	0	package main
	1
	2	import (
	3	"fmt"
	4	"math/rand"
	5	"sync"
	6	"time"
	7
	8	"github.com/vbauerster/mpb/v5"
	9	"github.com/vbauerster/mpb/v5/decor"
	10	)
	11
	12	func main() {
	13	var wg sync.WaitGroup
	14	// pass &wg (optional), so p will wait for it eventually
	15	p := mpb.New(mpb.WithWaitGroup(&wg), mpb.WithWidth(64))
	16	total, numBars := 100, 3
	17	wg.Add(numBars)
	18
	19	for i := 0; i < numBars; i++ {
	20	name := fmt.Sprintf("Bar#%d:", i)
	21	bar := p.AddBar(int64(total),
	22	mpb.PrependDecorators(
	23	// simple name decorator
	24	decor.Name(name),
	25	decor.OnComplete(
	26	// spinner decorator with default style
	27	decor.Spinner(nil, decor.WCSyncSpace), "done",
	28	),
	29	),
	30	mpb.AppendDecorators(
	31	// decor.DSyncWidth bit enables column width synchronization
	32	decor.Percentage(decor.WCSyncWidth),
	33	),
	34	)
	35	// simulating some work
	36	go func() {
	37	defer wg.Done()
	38	rng := rand.New(rand.NewSource(time.Now().UnixNano()))
	39	max := 100 * time.Millisecond
	40	for i := 0; i < total; i++ {
	41	time.Sleep(time.Duration(rng.Intn(10)+1) * max / 10)
	42	bar.Increment()
	43	}
	44	}()
	45	}
	46	// Waiting for passed &wg and for all bars to complete and flush
	47	p.Wait()
	48	}

+5

-0

_examples/stress/go.mod less more

	0	module github.com/vbauerster/mpb/_examples/stress
	1
	2	go 1.14
	3
	4	require github.com/vbauerster/mpb/v5 v5.0.3

+52

-0

_examples/stress/main.go less more

	0	package main
	1
	2	import (
	3	"fmt"
	4	"math/rand"
	5	"sync"
	6	"time"
	7
	8	"github.com/vbauerster/mpb/v5"
	9	"github.com/vbauerster/mpb/v5/decor"
	10	)
	11
	12	const (
	13	totalBars = 32
	14	)
	15
	16	func main() {
	17	var wg sync.WaitGroup
	18	p := mpb.New(
	19	mpb.WithWaitGroup(&wg),
	20	mpb.WithRefreshRate(50*time.Millisecond),
	21	)
	22	wg.Add(totalBars)
	23
	24	for i := 0; i < totalBars; i++ {
	25	name := fmt.Sprintf("Bar#%02d: ", i)
	26	total := rand.Intn(320) + 10
	27	bar := p.AddBar(int64(total),
	28	mpb.PrependDecorators(
	29	decor.Name(name),
	30	decor.Elapsed(decor.ET_STYLE_GO, decor.WCSyncSpace),
	31	),
	32	mpb.AppendDecorators(
	33	decor.OnComplete(
	34	decor.Percentage(decor.WC{W: 5}), "done",
	35	),
	36	),
	37	)
	38
	39	go func() {
	40	defer wg.Done()
	41	rng := rand.New(rand.NewSource(time.Now().UnixNano()))
	42	max := 100 * time.Millisecond
	43	for !bar.Completed() {
	44	time.Sleep(time.Duration(rng.Intn(10)+1) * max / 10)
	45	bar.Increment()
	46	}
	47	}()
	48	}
	49
	50	p.Wait()
	51	}

+5

-0

_examples/suppressBar/go.mod less more

	0	module github.com/vbauerster/mpb/_examples/suppressBar
	1
	2	go 1.14
	3
	4	require github.com/vbauerster/mpb/v5 v5.0.3

+129

-0

_examples/suppressBar/main.go less more

	0	package main
	1
	2	import (
	3	"errors"
	4	"fmt"
	5	"io"
	6	"math/rand"
	7	"sync"
	8	"time"
	9
	10	"github.com/vbauerster/mpb/v5"
	11	"github.com/vbauerster/mpb/v5/decor"
	12	)
	13
	14	func main() {
	15	p := mpb.New()
	16
	17	total := 100
	18	msgCh := make(chan string)
	19	resumeCh := make(chan struct{})
	20	filler, nextCh := newCustomFiller(msgCh, resumeCh)
	21	bar := p.Add(int64(total), filler,
	22	mpb.PrependDecorators(
	23	decor.Name("my bar:"),
	24	),
	25	mpb.AppendDecorators(
	26	newCustomPercentage(nextCh),
	27	),
	28	)
	29	ew := &errorWrapper{}
	30	time.AfterFunc(2*time.Second, func() {
	31	ew.reset(errors.New("timeout"))
	32	})
	33	// simulating some work
	34	go func() {
	35	rng := rand.New(rand.NewSource(time.Now().UnixNano()))
	36	max := 100 * time.Millisecond
	37	for i := 0; i < total; i++ {
	38	time.Sleep(time.Duration(rng.Intn(10)+1) * max / 10)
	39	if ew.isErr() {
	40	msgCh <- fmt.Sprintf("%s at %d, retrying...", ew.Error(), i)
	41	go ew.reset(nil)
	42	i--
	43	bar.SetRefill(int64(i))
	44	time.Sleep(3 * time.Second)
	45	resumeCh <- struct{}{}
	46	continue
	47	}
	48	bar.Increment()
	49	}
	50	}()
	51
	52	p.Wait()
	53	}
	54
	55	type errorWrapper struct {
	56	sync.RWMutex
	57	err error
	58	}
	59
	60	func (ew *errorWrapper) Error() string {
	61	ew.RLock()
	62	defer ew.RUnlock()
	63	return ew.err.Error()
	64	}
	65
	66	func (ew *errorWrapper) isErr() bool {
	67	ew.RLock()
	68	defer ew.RUnlock()
	69	return ew.err != nil
	70	}
	71
	72	func (ew *errorWrapper) reset(err error) {
	73	ew.Lock()
	74	ew.err = err
	75	ew.Unlock()
	76	}
	77
	78	type myBarFiller struct {
	79	mpb.BarFiller
	80	base mpb.BarFiller
	81	}
	82
	83	func (cf *myBarFiller) Base() mpb.BarFiller {
	84	return cf.base
	85	}
	86
	87	func newCustomFiller(ch <-chan string, resume <-chan struct{}) (mpb.BarFiller, <-chan struct{}) {
	88	base := mpb.NewBarFiller(mpb.DefaultBarStyle, false)
	89	nextCh := make(chan struct{}, 1)
	90	var msg *string
	91	filler := mpb.BarFillerFunc(func(w io.Writer, width int, st *decor.Statistics) {
	92	select {
	93	case m := <-ch:
	94	defer func() {
	95	msg = &m
	96	}()
	97	nextCh <- struct{}{}
	98	case <-resume:
	99	msg = nil
	100	default:
	101	}
	102	if msg != nil {
	103	limitFmt := fmt.Sprintf("%%.%ds", width)
	104	fmt.Fprintf(w, limitFmt, *msg)
	105	nextCh <- struct{}{}
	106	} else {
	107	base.Fill(w, width, st)
	108	}
	109	})
	110	cf := &myBarFiller{
	111	BarFiller: filler,
	112	base: base,
	113	}
	114	return cf, nextCh
	115	}
	116
	117	func newCustomPercentage(ch <-chan struct{}) decor.Decorator {
	118	base := decor.Percentage()
	119	f := func(s *decor.Statistics) string {
	120	select {
	121	case <-ch:
	122	return ""
	123	default:
	124	return base.Decor(s)
	125	}
	126	}
	127	return decor.Any(f)
	128	}

+1

-0

_svg/godEMrCZmJkHYH1X9dN4Nm0U7.svg less more

0

+1

-0

_svg/hIpTa3A5rQz65ssiVuRJu87X6.svg less more

0

+1

-0

_svg/wHzf1M7sd7B3zVa2scBMnjqRf.svg less more

0

+358

-281

bar.go less more

4	4	"context"
5	5	"fmt"
6	6	"io"
7		"io/ioutil"
	7	"log"
8	8	"strings"
9		"sync"
10	9	"time"
11	10	"unicode/utf8"
12	11
13		"github.com/vbauerster/mpb/decor"
	12	"github.com/vbauerster/mpb/v5/decor"
14	13	)
15	14
16		// Bar represents a progress Bar
	15	// BarFiller interface.
	16	// Bar renders itself by calling BarFiller's Fill method. You can
	17	// literally have any bar kind, by implementing this interface and
	18	// passing it to the Progress.Add(...) Bar method.
	19	type BarFiller interface {
	20	Fill(w io.Writer, width int, stat *decor.Statistics)
	21	}
	22
	23	// BarFillerFunc is function type adapter to convert function into Filler.
	24	type BarFillerFunc func(w io.Writer, width int, stat *decor.Statistics)
	25
	26	func (f BarFillerFunc) Fill(w io.Writer, width int, stat *decor.Statistics) {
	27	f(w, width, stat)
	28	}
	29
	30	// Bar represents a progress Bar.
17	31	type Bar struct {
	32	priority int // used by heap
	33	index int // used by heap
	34
	35	extendedLines int
	36	toShutdown bool
	37	toDrop bool
	38	noPop bool
	39	hasEwmaDecorators bool
	40	operateState chan func(*bState)
	41	frameCh chan io.Reader
	42	syncTableCh chan [][]chan int
	43	completed chan bool
	44
	45	// cancel is called either by user or on complete event
	46	cancel func()
	47	// done is closed after cacheState is assigned
	48	done chan struct{}
	49	// cacheState is populated, right after close(shutdown)
	50	cacheState *bState
	51
	52	container *Progress
	53	dlogger *log.Logger
	54	recoveredPanic interface{}
	55	}
	56
	57	type extFunc func(in io.Reader, tw int, st *decor.Statistics) (out io.Reader, lines int)
	58
	59	type bState struct {
	60	baseF BarFiller
	61	filler BarFiller
	62	id int
	63	width int
	64	total int64
	65	current int64
	66	lastN int64
	67	iterated bool
	68	trimSpace bool
	69	toComplete bool
	70	completeFlushed bool
	71	noPop bool
	72	aDecorators []decor.Decorator
	73	pDecorators []decor.Decorator
	74	averageDecorators []decor.AverageDecorator
	75	ewmaDecorators []decor.EwmaDecorator
	76	shutdownListeners []decor.ShutdownListener
	77	bufP, bufB, bufA *bytes.Buffer
	78	extender extFunc
	79
	80	// priority overrides *Bar's priority, if set
18	81	priority int
19		index int
20
21		runningBar *Bar
22		cacheState *bState
23		operateState chan func(*bState)
24		int64Ch chan int64
25		boolCh chan bool
26		frameReaderCh chan *frameReader
27		syncTableCh chan [][]chan int
28
29		// done is closed by Bar's goroutine, after cacheState is written
30		done chan struct{}
31		// shutdown is closed from master Progress goroutine only
32		shutdown chan struct{}
33		}
34
35		// Filler interface.
36		// Bar renders by calling Filler's Fill method. You can literally have
37		// any bar kind, by implementing this interface and passing it to the
38		// Add method.
39		type Filler interface {
40		Fill(w io.Writer, width int, s *decor.Statistics)
41		}
42
43		// FillerFunc is function type adapter to convert function into Filler.
44		type FillerFunc func(w io.Writer, width int, stat *decor.Statistics)
45
46		func (f FillerFunc) Fill(w io.Writer, width int, stat *decor.Statistics) {
47		f(w, width, stat)
48		}
49
50		type (
51		bState struct {
52		filler Filler
53		id int
54		width int
55		alignment int
56		total int64
57		current int64
58		trimSpace bool
59		toComplete bool
60		removeOnComplete bool
61		barClearOnComplete bool
62		completeFlushed bool
63		aDecorators []decor.Decorator
64		pDecorators []decor.Decorator
65		amountReceivers []decor.AmountReceiver
66		shutdownListeners []decor.ShutdownListener
67		refill *refill
68		bufP, bufB, bufA *bytes.Buffer
69		bufNL *bytes.Buffer
70		panicMsg string
71		newLineExtendFn func(io.Writer, *decor.Statistics)
72
73		// following options are assigned to the *Bar
74		priority int
75		runningBar *Bar
76		}
77		refill struct {
78		r rune
79		limit int64
80		}
81		frameReader struct {
82		io.Reader
83		extendedLines int
84		toShutdown bool
85		removeOnComplete bool
86		}
87		)
88
89		func newBar(
90		ctx context.Context,
91		wg *sync.WaitGroup,
92		filler Filler,
93		id, width int,
94		total int64,
95		options ...BarOption,
96		) *Bar {
97
98		s := &bState{
99		filler: filler,
100		id: id,
101		priority: id,
102		width: width,
103		total: total,
104		}
105
106		for _, opt := range options {
107		if opt != nil {
108		opt(s)
109		}
110		}
111
112		s.bufP = bytes.NewBuffer(make([]byte, 0, s.width))
113		s.bufB = bytes.NewBuffer(make([]byte, 0, s.width))
114		s.bufA = bytes.NewBuffer(make([]byte, 0, s.width))
115		if s.newLineExtendFn != nil {
116		s.bufNL = bytes.NewBuffer(make([]byte, 0, s.width))
117		}
118
119		b := &Bar{
120		priority: s.priority,
121		runningBar: s.runningBar,
122		operateState: make(chan func(*bState)),
123		int64Ch: make(chan int64),
124		boolCh: make(chan bool),
125		frameReaderCh: make(chan *frameReader, 1),
126		syncTableCh: make(chan [][]chan int),
127		done: make(chan struct{}),
128		shutdown: make(chan struct{}),
129		}
130
131		if b.runningBar != nil {
132		b.priority = b.runningBar.priority
133		}
134
135		go b.serve(ctx, wg, s)
136		return b
137		}
138
139		// RemoveAllPrependers removes all prepend functions.
140		func (b *Bar) RemoveAllPrependers() {
141		select {
142		case b.operateState <- func(s *bState) { s.pDecorators = nil }:
143		case <-b.done:
144		}
145		}
146
147		// RemoveAllAppenders removes all append functions.
148		func (b *Bar) RemoveAllAppenders() {
149		select {
150		case b.operateState <- func(s *bState) { s.aDecorators = nil }:
151		case <-b.done:
152		}
	82	// dropOnComplete propagates to *Bar
	83	dropOnComplete bool
	84	// runningBar is a key for *pState.parkedBars
	85	runningBar *Bar
	86
	87	debugOut io.Writer
	88	}
	89
	90	func newBar(container Progress, bs bState) *Bar {
	91	logPrefix := fmt.Sprintf("%sbar#%02d ", container.dlogger.Prefix(), bs.id)
	92	ctx, cancel := context.WithCancel(container.ctx)
	93
	94	bar := &Bar{
	95	container: container,
	96	priority: bs.priority,
	97	toDrop: bs.dropOnComplete,
	98	noPop: bs.noPop,
	99	operateState: make(chan func(*bState)),
	100	frameCh: make(chan io.Reader, 1),
	101	syncTableCh: make(chan [][]chan int),
	102	completed: make(chan bool, 1),
	103	done: make(chan struct{}),
	104	cancel: cancel,
	105	dlogger: log.New(bs.debugOut, logPrefix, log.Lshortfile),
	106	}
	107
	108	go bar.serve(ctx, bs)
	109	return bar
153	110	}
154	111
155	112	// ProxyReader wraps r with metrics required for progress tracking.
	113	// Panics if r is nil.
156	114	func (b *Bar) ProxyReader(r io.Reader) io.ReadCloser {
157	115	if r == nil {
158		panic("expect io.Reader, got nil")
159		}
160		rc, ok := r.(io.ReadCloser)
161		if !ok {
162		rc = ioutil.NopCloser(r)
163		}
164		return &proxyReader{rc, b, time.Now()}
	116	panic("expected non nil io.Reader")
	117	}
	118	return newProxyReader(r, b)
165	119	}
166	120
167	121	// ID returs id of the bar.
168	122	func (b *Bar) ID() int {
169		select {
170		case b.operateState <- func(s *bState) { b.int64Ch <- int64(s.id) }:
171		return int(<-b.int64Ch)
	123	result := make(chan int)
	124	select {
	125	case b.operateState <- func(s *bState) { result <- s.id }:
	126	return <-result
172	127	case <-b.done:
173	128	return b.cacheState.id
174	129	}

176	131
177	132	// Current returns bar's current number, in other words sum of all increments.
178	133	func (b *Bar) Current() int64 {
179		select {
180		case b.operateState <- func(s *bState) { b.int64Ch <- s.current }:
181		return <-b.int64Ch
	134	result := make(chan int64)
	135	select {
	136	case b.operateState <- func(s *bState) { result <- s.current }:
	137	return <-result
182	138	case <-b.done:
183	139	return b.cacheState.current
184	140	}
185	141	}
186	142
	143	// SetRefill fills bar with refill rune up to amount argument.
	144	// Given default bar style is "[=>-]<+", refill rune is '+'.
	145	// To set bar style use mpb.BarStyle(string) BarOption.
	146	func (b *Bar) SetRefill(amount int64) {
	147	type refiller interface {
	148	SetRefill(int64)
	149	}
	150	b.operateState <- func(s *bState) {
	151	if f, ok := s.baseF.(refiller); ok {
	152	f.SetRefill(amount)
	153	}
	154	}
	155	}
	156
	157	// TraverseDecorators traverses all available decorators and calls cb func on each.
	158	func (b *Bar) TraverseDecorators(cb func(decor.Decorator)) {
	159	b.operateState <- func(s *bState) {
	160	for _, decorators := range [...][]decor.Decorator{
	161	s.pDecorators,
	162	s.aDecorators,
	163	} {
	164	for _, d := range decorators {
	165	cb(extractBaseDecorator(d))
	166	}
	167	}
	168	}
	169	}
	170
187	171	// SetTotal sets total dynamically.
188		// Set complete to true, to trigger bar complete event now.
	172	// If total is less or equal to zero it takes progress' current value.
	173	// If complete is true, complete event will be triggered.
189	174	func (b *Bar) SetTotal(total int64, complete bool) {
190	175	select {
191	176	case b.operateState <- func(s *bState) {
192		s.total = total
	177	if total <= 0 {
	178	s.total = s.current
	179	} else {
	180	s.total = total
	181	}
193	182	if complete && !s.toComplete {
194	183	s.current = s.total
195	184	s.toComplete = true
196		}
197		}:
198		case <-b.done:
199		}
200		}
201
202		// SetRefill sets refill, if supported by underlying Filler.
203		func (b *Bar) SetRefill(amount int64) {
204		b.operateState <- func(s *bState) {
205		if f, ok := s.filler.(interface{ SetRefill(int64) }); ok {
206		f.SetRefill(amount)
207		}
208		}
209		}
210
211		// Increment is a shorthand for b.IncrBy(1).
212		func (b *Bar) Increment() {
213		b.IncrBy(1)
214		}
215
216		// IncrBy increments progress bar by amount of n.
217		// wdd is optional work duration i.e. time.Since(start), which expected
218		// to be provided, if any ewma based decorator is used.
219		func (b *Bar) IncrBy(n int, wdd ...time.Duration) {
220		select {
221		case b.operateState <- func(s *bState) {
222		s.current += int64(n)
	185	go b.refreshTillShutdown()
	186	}
	187	}:
	188	case <-b.done:
	189	}
	190	}
	191
	192	// SetCurrent sets progress' current to an arbitrary value.
	193	func (b *Bar) SetCurrent(current int64) {
	194	select {
	195	case b.operateState <- func(s *bState) {
	196	s.iterated = true
	197	s.lastN = current - s.current
	198	s.current = current
223	199	if s.total > 0 && s.current >= s.total {
224	200	s.current = s.total
225	201	s.toComplete = true
226		}
227		for _, ar := range s.amountReceivers {
228		ar.NextAmount(n, wdd...)
229		}
230		}:
231		case <-b.done:
	202	go b.refreshTillShutdown()
	203	}
	204	}:
	205	case <-b.done:
	206	}
	207	}
	208
	209	// Increment is a shorthand for b.IncrInt64(1).
	210	func (b *Bar) Increment() {
	211	b.IncrInt64(1)
	212	}
	213
	214	// IncrBy is a shorthand for b.IncrInt64(int64(n)).
	215	func (b *Bar) IncrBy(n int) {
	216	b.IncrInt64(int64(n))
	217	}
	218
	219	// IncrInt64 increments progress by amount of n.
	220	func (b *Bar) IncrInt64(n int64) {
	221	select {
	222	case b.operateState <- func(s *bState) {
	223	s.iterated = true
	224	s.lastN = n
	225	s.current += n
	226	if s.total > 0 && s.current >= s.total {
	227	s.current = s.total
	228	s.toComplete = true
	229	go b.refreshTillShutdown()
	230	}
	231	}:
	232	case <-b.done:
	233	}
	234	}
	235
	236	// DecoratorEwmaUpdate updates all EWMA based decorators. Should be
	237	// called on each iteration, because EWMA's unit of measure is an
	238	// iteration's duration. Panics if called before *Bar.Incr... family
	239	// methods.
	240	func (b *Bar) DecoratorEwmaUpdate(dur time.Duration) {
	241	select {
	242	case b.operateState <- func(s *bState) {
	243	ewmaIterationUpdate(false, s, dur)
	244	}:
	245	case <-b.done:
	246	ewmaIterationUpdate(true, b.cacheState, dur)
	247	}
	248	}
	249
	250	// DecoratorAverageAdjust adjusts all average based decorators. Call
	251	// if you need to adjust start time of all average based decorators
	252	// or after progress resume.
	253	func (b *Bar) DecoratorAverageAdjust(start time.Time) {
	254	select {
	255	case b.operateState <- func(s *bState) {
	256	for _, d := range s.averageDecorators {
	257	d.AverageAdjust(start)
	258	}
	259	}:
	260	case <-b.done:
	261	}
	262	}
	263
	264	// SetPriority changes bar's order among multiple bars. Zero is highest
	265	// priority, i.e. bar will be on top. If you don't need to set priority
	266	// dynamically, better use BarPriority option.
	267	func (b *Bar) SetPriority(priority int) {
	268	select {
	269	case <-b.done:
	270	default:
	271	b.container.setBarPriority(b, priority)
	272	}
	273	}
	274
	275	// Abort interrupts bar's running goroutine. Call this, if you'd like
	276	// to stop/remove bar before completion event. It has no effect after
	277	// completion event. If drop is true bar will be removed as well.
	278	func (b *Bar) Abort(drop bool) {
	279	select {
	280	case <-b.done:
	281	default:
	282	if drop {
	283	b.container.dropBar(b)
	284	}
	285	b.cancel()
232	286	}
233	287	}
234	288
235	289	// Completed reports whether the bar is in completed state.
236	290	func (b *Bar) Completed() bool {
237		// omit select here, because primary usage of the method is for loop
238		// condition, like for !bar.Completed() {...} so when toComplete=true
239		// it is called once (at which time, the bar is still alive), then
240		// quits the loop and never suppose to be called afterwards.
241		return <-b.boolCh
242		}
243
244		func (b *Bar) wSyncTable() [][]chan int {
245		select {
246		case b.operateState <- func(s *bState) { b.syncTableCh <- s.wSyncTable() }:
247		return <-b.syncTableCh
248		case <-b.done:
249		return b.cacheState.wSyncTable()
250		}
251		}
252
253		func (b Bar) serve(ctx context.Context, wg sync.WaitGroup, s *bState) {
254		defer wg.Done()
255		cancel := ctx.Done()
	291	select {
	292	case b.operateState <- func(s *bState) { b.completed <- s.toComplete }:
	293	return <-b.completed
	294	case <-b.done:
	295	return true
	296	}
	297	}
	298
	299	func (b Bar) serve(ctx context.Context, s bState) {
	300	defer b.container.bwg.Done()
256	301	for {
257	302	select {
258	303	case op := <-b.operateState:
259	304	op(s)
260		case b.boolCh <- s.toComplete:
261		case <-cancel:
262		s.toComplete = true
263		cancel = nil
264		case <-b.shutdown:
	305	case <-ctx.Done():
265	306	b.cacheState = s
266	307	close(b.done)
	308	// Notifying decorators about shutdown event
267	309	for _, sl := range s.shutdownListeners {
268	310	sl.Shutdown()
269	311	}

272	314	}
273	315	}
274	316
275		func (b *Bar) render(debugOut io.Writer, tw int) {
	317	func (b *Bar) render(tw int) {
	318	if b.recoveredPanic != nil {
	319	b.toShutdown = false
	320	b.frameCh <- b.panicToFrame(tw)
	321	return
	322	}
276	323	select {
277	324	case b.operateState <- func(s *bState) {
278	325	defer func() {
279	326	// recovering if user defined decorator panics for example
280	327	if p := recover(); p != nil {
281		s.panicMsg = fmt.Sprintf("panic: %v", p)
282		fmt.Fprintf(debugOut, "%s %s bar id %02d %v\n", "[mpb]", time.Now(), s.id, s.panicMsg)
283		b.frameReaderCh <- &frameReader{
284		Reader: strings.NewReader(fmt.Sprintf(fmt.Sprintf("%%.%ds\n", tw), s.panicMsg)),
285		toShutdown: true,
286		}
	328	b.dlogger.Println(p)
	329	b.recoveredPanic = p
	330	b.toShutdown = !s.completeFlushed
	331	b.frameCh <- b.panicToFrame(tw)
287	332	}
288	333	}()
289		r := s.draw(tw)
290		var extendedLines int
291		if s.newLineExtendFn != nil {
292		s.bufNL.Reset()
293		s.newLineExtendFn(s.bufNL, newStatistics(s))
294		extendedLines = countLines(s.bufNL.Bytes())
295		r = io.MultiReader(r, s.bufNL)
296		}
297		b.frameReaderCh <- &frameReader{
298		Reader: r,
299		extendedLines: extendedLines,
300		toShutdown: s.toComplete && !s.completeFlushed,
301		removeOnComplete: s.removeOnComplete,
302		}
	334
	335	st := newStatistics(s)
	336	frame := s.draw(tw, st)
	337	frame, b.extendedLines = s.extender(frame, tw, st)
	338
	339	b.toShutdown = s.toComplete && !s.completeFlushed
303	340	s.completeFlushed = s.toComplete
	341	b.frameCh <- frame
304	342	}:
305	343	case <-b.done:
306	344	s := b.cacheState
307		r := s.draw(tw)
308		var extendedLines int
309		if s.newLineExtendFn != nil {
310		s.bufNL.Reset()
311		s.newLineExtendFn(s.bufNL, newStatistics(s))
312		extendedLines = countLines(s.bufNL.Bytes())
313		r = io.MultiReader(r, s.bufNL)
314		}
315		b.frameReaderCh <- &frameReader{
316		Reader: r,
317		extendedLines: extendedLines,
318		}
319		}
320		}
321
322		func (s *bState) draw(termWidth int) io.Reader {
323		if s.panicMsg != "" {
324		return strings.NewReader(fmt.Sprintf(fmt.Sprintf("%%.%ds\n", termWidth), s.panicMsg))
325		}
326
327		stat := newStatistics(s)
328
	345	st := newStatistics(s)
	346	frame := s.draw(tw, st)
	347	frame, b.extendedLines = s.extender(frame, tw, st)
	348	b.frameCh <- frame
	349	}
	350	}
	351
	352	func (b *Bar) panicToFrame(termWidth int) io.Reader {
	353	return strings.NewReader(fmt.Sprintf(fmt.Sprintf("%%.%dv\n", termWidth), b.recoveredPanic))
	354	}
	355
	356	func (b *Bar) subscribeDecorators() {
	357	var averageDecorators []decor.AverageDecorator
	358	var ewmaDecorators []decor.EwmaDecorator
	359	var shutdownListeners []decor.ShutdownListener
	360	b.TraverseDecorators(func(d decor.Decorator) {
	361	if d, ok := d.(decor.AverageDecorator); ok {
	362	averageDecorators = append(averageDecorators, d)
	363	}
	364	if d, ok := d.(decor.EwmaDecorator); ok {
	365	ewmaDecorators = append(ewmaDecorators, d)
	366	}
	367	if d, ok := d.(decor.ShutdownListener); ok {
	368	shutdownListeners = append(shutdownListeners, d)
	369	}
	370	})
	371	b.operateState <- func(s *bState) {
	372	s.averageDecorators = averageDecorators
	373	s.ewmaDecorators = ewmaDecorators
	374	s.shutdownListeners = shutdownListeners
	375	}
	376	b.hasEwmaDecorators = len(ewmaDecorators) != 0
	377	}
	378
	379	func (b *Bar) refreshTillShutdown() {
	380	for {
	381	select {
	382	case b.container.refreshCh <- time.Now():
	383	case <-b.done:
	384	return
	385	}
	386	}
	387	}
	388
	389	func (b *Bar) wSyncTable() [][]chan int {
	390	select {
	391	case b.operateState <- func(s *bState) { b.syncTableCh <- s.wSyncTable() }:
	392	return <-b.syncTableCh
	393	case <-b.done:
	394	return b.cacheState.wSyncTable()
	395	}
	396	}
	397
	398	func (s bState) draw(termWidth int, stat decor.Statistics) io.Reader {
329	399	for _, d := range s.pDecorators {
330	400	s.bufP.WriteString(d.Decor(stat))
331	401	}

334	404	s.bufA.WriteString(d.Decor(stat))
335	405	}
336	406
337		if s.barClearOnComplete && s.completeFlushed {
338		s.bufA.WriteByte('\n')
339		return io.MultiReader(s.bufP, s.bufA)
340		}
	407	s.bufA.WriteByte('\n')
341	408
342	409	prependCount := utf8.RuneCount(s.bufP.Bytes())
343		appendCount := utf8.RuneCount(s.bufA.Bytes())
344
345		if !s.trimSpace {
346		// reserve space for edge spaces
347		termWidth -= 2
348		s.bufB.WriteByte(' ')
349		}
350
351		if prependCount+s.width+appendCount > termWidth {
352		s.filler.Fill(s.bufB, termWidth-prependCount-appendCount, stat)
353		} else {
354		s.filler.Fill(s.bufB, s.width, stat)
355		}
356
357		if !s.trimSpace {
358		s.bufB.WriteByte(' ')
359		}
360
361		s.bufA.WriteByte('\n')
	410	appendCount := utf8.RuneCount(s.bufA.Bytes()) - 1
	411
	412	if fitWidth := s.width; termWidth > 1 {
	413	if !s.trimSpace {
	414	// reserve space for edge spaces
	415	termWidth -= 2
	416	s.bufB.WriteByte(' ')
	417	defer s.bufB.WriteByte(' ')
	418	}
	419	if prependCount+s.width+appendCount > termWidth {
	420	fitWidth = termWidth - prependCount - appendCount
	421	}
	422	s.filler.Fill(s.bufB, fitWidth, stat)
	423	}
	424
362	425	return io.MultiReader(s.bufP, s.bufB, s.bufA)
363	426	}
364	427

366	429	columns := make([]chan int, 0, len(s.pDecorators)+len(s.aDecorators))
367	430	var pCount int
368	431	for _, d := range s.pDecorators {
369		if ok, ch := d.Syncable(); ok {
	432	if ch, ok := d.Sync(); ok {
370	433	columns = append(columns, ch)
371	434	pCount++
372	435	}
373	436	}
374	437	var aCount int
375	438	for _, d := range s.aDecorators {
376		if ok, ch := d.Syncable(); ok {
	439	if ch, ok := d.Sync(); ok {
377	440	columns = append(columns, ch)
378	441	aCount++
379	442	}

393	456	}
394	457	}
395	458
396		func countLines(b []byte) int {
397		return bytes.Count(b, []byte("\n"))
398		}
	459	func extractBaseDecorator(d decor.Decorator) decor.Decorator {
	460	if d, ok := d.(decor.Wrapper); ok {
	461	return extractBaseDecorator(d.Base())
	462	}
	463	return d
	464	}
	465
	466	func ewmaIterationUpdate(done bool, s *bState, dur time.Duration) {
	467	if !done && !s.iterated {
	468	panic("increment required before ewma iteration update")
	469	} else {
	470	s.iterated = false
	471	}
	472	for _, d := range s.ewmaDecorators {
	473	d.EwmaUpdate(s.lastN, dur)
	474	}
	475	}

+64

-37

bar_filler.go less more

3	3	"io"
4	4	"unicode/utf8"
5	5
6		"github.com/vbauerster/mpb/decor"
7		"github.com/vbauerster/mpb/internal"
	6	"github.com/vbauerster/mpb/v5/decor"
	7	"github.com/vbauerster/mpb/v5/internal"
8	8	)
9	9
10	10	const (

17	17	rRefill
18	18	)
19	19
20		var defaultBarStyle = "[=>-]<+"
	20	// DefaultBarStyle is a string containing 7 runes.
	21	// Each rune is a building block of a progress bar.
	22	//
	23	// '1st rune' stands for left boundary rune
	24	//
	25	// '2nd rune' stands for fill rune
	26	//
	27	// '3rd rune' stands for tip rune
	28	//
	29	// '4th rune' stands for empty rune
	30	//
	31	// '5th rune' stands for right boundary rune
	32	//
	33	// '6th rune' stands for reverse tip rune
	34	//
	35	// '7th rune' stands for refill rune
	36	//
	37	const DefaultBarStyle string = "[=>-]<+"
21	38
22	39	type barFiller struct {
23		format [][]byte
24		refillAmount int64
25		reverse bool
	40	format [][]byte
	41	tip []byte
	42	refill int64
	43	reverse bool
	44	flush func(w io.Writer, bb [][]byte)
26	45	}
27	46
28		func newDefaultBarFiller() Filler {
	47	// NewBarFiller constucts mpb.BarFiller, to be used with Progress.Add(...) Bar method.
	48	func NewBarFiller(style string, reverse bool) BarFiller {
	49	if style == "" {
	50	style = DefaultBarStyle
	51	}
29	52	bf := &barFiller{
30		format: make([][]byte, utf8.RuneCountInString(defaultBarStyle)),
	53	format: make([][]byte, utf8.RuneCountInString(style)),
	54	reverse: reverse,
31	55	}
32		bf.setStyle(defaultBarStyle)
	56	bf.SetStyle(style)
33	57	return bf
34	58	}
35	59
36		func (s *barFiller) setStyle(style string) {
	60	func (s *barFiller) SetStyle(style string) {
37	61	if !utf8.ValidString(style) {
38	62	return
39	63	}

42	66	src = append(src, []byte(string(r)))
43	67	}
44	68	copy(s.format, src)
	69	s.SetReverse(s.reverse)
45	70	}
46	71
47		func (s *barFiller) setReverse() {
48		s.reverse = true
	72	func (s *barFiller) SetReverse(reverse bool) {
	73	if reverse {
	74	s.tip = s.format[rRevTip]
	75	s.flush = reverseFlush
	76	} else {
	77	s.tip = s.format[rTip]
	78	s.flush = normalFlush
	79	}
	80	s.reverse = reverse
49	81	}
50	82
51	83	func (s *barFiller) SetRefill(amount int64) {
52		s.refillAmount = amount
	84	s.refill = amount
53	85	}
54	86
55	87	func (s barFiller) Fill(w io.Writer, width int, stat decor.Statistics) {
56
57		// don't count rLeft and rRight [brackets]
	88	// don't count rLeft and rRight as progress
58	89	width -= 2
59	90	if width < 2 {
60	91	return
61	92	}
62
63	93	w.Write(s.format[rLeft])
64		if width == 2 {
65		w.Write(s.format[rRight])
66		return
67		}
	94	defer w.Write(s.format[rRight])
68	95
69	96	bb := make([][]byte, width)
70	97
71		cwidth := int(internal.Percentage(stat.Total, stat.Current, int64(width)))
	98	cwidth := int(internal.PercentageRound(stat.Total, stat.Current, width))
72	99
73	100	for i := 0; i < cwidth; i++ {
74	101	bb[i] = s.format[rFill]
75	102	}
76	103
77		if s.refillAmount > 0 {
	104	if s.refill > 0 {
78	105	var rwidth int
79		if s.refillAmount > stat.Current {
	106	if s.refill > stat.Current {
80	107	rwidth = cwidth
81	108	} else {
82		rwidth = int(internal.Percentage(stat.Total, int64(s.refillAmount), int64(width)))
	109	rwidth = int(internal.PercentageRound(stat.Total, int64(s.refill), width))
83	110	}
84	111	for i := 0; i < rwidth; i++ {
85	112	bb[i] = s.format[rRefill]

87	114	}
88	115
89	116	if cwidth > 0 && cwidth < width {
90		bb[cwidth-1] = s.format[rTip]
	117	bb[cwidth-1] = s.tip
91	118	}
92	119
93	120	for i := cwidth; i < width; i++ {
94	121	bb[i] = s.format[rEmpty]
95	122	}
96	123
97		if s.reverse {
98		if cwidth > 0 && cwidth < width {
99		bb[cwidth-1] = s.format[rRevTip]
100		}
101		for i := len(bb) - 1; i >= 0; i-- {
102		w.Write(bb[i])
103		}
104		} else {
105		for i := 0; i < len(bb); i++ {
106		w.Write(bb[i])
107		}
	124	s.flush(w, bb)
	125	}
	126
	127	func normalFlush(w io.Writer, bb [][]byte) {
	128	for i := 0; i < len(bb); i++ {
	129	w.Write(bb[i])
108	130	}
109		w.Write(s.format[rRight])
110	131	}
	132
	133	func reverseFlush(w io.Writer, bb [][]byte) {
	134	for i := len(bb) - 1; i >= 0; i-- {
	135	w.Write(bb[i])
	136	}
	137	}

+113

-102

bar_option.go less more

0	0	package mpb
1	1
2	2	import (
	3	"bytes"
3	4	"io"
4	5
5		"github.com/vbauerster/mpb/decor"
	6	"github.com/vbauerster/mpb/v5/decor"
6	7	)
7	8
8	9	// BarOption is a function option which changes the default behavior of a bar.
9	10	type BarOption func(*bState)
10	11
	12	func (s bState) addDecorators(dest []decor.Decorator, decorators ...decor.Decorator) {
	13	type mergeWrapper interface {
	14	MergeUnwrap() []decor.Decorator
	15	}
	16	for _, decorator := range decorators {
	17	if mw, ok := decorator.(mergeWrapper); ok {
	18	dest = append(dest, mw.MergeUnwrap()...)
	19	}
	20	dest = append(dest, decorator)
	21	}
	22	}
	23
11	24	// AppendDecorators let you inject decorators to the bar's right side.
12		func AppendDecorators(appenders ...decor.Decorator) BarOption {
13		return func(s *bState) {
14		for _, decorator := range appenders {
15		if ar, ok := decorator.(decor.AmountReceiver); ok {
16		s.amountReceivers = append(s.amountReceivers, ar)
17		}
18		if sl, ok := decorator.(decor.ShutdownListener); ok {
19		s.shutdownListeners = append(s.shutdownListeners, sl)
20		}
21		s.aDecorators = append(s.aDecorators, decorator)
22		}
	25	func AppendDecorators(decorators ...decor.Decorator) BarOption {
	26	return func(s *bState) {
	27	s.addDecorators(&s.aDecorators, decorators...)
23	28	}
24	29	}
25	30
26	31	// PrependDecorators let you inject decorators to the bar's left side.
27		func PrependDecorators(prependers ...decor.Decorator) BarOption {
28		return func(s *bState) {
29		for _, decorator := range prependers {
30		if ar, ok := decorator.(decor.AmountReceiver); ok {
31		s.amountReceivers = append(s.amountReceivers, ar)
32		}
33		if sl, ok := decorator.(decor.ShutdownListener); ok {
34		s.shutdownListeners = append(s.shutdownListeners, sl)
35		}
36		s.pDecorators = append(s.pDecorators, decorator)
37		}
	32	func PrependDecorators(decorators ...decor.Decorator) BarOption {
	33	return func(s *bState) {
	34	s.addDecorators(&s.pDecorators, decorators...)
38	35	}
39	36	}
40	37

52	49	}
53	50	}
54	51
55		// BarRemoveOnComplete is a flag, if set whole bar line will be removed
56		// on complete event. If both BarRemoveOnComplete and BarClearOnComplete
57		// are set, first bar section gets cleared and then whole bar line
58		// gets removed completely.
	52	// BarQueueAfter queues this (being constructed) bar to relplace
	53	// runningBar after it has been completed.
	54	func BarQueueAfter(runningBar *Bar) BarOption {
	55	if runningBar == nil {
	56	return nil
	57	}
	58	return func(s *bState) {
	59	s.runningBar = runningBar
	60	}
	61	}
	62
	63	// BarRemoveOnComplete removes both bar's filler and its decorators
	64	// on complete event.
59	65	func BarRemoveOnComplete() BarOption {
60	66	return func(s *bState) {
61		s.removeOnComplete = true
62		}
63		}
64
65		// BarReplaceOnComplete is indicator for delayed bar start, after the
66		// `runningBar` is complete. To achieve bar replacement effect,
67		// `runningBar` should has its `BarRemoveOnComplete` option set.
68		func BarReplaceOnComplete(runningBar *Bar) BarOption {
69		return BarParkTo(runningBar)
70		}
71
72		// BarParkTo same as BarReplaceOnComplete
73		func BarParkTo(runningBar *Bar) BarOption {
74		return func(s *bState) {
75		s.runningBar = runningBar
76		}
77		}
78
79		// BarClearOnComplete is a flag, if set will clear bar section on
80		// complete event. If you need to remove a whole bar line, refer to
81		// BarRemoveOnComplete.
82		func BarClearOnComplete() BarOption {
83		return func(s *bState) {
84		s.barClearOnComplete = true
85		}
	67	s.dropOnComplete = true
	68	}
	69	}
	70
	71	// BarFillerClearOnComplete clears bar's filler on complete event.
	72	// It's shortcut for BarFillerOnComplete("").
	73	func BarFillerClearOnComplete() BarOption {
	74	return BarFillerOnComplete("")
	75	}
	76
	77	// BarFillerOnComplete replaces bar's filler with message, on complete event.
	78	func BarFillerOnComplete(message string) BarOption {
	79	return func(s *bState) {
	80	s.filler = makeBarFillerOnComplete(s.baseF, message)
	81	}
	82	}
	83
	84	func makeBarFillerOnComplete(filler BarFiller, message string) BarFiller {
	85	return BarFillerFunc(func(w io.Writer, width int, st *decor.Statistics) {
	86	if st.Completed {
	87	io.WriteString(w, message)
	88	} else {
	89	filler.Fill(w, width, st)
	90	}
	91	})
86	92	}
87	93
88	94	// BarPriority sets bar's priority. Zero is highest priority, i.e. bar

94	100	}
95	101	}
96	102
97		// BarNewLineExtend takes user defined efn, which gets called each
98		// render cycle. Any write to provided writer of efn, will appear on
99		// new line of respective bar.
100		func BarNewLineExtend(efn func(io.Writer, *decor.Statistics)) BarOption {
101		return func(s *bState) {
102		s.newLineExtendFn = efn
	103	// BarExtender is an option to extend bar to the next new line, with
	104	// arbitrary output.
	105	func BarExtender(extender BarFiller) BarOption {
	106	if extender == nil {
	107	return nil
	108	}
	109	return func(s *bState) {
	110	s.extender = makeExtFunc(extender)
	111	}
	112	}
	113
	114	func makeExtFunc(extender BarFiller) extFunc {
	115	buf := new(bytes.Buffer)
	116	nl := []byte("\n")
	117	return func(r io.Reader, tw int, st *decor.Statistics) (io.Reader, int) {
	118	extender.Fill(buf, tw, st)
	119	return io.MultiReader(r, buf), bytes.Count(buf.Bytes(), nl)
103	120	}
104	121	}
105	122

110	127	}
111	128	}
112	129
113		// BarStyle sets custom bar style, default one is "[=>-]<+".
114		//
115		// '[' left bracket rune
116		//
117		// '=' fill rune
118		//
119		// '>' tip rune
120		//
121		// '-' empty rune
122		//
123		// ']' right bracket rune
124		//
125		// '<' reverse tip rune, used when BarReverse option is set
126		//
127		// '+' refill rune, used when *Bar.SetRefill(int64) is called
128		//
129		// It's ok to provide first five runes only, for example mpb.BarStyle("╢▌▌░╟")
	130	// BarStyle overrides mpb.DefaultBarStyle which is "[=>-]<+".
	131	// It's ok to pass string containing just 5 runes, for example "╢▌▌░╟",
	132	// if you don't need to override '<' (reverse tip) and '+' (refill rune).
130	133	func BarStyle(style string) BarOption {
131		chk := func(filler Filler) (interface{}, bool) {
132		if style == "" {
133		return nil, false
134		}
135		t, ok := filler.(*barFiller)
136		return t, ok
137		}
138		cb := func(t interface{}) {
139		t.(*barFiller).setStyle(style)
140		}
141		return MakeFillerTypeSpecificBarOption(chk, cb)
	134	if style == "" {
	135	return nil
	136	}
	137	type styleSetter interface {
	138	SetStyle(string)
	139	}
	140	return func(s *bState) {
	141	if t, ok := s.baseF.(styleSetter); ok {
	142	t.SetStyle(style)
	143	}
	144	}
	145	}
	146
	147	// BarNoPop disables bar pop out of container. Effective when
	148	// PopCompletedMode of container is enabled.
	149	func BarNoPop() BarOption {
	150	return func(s *bState) {
	151	s.noPop = true
	152	}
142	153	}
143	154
144	155	// BarReverse reverse mode, bar will progress from right to left.
145	156	func BarReverse() BarOption {
146		chk := func(filler Filler) (interface{}, bool) {
147		t, ok := filler.(*barFiller)
148		return t, ok
149		}
150		cb := func(t interface{}) {
151		t.(*barFiller).setReverse()
152		}
153		return MakeFillerTypeSpecificBarOption(chk, cb)
	157	type revSetter interface {
	158	SetReverse(bool)
	159	}
	160	return func(s *bState) {
	161	if t, ok := s.baseF.(revSetter); ok {
	162	t.SetReverse(true)
	163	}
	164	}
154	165	}
155	166
156	167	// SpinnerStyle sets custom spinner style.
157	168	// Effective when Filler type is spinner.
158	169	func SpinnerStyle(frames []string) BarOption {
159		chk := func(filler Filler) (interface{}, bool) {
160		if len(frames) == 0 {
161		return nil, false
162		}
	170	if len(frames) == 0 {
	171	return nil
	172	}
	173	chk := func(filler BarFiller) (interface{}, bool) {
163	174	t, ok := filler.(*spinnerFiller)
164	175	return t, ok
165	176	}

173	184	// actual type. If you implement your own Filler, so most probably
174	185	// you'll need this. See BarStyle or SpinnerStyle for example.
175	186	func MakeFillerTypeSpecificBarOption(
176		typeChecker func(Filler) (interface{}, bool),
	187	typeChecker func(BarFiller) (interface{}, bool),
177	188	cb func(interface{}),
178	189	) BarOption {
179	190	return func(s *bState) {
180		if t, ok := typeChecker(s.filler); ok {
	191	if t, ok := typeChecker(s.baseF); ok {
181	192	cb(t)
182	193	}
183	194	}
184	195	}
185	196
186		// OptionOnCondition returns option when condition evaluates to true.
187		func OptionOnCondition(option BarOption, condition func() bool) BarOption {
	197	// BarOptOn returns option when condition evaluates to true.
	198	func BarOptOn(option BarOption, condition func() bool) BarOption {
188	199	if condition() {
189	200	return option
190	201	}

+81

-31

bar_test.go less more

4	4	"fmt"
5	5	"io/ioutil"
6	6	"strings"
	7	"sync/atomic"
7	8	"testing"
8	9	"time"
9	10	"unicode/utf8"
10	11
11		. "github.com/vbauerster/mpb"
12		"github.com/vbauerster/mpb/decor"
	12	. "github.com/vbauerster/mpb/v5"
	13	"github.com/vbauerster/mpb/v5/decor"
13	14	)
14	15
15	16	func TestBarCompleted(t *testing.T) {

32	33
33	34	func TestBarID(t *testing.T) {
34	35	p := New(WithOutput(ioutil.Discard))
35		total := 80
	36	total := 100
36	37	wantID := 11
37	38	bar := p.AddBar(int64(total), BarID(wantID))
38	39
39		go func() {
	40	go func(total int) {
40	41	for i := 0; i < total; i++ {
41	42	time.Sleep(50 * time.Millisecond)
42	43	bar.Increment()
43	44	}
44		}()
	45	}(total)
45	46
46	47	gotID := bar.ID()
47	48	if gotID != wantID {
48	49	t.Errorf("Expected bar id: %d, got %d\n", wantID, gotID)
49	50	}
50	51
51		p.Abort(bar, true)
	52	bar.Abort(true)
52	53	p.Wait()
53	54	}
54	55

161	162	)
162	163	got := string(getLastLine(buf.Bytes()))
163	164
164		if got != wantBar {
	165	if !strings.Contains(got, wantBar) {
165	166	t.Errorf("Want bar: %q:%d, got bar: %q:%d\n", wantBar, utf8.RuneCountInString(wantBar), got, utf8.RuneCountInString(got))
166	167	}
167	168	}
168	169
169		func TestBarPanics(t *testing.T) {
	170	func TestBarPanicBeforeComplete(t *testing.T) {
170	171	var buf bytes.Buffer
171	172	p := New(WithDebugOutput(&buf), WithOutput(ioutil.Discard))
172	173
173		wantPanic := "Upps!!!"
174		total := 100
175
176		bar := p.AddBar(int64(total), PrependDecorators(panicDecorator(wantPanic)))
177
178		go func() {
179		for i := 0; i < 100; i++ {
180		time.Sleep(10 * time.Millisecond)
181		bar.Increment()
182		}
183		}()
184
185		p.Wait()
186
187		wantPanic = fmt.Sprintf("panic: %s", wantPanic)
188		debugStr := buf.String()
189		if !strings.Contains(debugStr, wantPanic) {
190		t.Errorf("%q doesn't contain %q\n", debugStr, wantPanic)
191		}
192		}
193
194		func panicDecorator(panicMsg string) decor.Decorator {
	174	total := 100
	175	panicMsg := "Upps!!!"
	176	var pCount uint32
	177	bar := p.AddBar(int64(total),
	178	PrependDecorators(panicDecorator(panicMsg,
	179	func(st *decor.Statistics) bool {
	180	if st.Current >= 42 {
	181	atomic.AddUint32(&pCount, 1)
	182	return true
	183	}
	184	return false
	185	},
	186	)),
	187	)
	188
	189	for i := 0; i < total; i++ {
	190	time.Sleep(10 * time.Millisecond)
	191	bar.Increment()
	192	}
	193
	194	p.Wait()
	195
	196	if pCount != 1 {
	197	t.Errorf("Decor called after panic %d times\n", pCount-1)
	198	}
	199
	200	barStr := buf.String()
	201	if !strings.Contains(barStr, panicMsg) {
	202	t.Errorf("%q doesn't contain %q\n", barStr, panicMsg)
	203	}
	204	}
	205
	206	func TestBarPanicAfterComplete(t *testing.T) {
	207	var buf bytes.Buffer
	208	p := New(WithDebugOutput(&buf), WithOutput(ioutil.Discard))
	209
	210	total := 100
	211	panicMsg := "Upps!!!"
	212	var pCount uint32
	213	bar := p.AddBar(int64(total),
	214	PrependDecorators(panicDecorator(panicMsg,
	215	func(st *decor.Statistics) bool {
	216	if st.Completed {
	217	atomic.AddUint32(&pCount, 1)
	218	return true
	219	}
	220	return false
	221	},
	222	)),
	223	)
	224
	225	for i := 0; i < total; i++ {
	226	time.Sleep(10 * time.Millisecond)
	227	bar.Increment()
	228	}
	229
	230	p.Wait()
	231
	232	if pCount != 1 {
	233	t.Errorf("Decor called after panic %d times\n", pCount-1)
	234	}
	235
	236	barStr := buf.String()
	237	if !strings.Contains(barStr, panicMsg) {
	238	t.Errorf("%q doesn't contain %q\n", barStr, panicMsg)
	239	}
	240	}
	241
	242	func panicDecorator(panicMsg string, cond func(*decor.Statistics) bool) decor.Decorator {
195	243	d := &decorator{
196	244	panicMsg: panicMsg,
	245	cond: cond,
197	246	}
198	247	d.Init()
199	248	return d

202	251	type decorator struct {
203	252	decor.WC
204	253	panicMsg string
	254	cond func(*decor.Statistics) bool
205	255	}
206	256
207	257	func (d decorator) Decor(st decor.Statistics) string {
208		if st.Current >= 42 {
	258	if d.cond(st) {
209	259	panic(d.panicMsg)
210	260	}
211	261	return d.FormatMsg("")

+1

-1

barbench_test.go less more

3	3	"io/ioutil"
4	4	"testing"
5	5
6		"github.com/vbauerster/mpb/decor"
	6	"github.com/vbauerster/mpb/v5/decor"
7	7	)
8	8
9	9	func BenchmarkIncrSingleBar(b *testing.B) {

+0

-3

~~cwriter/export_test.go~~ less more

0		package cwriter
1
2		var ClearCursorAndLine = clearCursorAndLine

+18

-27

cwriter/writer.go less more

6	6	"io"
7	7	"os"
8	8
9		isatty "github.com/mattn/go-isatty"
10	9	"golang.org/x/crypto/ssh/terminal"
11	10	)
12	11
13		// ESC is the ASCII code for escape character
14		const ESC = 27
15
	12	// NotATTY not a TeleTYpewriter error.
16	13	var NotATTY = errors.New("not a terminal")
17	14
18		var (
19		cursorUp = fmt.Sprintf("%c[%dA", ESC, 1)
20		clearLine = fmt.Sprintf("%c[2K\r", ESC)
21		clearCursorAndLine = cursorUp + clearLine
22		)
	15	var cuuAndEd = fmt.Sprintf("%c[%%dA%[1]c[J", 27)
23	16
24		// Writer is a buffered the writer that updates the terminal. The
	17	// Writer is a buffered the writer that updates the terminal. The
25	18	// contents of writer will be flushed when Flush is called.
26	19	type Writer struct {
27	20	out io.Writer
28	21	buf bytes.Buffer
	22	lineCount int
	23	fd uintptr
29	24	isTerminal bool
30		fd int
31		lineCount int
32	25	}
33	26
34		// New returns a new Writer with defaults
	27	// New returns a new Writer with defaults.
35	28	func New(out io.Writer) *Writer {
36	29	w := &Writer{out: out}
37	30	if f, ok := out.(*os.File); ok {
38		fd := f.Fd()
39		w.isTerminal = isatty.IsTerminal(fd)
40		w.fd = int(fd)
	31	w.fd = f.Fd()
	32	w.isTerminal = terminal.IsTerminal(int(w.fd))
41	33	}
42	34	return w
43	35	}
44	36
45		// Flush flushes the underlying buffer
46		func (w *Writer) Flush(lineCount int) error {
47		err := w.clearLines()
	37	// Flush flushes the underlying buffer.
	38	func (w *Writer) Flush(lineCount int) (err error) {
	39	if w.lineCount > 0 {
	40	w.clearLines()
	41	}
48	42	w.lineCount = lineCount
49		// WriteTo takes care of w.buf.Reset
50		if _, e := w.buf.WriteTo(w.out); err == nil {
51		err = e
52		}
53		return err
	43	_, err = w.buf.WriteTo(w.out)
	44	return
54	45	}
55	46
56		// Write appends the contents of p to the underlying buffer
	47	// Write appends the contents of p to the underlying buffer.
57	48	func (w *Writer) Write(p []byte) (n int, err error) {
58	49	return w.buf.Write(p)
59	50	}
60	51
61		// WriteString writes string to the underlying buffer
	52	// WriteString writes string to the underlying buffer.
62	53	func (w *Writer) WriteString(s string) (n int, err error) {
63	54	return w.buf.WriteString(s)
64	55	}

72	63	// GetWidth returns width of underlying terminal.
73	64	func (w *Writer) GetWidth() (int, error) {
74	65	if w.isTerminal {
75		tw, _, err := terminal.GetSize(w.fd)
	66	tw, _, err := terminal.GetSize(int(w.fd))
76	67	return tw, err
77	68	}
78	69	return -1, NotATTY

+3

-7

cwriter/writer_posix.go less more

1	1
2	2	package cwriter
3	3
4		import (
5		"io"
6		"strings"
7		)
	4	import "fmt"
8	5
9		func (w *Writer) clearLines() error {
10		_, err := io.WriteString(w.out, strings.Repeat(clearCursorAndLine, w.lineCount))
11		return err
	6	func (w *Writer) clearLines() {
	7	fmt.Fprintf(w.out, cuuAndEd, w.lineCount)
12	8	}

+0

-36

~~cwriter/writer_posix_test.go~~ less more

0		// +build !windows
1
2		package cwriter_test
3
4		import (
5		"bytes"
6		"testing"
7
8		. "github.com/vbauerster/mpb/cwriter"
9		)
10
11		// TestWriterPosix by writing and flushing many times. The output buffer
12		// must contain the clearCursor and clearLine sequences.
13		func TestWriterPosix(t *testing.T) {
14		out := new(bytes.Buffer)
15		w := New(out)
16
17		for _, tcase := range []struct {
18		input, expectedOutput string
19		}{
20		{input: "foo\n", expectedOutput: "foo\n"},
21		{input: "bar\n", expectedOutput: "foo\n" + ClearCursorAndLine + "bar\n"},
22		{input: "fizz\n", expectedOutput: "foo\n" + ClearCursorAndLine + "bar\n" + ClearCursorAndLine + "fizz\n"},
23		} {
24		t.Run(tcase.input, func(t *testing.T) {
25		s := []byte(tcase.input)
26		lc := bytes.Count(s, []byte("\n"))
27		w.Write(s)
28		w.Flush(lc)
29		output := out.String()
30		if output != tcase.expectedOutput {
31		t.Fatalf("want %q, got %q", tcase.expectedOutput, output)
32		}
33		})
34		}
35		}

+35

-52

cwriter/writer_windows.go less more

2	2	package cwriter
3	3
4	4	import (
5		"io"
6		"strings"
	5	"fmt"
7	6	"syscall"
8	7	"unsafe"
9
10		isatty "github.com/mattn/go-isatty"
11	8	)
12	9
13	10	var kernel32 = syscall.NewLazyDLL("kernel32.dll")

19	16	procFillConsoleOutputAttribute = kernel32.NewProc("FillConsoleOutputAttribute")
20	17	)
21	18
22		type (
23		short int16
24		word uint16
25		dword uint32
26
27		coord struct {
28		x short
29		y short
30		}
31		smallRect struct {
32		left short
33		top short
34		right short
35		bottom short
36		}
37		consoleScreenBufferInfo struct {
38		size coord
39		cursorPosition coord
40		attributes word
41		window smallRect
42		maximumWindowSize coord
43		}
44		)
45
46		// FdWriter is a writer with a file descriptor.
47		type FdWriter interface {
48		io.Writer
49		Fd() uintptr
	19	type coord struct {
	20	x int16
	21	y int16
50	22	}
51	23
52		func (w *Writer) clearLines() error {
53		f, ok := w.out.(FdWriter)
54		if ok && !isatty.IsTerminal(f.Fd()) {
55		_, err := io.WriteString(w.out, strings.Repeat(clearCursorAndLine, w.lineCount))
56		return err
	24	type smallRect struct {
	25	left int16
	26	top int16
	27	right int16
	28	bottom int16
	29	}
	30
	31	type consoleScreenBufferInfo struct {
	32	size coord
	33	cursorPosition coord
	34	attributes uint16
	35	window smallRect
	36	maximumWindowSize coord
	37	}
	38
	39	func (w *Writer) clearLines() {
	40	if !w.isTerminal {
	41	fmt.Fprintf(w.out, cuuAndEd, w.lineCount)
57	42	}
58		fd := f.Fd()
59	43	var info consoleScreenBufferInfo
60		procGetConsoleScreenBufferInfo.Call(fd, uintptr(unsafe.Pointer(&info)))
	44	procGetConsoleScreenBufferInfo.Call(w.fd, uintptr(unsafe.Pointer(&info)))
61	45
62		for i := 0; i < w.lineCount; i++ {
63		// move the cursor up
64		info.cursorPosition.y--
65		procSetConsoleCursorPosition.Call(fd, uintptr((int32)(unsafe.Pointer(&info.cursorPosition))))
66		// clear the line
67		cursor := coord{
68		x: info.window.left,
69		y: info.window.top + info.cursorPosition.y,
70		}
71		var count, w dword
72		count = dword(info.size.x)
73		procFillConsoleOutputCharacter.Call(fd, uintptr(' '), uintptr(count), (uintptr)(unsafe.Pointer(&cursor)), uintptr(unsafe.Pointer(&w)))
	46	info.cursorPosition.y -= int16(w.lineCount)
	47	if info.cursorPosition.y < 0 {
	48	info.cursorPosition.y = 0
74	49	}
75		return nil
	50	procSetConsoleCursorPosition.Call(w.fd, uintptr(uint32(uint16(info.cursorPosition.y))<<16\|uint32(uint16(info.cursorPosition.x))))
	51
	52	// clear the lines
	53	cursor := coord{
	54	x: info.window.left,
	55	y: info.cursorPosition.y,
	56	}
	57	count := uint32(info.size.x) * uint32(w.lineCount)
	58	procFillConsoleOutputCharacter.Call(w.fd, uintptr(' '), uintptr(count), (uintptr)(unsafe.Pointer(&cursor)), uintptr(unsafe.Pointer(new(uint32))))
76	59	}

+21

-0

decor/any.go less more

	0	package decor
	1
	2	// Any decorator displays text, that can be changed during decorator's
	3	// lifetime via provided func call back.
	4	//
	5	// `f` call back which provides string to display
	6	//
	7	// `wcc` optional WC config
	8	//
	9	func Any(f func(*Statistics) string, wcc ...WC) Decorator {
	10	return &any{initWC(wcc...), f}
	11	}
	12
	13	type any struct {
	14	WC
	15	f func(*Statistics) string
	16	}
	17
	18	func (d any) Decor(s Statistics) string {
	19	return d.FormatMsg(d.f(s))
	20	}

+33

-174

decor/counters.go less more

1	1
2	2	import (
3	3	"fmt"
4		"io"
5		"strconv"
6		"strings"
7		)
8
9		const (
10		_ = iota
11		KiB = 1 << (iota * 10)
12		MiB
13		GiB
14		TiB
15		)
16
17		const (
18		KB = 1000
19		MB = KB * 1000
20		GB = MB * 1000
21		TB = GB * 1000
22	4	)
23	5
24	6	const (

27	9	UnitKB
28	10	)
29	11
30		type CounterKiB int64
31
32		func (c CounterKiB) Format(st fmt.State, verb rune) {
33		prec, ok := st.Precision()
34
35		if verb == 'd' \|\| !ok {
36		prec = 0
37		}
38		if verb == 'f' && !ok {
39		prec = 6
40		}
41		// retain old beahavior if s verb used
42		if verb == 's' {
43		prec = 1
44		}
45
46		var res, unit string
47		switch {
48		case c >= TiB:
49		unit = "TiB"
50		res = strconv.FormatFloat(float64(c)/TiB, 'f', prec, 64)
51		case c >= GiB:
52		unit = "GiB"
53		res = strconv.FormatFloat(float64(c)/GiB, 'f', prec, 64)
54		case c >= MiB:
55		unit = "MiB"
56		res = strconv.FormatFloat(float64(c)/MiB, 'f', prec, 64)
57		case c >= KiB:
58		unit = "KiB"
59		res = strconv.FormatFloat(float64(c)/KiB, 'f', prec, 64)
60		default:
61		unit = "b"
62		res = strconv.FormatInt(int64(c), 10)
63		}
64
65		if st.Flag(' ') {
66		res += " "
67		}
68		res += unit
69
70		if w, ok := st.Width(); ok {
71		if len(res) < w {
72		pad := strings.Repeat(" ", w-len(res))
73		if st.Flag(int('-')) {
74		res += pad
75		} else {
76		res = pad + res
77		}
78		}
79		}
80
81		io.WriteString(st, res)
82		}
83
84		type CounterKB int64
85
86		func (c CounterKB) Format(st fmt.State, verb rune) {
87		prec, ok := st.Precision()
88
89		if verb == 'd' \|\| !ok {
90		prec = 0
91		}
92		if verb == 'f' && !ok {
93		prec = 6
94		}
95		// retain old beahavior if s verb used
96		if verb == 's' {
97		prec = 1
98		}
99
100		var res, unit string
101		switch {
102		case c >= TB:
103		unit = "TB"
104		res = strconv.FormatFloat(float64(c)/TB, 'f', prec, 64)
105		case c >= GB:
106		unit = "GB"
107		res = strconv.FormatFloat(float64(c)/GB, 'f', prec, 64)
108		case c >= MB:
109		unit = "MB"
110		res = strconv.FormatFloat(float64(c)/MB, 'f', prec, 64)
111		case c >= KB:
112		unit = "kB"
113		res = strconv.FormatFloat(float64(c)/KB, 'f', prec, 64)
114		default:
115		unit = "b"
116		res = strconv.FormatInt(int64(c), 10)
117		}
118
119		if st.Flag(' ') {
120		res += " "
121		}
122		res += unit
123
124		if w, ok := st.Width(); ok {
125		if len(res) < w {
126		pad := strings.Repeat(" ", w-len(res))
127		if st.Flag(int('-')) {
128		res += pad
129		} else {
130		res = pad + res
131		}
132		}
133		}
134
135		io.WriteString(st, res)
136		}
137
138	12	// CountersNoUnit is a wrapper around Counters with no unit param.
139		func CountersNoUnit(pairFormat string, wcc ...WC) Decorator {
140		return Counters(0, pairFormat, wcc...)
	13	func CountersNoUnit(pairFmt string, wcc ...WC) Decorator {
	14	return Counters(0, pairFmt, wcc...)
141	15	}
142	16
143	17	// CountersKibiByte is a wrapper around Counters with predefined unit
144	18	// UnitKiB (bytes/1024).
145		func CountersKibiByte(pairFormat string, wcc ...WC) Decorator {
146		return Counters(UnitKiB, pairFormat, wcc...)
	19	func CountersKibiByte(pairFmt string, wcc ...WC) Decorator {
	20	return Counters(UnitKiB, pairFmt, wcc...)
147	21	}
148	22
149	23	// CountersKiloByte is a wrapper around Counters with predefined unit
150	24	// UnitKB (bytes/1000).
151		func CountersKiloByte(pairFormat string, wcc ...WC) Decorator {
152		return Counters(UnitKB, pairFormat, wcc...)
	25	func CountersKiloByte(pairFmt string, wcc ...WC) Decorator {
	26	return Counters(UnitKB, pairFmt, wcc...)
153	27	}
154	28
155	29	// Counters decorator with dynamic unit measure adjustment.
156	30	//
157	31	// `unit` one of [0\|UnitKiB\|UnitKB] zero for no unit
158	32	//
159		// `pairFormat` printf compatible verbs for current and total, like "%f" or "%d"
	33	// `pairFmt` printf compatible verbs for current and total, like "%f" or "%d"
160	34	//
161	35	// `wcc` optional WC config
162	36	//
163		// pairFormat example if UnitKB is chosen:
	37	// pairFmt example if unit=UnitKB:
164	38	//
165		// "%.1f / %.1f" = "1.0MB / 12.0MB" or "% .1f / % .1f" = "1.0 MB / 12.0 MB"
166		func Counters(unit int, pairFormat string, wcc ...WC) Decorator {
167		var wc WC
168		for _, widthConf := range wcc {
169		wc = widthConf
170		}
171		wc.Init()
172		d := &countersDecorator{
173		WC: wc,
174		unit: unit,
175		pairFormat: pairFormat,
176		}
177		return d
	39	// pairFmt="%.1f / %.1f" output: "1.0MB / 12.0MB"
	40	// pairFmt="% .1f / % .1f" output: "1.0 MB / 12.0 MB"
	41	// pairFmt="%d / %d" output: "1MB / 12MB"
	42	// pairFmt="% d / % d" output: "1 MB / 12 MB"
	43	//
	44	func Counters(unit int, pairFmt string, wcc ...WC) Decorator {
	45	return Any(chooseSizeProducer(unit, pairFmt), wcc...)
178	46	}
179	47
180		type countersDecorator struct {
181		WC
182		unit int
183		pairFormat string
184		completeMsg *string
	48	func chooseSizeProducer(unit int, format string) func(*Statistics) string {
	49	if format == "" {
	50	format = "%d / %d"
	51	}
	52	switch unit {
	53	case UnitKiB:
	54	return func(s *Statistics) string {
	55	return fmt.Sprintf(format, SizeB1024(s.Current), SizeB1024(s.Total))
	56	}
	57	case UnitKB:
	58	return func(s *Statistics) string {
	59	return fmt.Sprintf(format, SizeB1000(s.Current), SizeB1000(s.Total))
	60	}
	61	default:
	62	return func(s *Statistics) string {
	63	return fmt.Sprintf(format, s.Current, s.Total)
	64	}
	65	}
185	66	}
186
187		func (d countersDecorator) Decor(st Statistics) string {
188		if st.Completed && d.completeMsg != nil {
189		return d.FormatMsg(*d.completeMsg)
190		}
191
192		var str string
193		switch d.unit {
194		case UnitKiB:
195		str = fmt.Sprintf(d.pairFormat, CounterKiB(st.Current), CounterKiB(st.Total))
196		case UnitKB:
197		str = fmt.Sprintf(d.pairFormat, CounterKB(st.Current), CounterKB(st.Total))
198		default:
199		str = fmt.Sprintf(d.pairFormat, st.Current, st.Total)
200		}
201
202		return d.FormatMsg(str)
203		}
204
205		func (d *countersDecorator) OnCompleteMessage(msg string) {
206		d.completeMsg = &msg
207		}

+0

-142

~~decor/counters_test.go~~ less more

0		package decor
1
2		import (
3		"fmt"
4		"testing"
5		)
6
7		func TestCounterKiB(t *testing.T) {
8		cases := map[string]struct {
9		value int64
10		verb string
11		expected string
12		}{
13		"verb %f": {12345678, "%f", "11.773756MiB"},
14		"verb %.0f": {12345678, "%.0f", "12MiB"},
15		"verb %.1f": {12345678, "%.1f", "11.8MiB"},
16		"verb %.2f": {12345678, "%.2f", "11.77MiB"},
17		"verb %.3f": {12345678, "%.3f", "11.774MiB"},
18
19		"verb % f": {12345678, "% f", "11.773756 MiB"},
20		"verb % .0f": {12345678, "% .0f", "12 MiB"},
21		"verb % .1f": {12345678, "% .1f", "11.8 MiB"},
22		"verb % .2f": {12345678, "% .2f", "11.77 MiB"},
23		"verb % .3f": {12345678, "% .3f", "11.774 MiB"},
24
25		"verb %8.f": {12345678, "%8.f", " 12MiB"},
26		"verb %8.0f": {12345678, "%8.0f", " 12MiB"},
27		"verb %8.1f": {12345678, "%8.1f", " 11.8MiB"},
28		"verb %8.2f": {12345678, "%8.2f", "11.77MiB"},
29		"verb %8.3f": {12345678, "%8.3f", "11.774MiB"},
30
31		"verb % 8.f": {12345678, "% 8.f", " 12 MiB"},
32		"verb % 8.0f": {12345678, "% 8.0f", " 12 MiB"},
33		"verb % 8.1f": {12345678, "% 8.1f", "11.8 MiB"},
34
35		"verb %-8.f": {12345678, "%-8.f", "12MiB "},
36		"verb %-8.0f": {12345678, "%-8.0f", "12MiB "},
37		"verb %-8.1f": {12345678, "%-8.1f", "11.8MiB "},
38		"verb %-8.2f": {12345678, "%8.2f", "11.77MiB"},
39		"verb %-8.3f": {12345678, "%8.3f", "11.774MiB"},
40
41		"verb % -8.f": {12345678, "% -8.f", "12 MiB "},
42		"verb % -8.0f": {12345678, "% -8.0f", "12 MiB "},
43		"verb % -8.1f": {12345678, "% -8.1f", "11.8 MiB"},
44
45		"1000 %f": {1000, "%f", "1000b"},
46		"1000 %d": {1000, "%d", "1000b"},
47		"1000 %s": {1000, "%s", "1000b"},
48		"1024 %f": {1024, "%f", "1.000000KiB"},
49		"1024 %d": {1024, "%d", "1KiB"},
50		"1024 %.1f": {1024, "%.1f", "1.0KiB"},
51		"1024 %s": {1024, "%s", "1.0KiB"},
52		"3MiB+140KiB %f": {3MiB + 140*KiB, "%f", "3.136719MiB"},
53		"3MiB+140KiB %d": {3MiB + 140*KiB, "%d", "3MiB"},
54		"3MiB+140KiB %.1f": {3MiB + 140*KiB, "%.1f", "3.1MiB"},
55		"3MiB+140KiB %s": {3MiB + 140*KiB, "%s", "3.1MiB"},
56		"2GiB %f": {2 GiB, "%f", "2.000000GiB"},
57		"2GiB %d": {2 GiB, "%d", "2GiB"},
58		"2GiB %.1f": {2 GiB, "%.1f", "2.0GiB"},
59		"2GiB %s": {2 GiB, "%s", "2.0GiB"},
60		"4TiB %f": {4 TiB, "%f", "4.000000TiB"},
61		"4TiB %d": {4 TiB, "%d", "4TiB"},
62		"4TiB %.1f": {4 TiB, "%.1f", "4.0TiB"},
63		"4TiB %s": {4 TiB, "%s", "4.0TiB"},
64		}
65		for name, tc := range cases {
66		t.Run(name, func(t *testing.T) {
67		got := fmt.Sprintf(tc.verb, CounterKiB(tc.value))
68		if got != tc.expected {
69		t.Fatalf("expected: %q, got: %q\n", tc.expected, got)
70		}
71		})
72		}
73		}
74
75		func TestCounterKB(t *testing.T) {
76		cases := map[string]struct {
77		value int64
78		verb string
79		expected string
80		}{
81		"verb %f": {12345678, "%f", "12.345678MB"},
82		"verb %.0f": {12345678, "%.0f", "12MB"},
83		"verb %.1f": {12345678, "%.1f", "12.3MB"},
84		"verb %.2f": {12345678, "%.2f", "12.35MB"},
85		"verb %.3f": {12345678, "%.3f", "12.346MB"},
86
87		"verb % f": {12345678, "% f", "12.345678 MB"},
88		"verb % .0f": {12345678, "% .0f", "12 MB"},
89		"verb % .1f": {12345678, "% .1f", "12.3 MB"},
90		"verb % .2f": {12345678, "% .2f", "12.35 MB"},
91		"verb % .3f": {12345678, "% .3f", "12.346 MB"},
92
93		"verb %8.f": {12345678, "%8.f", " 12MB"},
94		"verb %8.0f": {12345678, "%8.0f", " 12MB"},
95		"verb %8.1f": {12345678, "%8.1f", " 12.3MB"},
96		"verb %8.2f": {12345678, "%8.2f", " 12.35MB"},
97		"verb %8.3f": {12345678, "%8.3f", "12.346MB"},
98
99		"verb % 8.f": {12345678, "% 8.f", " 12 MB"},
100		"verb % 8.0f": {12345678, "% 8.0f", " 12 MB"},
101		"verb % 8.1f": {12345678, "% 8.1f", " 12.3 MB"},
102
103		"verb %-8.f": {12345678, "%-8.f", "12MB "},
104		"verb %-8.0f": {12345678, "%-8.0f", "12MB "},
105		"verb %-8.1f": {12345678, "%-8.1f", "12.3MB "},
106		"verb %-8.2f": {12345678, "%8.2f", " 12.35MB"},
107		"verb %-8.3f": {12345678, "%8.3f", "12.346MB"},
108
109		"verb % -8.f": {12345678, "% -8.f", "12 MB "},
110		"verb % -8.0f": {12345678, "% -8.0f", "12 MB "},
111		"verb % -8.1f": {12345678, "% -8.1f", "12.3 MB "},
112
113		"1000 %f": {1000, "%f", "1.000000kB"},
114		"1000 %d": {1000, "%d", "1kB"},
115		"1000 %s": {1000, "%s", "1.0kB"},
116		"1024 %f": {1024, "%f", "1.024000kB"},
117		"1024 %d": {1024, "%d", "1kB"},
118		"1024 %.1f": {1024, "%.1f", "1.0kB"},
119		"1024 %s": {1024, "%s", "1.0kB"},
120		"3MB+140KB %f": {3MB + 140KB, "%f", "3.140000MB"},
121		"3MB+140KB %d": {3MB + 140KB, "%d", "3MB"},
122		"3MB+140KB %.1f": {3MB + 140KB, "%.1f", "3.1MB"},
123		"3MB+140KB %s": {3MB + 140KB, "%s", "3.1MB"},
124		"2GB %f": {2 GB, "%f", "2.000000GB"},
125		"2GB %d": {2 GB, "%d", "2GB"},
126		"2GB %.1f": {2 GB, "%.1f", "2.0GB"},
127		"2GB %s": {2 GB, "%s", "2.0GB"},
128		"4TB %f": {4 TB, "%f", "4.000000TB"},
129		"4TB %d": {4 TB, "%d", "4TB"},
130		"4TB %.1f": {4 TB, "%.1f", "4.0TB"},
131		"4TB %s": {4 TB, "%s", "4.0TB"},
132		}
133		for name, tc := range cases {
134		t.Run(name, func(t *testing.T) {
135		got := fmt.Sprintf(tc.verb, CounterKB(tc.value))
136		if got != tc.expected {
137		t.Fatalf("expected: %q, got: %q\n", tc.expected, got)
138		}
139		})
140		}
141		}

+84

-52

decor/decorator.go less more

3	3	"fmt"
4	4	"time"
5	5	"unicode/utf8"
	6
	7	"github.com/acarl005/stripansi"
6	8	)
7	9
8	10	const (

41	43	ET_STYLE_MMSS
42	44	)
43	45
44		// Statistics is a struct, which gets passed to a Decorator.
	46	// Statistics consists of progress related statistics, that Decorator
	47	// may need.
45	48	type Statistics struct {
46	49	ID int
47	50	Completed bool

50	53	}
51	54
52	55	// Decorator interface.
53		// A decorator must implement this interface, in order to be used with
54		// mpb library.
	56	// Implementors should embed WC type, that way only single method
	57	// Decor(*Statistics) needs to be implemented, the rest will be handled
	58	// by WC type.
55	59	type Decorator interface {
	60	Configurator
	61	Synchronizer
56	62	Decor(*Statistics) string
57		Syncable
58	63	}
59	64
60		// Syncable interface.
61		// All decorators implement this interface implicitly. Its Syncable
62		// method exposes width sync channel, if sync is enabled.
63		type Syncable interface {
64		Syncable() (bool, chan int)
	65	// Synchronizer interface.
	66	// All decorators implement this interface implicitly. Its Sync
	67	// method exposes width sync channel, if DSyncWidth bit is set.
	68	type Synchronizer interface {
	69	Sync() (chan int, bool)
65	70	}
66	71
67		// OnCompleteMessenger interface.
68		// Decorators implementing this interface suppose to return provided
69		// string on complete event.
70		type OnCompleteMessenger interface {
71		OnCompleteMessage(string)
	72	// Configurator interface.
	73	type Configurator interface {
	74	GetConf() WC
	75	SetConf(WC)
72	76	}
73	77
74		// AmountReceiver interface.
75		// If decorator needs to receive increment amount, so this is the right
76		// interface to implement.
77		type AmountReceiver interface {
78		NextAmount(int, ...time.Duration)
	78	// Wrapper interface.
	79	// If you're implementing custom Decorator by wrapping a built-in one,
	80	// it is necessary to implement this interface to retain functionality
	81	// of built-in Decorator.
	82	type Wrapper interface {
	83	Base() Decorator
	84	}
	85
	86	// EwmaDecorator interface.
	87	// EWMA based decorators should implement this one.
	88	type EwmaDecorator interface {
	89	EwmaUpdate(int64, time.Duration)
	90	}
	91
	92	// AverageDecorator interface.
	93	// Average decorators should implement this interface to provide start
	94	// time adjustment facility, for resume-able tasks.
	95	type AverageDecorator interface {
	96	AverageAdjust(time.Time)
79	97	}
80	98
81	99	// ShutdownListener interface.

85	103	Shutdown()
86	104	}
87	105
88		// Global convenience shortcuts
	106	// Global convenience instances of WC with sync width bit set.
	107	// To be used with multiple bars only, i.e. not effective for single bar usage.
89	108	var (
90	109	WCSyncWidth = WC{C: DSyncWidth}
91	110	WCSyncWidthR = WC{C: DSyncWidthR}

95	114
96	115	// WC is a struct with two public fields W and C, both of int type.
97	116	// W represents width and C represents bit set of width related config.
98		// A decorator should embed WC, in order to become Syncable.
	117	// A decorator should embed WC, to enable width synchronization.
99	118	type WC struct {
100		W int
101		C int
102		format string
103		wsync chan int
	119	W int
	120	C int
	121	dynFormat string
	122	wsync chan int
104	123	}
105	124
106	125	// FormatMsg formats final message according to WC.W and WC.C.
107	126	// Should be called by any Decorator implementation.
108		func (wc WC) FormatMsg(msg string) string {
	127	func (wc *WC) FormatMsg(msg string) string {
	128	var format string
	129	runeCount := utf8.RuneCountInString(stripansi.Strip(msg))
	130	ansiCount := utf8.RuneCountInString(msg) - runeCount
109	131	if (wc.C & DSyncWidth) != 0 {
110		wc.wsync <- utf8.RuneCountInString(msg)
	132	if (wc.C & DextraSpace) != 0 {
	133	runeCount++
	134	}
	135	wc.wsync <- runeCount
111	136	max := <-wc.wsync
112		if max == 0 {
113		max = wc.W
114		}
115		if (wc.C & DextraSpace) != 0 {
116		max++
117		}
118		return fmt.Sprintf(fmt.Sprintf(wc.format, max), msg)
	137	format = fmt.Sprintf(wc.dynFormat, ansiCount+max)
	138	} else {
	139	format = fmt.Sprintf(wc.dynFormat, ansiCount+wc.W)
119	140	}
120		return fmt.Sprintf(fmt.Sprintf(wc.format, wc.W), msg)
	141	return fmt.Sprintf(format, msg)
121	142	}
122	143
123	144	// Init initializes width related config.
124		func (wc *WC) Init() {
125		wc.format = "%%"
	145	func (wc *WC) Init() WC {
	146	wc.dynFormat = "%%"
126	147	if (wc.C & DidentRight) != 0 {
127		wc.format += "-"
	148	wc.dynFormat += "-"
128	149	}
129		wc.format += "%ds"
	150	wc.dynFormat += "%ds"
130	151	if (wc.C & DSyncWidth) != 0 {
	152	// it's deliberate choice to override wsync on each Init() call,
	153	// this way globals like WCSyncSpace can be reused
131	154	wc.wsync = make(chan int)
132	155	}
	156	return *wc
133	157	}
134	158
135		// Syncable is implementation of Syncable interface.
136		func (wc *WC) Syncable() (bool, chan int) {
137		return (wc.C & DSyncWidth) != 0, wc.wsync
	159	// Sync is implementation of Synchronizer interface.
	160	func (wc *WC) Sync() (chan int, bool) {
	161	if (wc.C&DSyncWidth) != 0 && wc.wsync == nil {
	162	panic(fmt.Sprintf("%T is not initialized", wc))
	163	}
	164	return wc.wsync, (wc.C & DSyncWidth) != 0
138	165	}
139	166
140		// OnComplete returns decorator, which wraps provided decorator, with
141		// sole purpose to display provided message on complete event.
142		//
143		// `decorator` Decorator to wrap
144		//
145		// `message` message to display on complete event
146		func OnComplete(decorator Decorator, message string) Decorator {
147		if d, ok := decorator.(OnCompleteMessenger); ok {
148		d.OnCompleteMessage(message)
	167	// GetConf is implementation of Configurator interface.
	168	func (wc *WC) GetConf() WC {
	169	return *wc
	170	}
	171
	172	// SetConf is implementation of Configurator interface.
	173	func (wc *WC) SetConf(conf WC) {
	174	*wc = conf.Init()
	175	}
	176
	177	func initWC(wcc ...WC) WC {
	178	var wc WC
	179	for _, nwc := range wcc {
	180	wc = nwc
149	181	}
150		return decorator
	182	return wc.Init()
151	183	}

+1

-5

decor/doc.go less more

0		// Copyright (C) 2016-2018 Vladimir Bauer
1		// Use of this source code is governed by a BSD-style
2		// license that can be found in the LICENSE file.
3
4	0	/*
5		Package decor contains common decorators used by "github.com/vbauerster/mpb" package.
	1	Package decor provides common decorators for "github.com/vbauerster/mpb/v5" module.
6	2
7	3	Some decorators returned by this package might have a closure state. It is ok to use
8	4	decorators concurrently, unless you share the same decorator among multiple

+21

-54

decor/elapsed.go less more

0	0	package decor
1	1
2	2	import (
3		"fmt"
4	3	"time"
5	4	)
6	5
7		// Elapsed returns elapsed time decorator.
	6	// Elapsed decorator. It's wrapper of NewElapsed.
8	7	//
9	8	// `style` one of [ET_STYLE_GO\|ET_STYLE_HHMMSS\|ET_STYLE_HHMM\|ET_STYLE_MMSS]
10	9	//
11	10	// `wcc` optional WC config
	11	//
12	12	func Elapsed(style TimeStyle, wcc ...WC) Decorator {
13		var wc WC
14		for _, widthConf := range wcc {
15		wc = widthConf
16		}
17		wc.Init()
18		d := &elapsedDecorator{
19		WC: wc,
20		style: style,
21		startTime: time.Now(),
22		}
23		return d
	13	return NewElapsed(style, time.Now(), wcc...)
24	14	}
25	15
26		type elapsedDecorator struct {
27		WC
28		style TimeStyle
29		startTime time.Time
30		msg string
31		completeMsg *string
	16	// NewElapsed returns elapsed time decorator.
	17	//
	18	// `style` one of [ET_STYLE_GO\|ET_STYLE_HHMMSS\|ET_STYLE_HHMM\|ET_STYLE_MMSS]
	19	//
	20	// `startTime` start time
	21	//
	22	// `wcc` optional WC config
	23	//
	24	func NewElapsed(style TimeStyle, startTime time.Time, wcc ...WC) Decorator {
	25	var msg string
	26	producer := chooseTimeProducer(style)
	27	f := func(s *Statistics) string {
	28	if !s.Completed {
	29	msg = producer(time.Since(startTime))
	30	}
	31	return msg
	32	}
	33	return Any(f, wcc...)
32	34	}
33
34		func (d elapsedDecorator) Decor(st Statistics) string {
35		if st.Completed {
36		if d.completeMsg != nil {
37		return d.FormatMsg(*d.completeMsg)
38		}
39		return d.FormatMsg(d.msg)
40		}
41
42		timeElapsed := time.Since(d.startTime)
43		hours := int64((timeElapsed / time.Hour) % 60)
44		minutes := int64((timeElapsed / time.Minute) % 60)
45		seconds := int64((timeElapsed / time.Second) % 60)
46
47		switch d.style {
48		case ET_STYLE_GO:
49		d.msg = fmt.Sprint(time.Duration(timeElapsed.Seconds()) * time.Second)
50		case ET_STYLE_HHMMSS:
51		d.msg = fmt.Sprintf("%02d:%02d:%02d", hours, minutes, seconds)
52		case ET_STYLE_HHMM:
53		d.msg = fmt.Sprintf("%02d:%02d", hours, minutes)
54		case ET_STYLE_MMSS:
55		if hours > 0 {
56		d.msg = fmt.Sprintf("%02d:%02d:%02d", hours, minutes, seconds)
57		} else {
58		d.msg = fmt.Sprintf("%02d:%02d", minutes, seconds)
59		}
60		}
61
62		return d.FormatMsg(d.msg)
63		}
64
65		func (d *elapsedDecorator) OnCompleteMessage(msg string) {
66		d.completeMsg = &msg
67		}

+140

-143

decor/eta.go less more

7	7	"github.com/VividCortex/ewma"
8	8	)
9	9
10		type TimeNormalizer func(time.Duration) time.Duration
	10	// TimeNormalizer interface. Implementors could be passed into
	11	// MovingAverageETA, in order to affect i.e. normalize its output.
	12	type TimeNormalizer interface {
	13	Normalize(time.Duration) time.Duration
	14	}
	15
	16	// TimeNormalizerFunc is function type adapter to convert function
	17	// into TimeNormalizer.
	18	type TimeNormalizerFunc func(time.Duration) time.Duration
	19
	20	func (f TimeNormalizerFunc) Normalize(src time.Duration) time.Duration {
	21	return f(src)
	22	}
11	23
12	24	// EwmaETA exponential-weighted-moving-average based ETA decorator.
	25	// For this decorator to work correctly you have to measure each
	26	// iteration's duration and pass it to the
	27	// *Bar.DecoratorEwmaUpdate(time.Duration) method after each increment.
	28	func EwmaETA(style TimeStyle, age float64, wcc ...WC) Decorator {
	29	var average ewma.MovingAverage
	30	if age == 0 {
	31	average = ewma.NewMovingAverage()
	32	} else {
	33	average = ewma.NewMovingAverage(age)
	34	}
	35	return MovingAverageETA(style, NewThreadSafeMovingAverage(average), nil, wcc...)
	36	}
	37
	38	// MovingAverageETA decorator relies on MovingAverage implementation to calculate its average.
13	39	//
14	40	// `style` one of [ET_STYLE_GO\|ET_STYLE_HHMMSS\|ET_STYLE_HHMM\|ET_STYLE_MMSS]
15	41	//
16		// `age` is the previous N samples to average over.
	42	// `average` implementation of MovingAverage interface
	43	//
	44	// `normalizer` available implementations are [FixedIntervalTimeNormalizer\|MaxTolerateTimeNormalizer]
17	45	//
18	46	// `wcc` optional WC config
19		func EwmaETA(style TimeStyle, age float64, wcc ...WC) Decorator {
20		return MovingAverageETA(style, ewma.NewMovingAverage(age), NopNormalizer(), wcc...)
21		}
22
23		// MovingAverageETA decorator relies on MovingAverage implementation to calculate its average.
24		//
25		// `style` one of [ET_STYLE_GO\|ET_STYLE_HHMMSS\|ET_STYLE_HHMM\|ET_STYLE_MMSS]
26		//
27		// `average` available implementations of MovingAverage [ewma.MovingAverage\|NewMedian\|NewMedianEwma]
28		//
29		// `normalizer` available implementations are [NopNormalizer\|FixedIntervalTimeNormalizer\|MaxTolerateTimeNormalizer]
30		//
31		// `wcc` optional WC config
32		func MovingAverageETA(style TimeStyle, average MovingAverage, normalizer TimeNormalizer, wcc ...WC) Decorator {
33		var wc WC
34		for _, widthConf := range wcc {
35		wc = widthConf
36		}
37		wc.Init()
	47	//
	48	func MovingAverageETA(style TimeStyle, average ewma.MovingAverage, normalizer TimeNormalizer, wcc ...WC) Decorator {
38	49	d := &movingAverageETA{
39		WC: wc,
40		style: style,
	50	WC: initWC(wcc...),
41	51	average: average,
42	52	normalizer: normalizer,
	53	producer: chooseTimeProducer(style),
43	54	}
44	55	return d
45	56	}
46	57
47	58	type movingAverageETA struct {
48	59	WC
49		style TimeStyle
50		average ewma.MovingAverage
51		completeMsg *string
52		normalizer TimeNormalizer
53		}
54
55		func (d movingAverageETA) Decor(st Statistics) string {
56		if st.Completed && d.completeMsg != nil {
57		return d.FormatMsg(*d.completeMsg)
58		}
59
	60	average ewma.MovingAverage
	61	normalizer TimeNormalizer
	62	producer func(time.Duration) string
	63	}
	64
	65	func (d movingAverageETA) Decor(s Statistics) string {
60	66	v := math.Round(d.average.Value())
61		remaining := d.normalizer(time.Duration((st.Total - st.Current) * int64(v)))
62		hours := int64((remaining / time.Hour) % 60)
63		minutes := int64((remaining / time.Minute) % 60)
64		seconds := int64((remaining / time.Second) % 60)
65
66		var str string
67		switch d.style {
68		case ET_STYLE_GO:
69		str = fmt.Sprint(time.Duration(remaining.Seconds()) * time.Second)
70		case ET_STYLE_HHMMSS:
71		str = fmt.Sprintf("%02d:%02d:%02d", hours, minutes, seconds)
72		case ET_STYLE_HHMM:
73		str = fmt.Sprintf("%02d:%02d", hours, minutes)
74		case ET_STYLE_MMSS:
75		if hours > 0 {
76		str = fmt.Sprintf("%02d:%02d:%02d", hours, minutes, seconds)
77		} else {
78		str = fmt.Sprintf("%02d:%02d", minutes, seconds)
79		}
80		}
81
82		return d.FormatMsg(str)
83		}
84
85		func (d *movingAverageETA) NextAmount(n int, wdd ...time.Duration) {
86		var workDuration time.Duration
87		for _, wd := range wdd {
88		workDuration = wd
89		}
90		lastItemEstimate := float64(workDuration) / float64(n)
91		if math.IsInf(lastItemEstimate, 0) \|\| math.IsNaN(lastItemEstimate) {
	67	remaining := time.Duration((s.Total - s.Current) * int64(v))
	68	if d.normalizer != nil {
	69	remaining = d.normalizer.Normalize(remaining)
	70	}
	71	return d.FormatMsg(d.producer(remaining))
	72	}
	73
	74	func (d *movingAverageETA) EwmaUpdate(n int64, dur time.Duration) {
	75	durPerItem := float64(dur) / float64(n)
	76	if math.IsInf(durPerItem, 0) \|\| math.IsNaN(durPerItem) {
92	77	return
93	78	}
94		d.average.Add(lastItemEstimate)
95		}
96
97		func (d *movingAverageETA) OnCompleteMessage(msg string) {
98		d.completeMsg = &msg
99		}
100
101		// AverageETA decorator.
	79	d.average.Add(durPerItem)
	80	}
	81
	82	// AverageETA decorator. It's wrapper of NewAverageETA.
102	83	//
103	84	// `style` one of [ET_STYLE_GO\|ET_STYLE_HHMMSS\|ET_STYLE_HHMM\|ET_STYLE_MMSS]
104	85	//
105	86	// `wcc` optional WC config
	87	//
106	88	func AverageETA(style TimeStyle, wcc ...WC) Decorator {
107		var wc WC
108		for _, widthConf := range wcc {
109		wc = widthConf
110		}
111		wc.Init()
	89	return NewAverageETA(style, time.Now(), nil, wcc...)
	90	}
	91
	92	// NewAverageETA decorator with user provided start time.
	93	//
	94	// `style` one of [ET_STYLE_GO\|ET_STYLE_HHMMSS\|ET_STYLE_HHMM\|ET_STYLE_MMSS]
	95	//
	96	// `startTime` start time
	97	//
	98	// `normalizer` available implementations are [FixedIntervalTimeNormalizer\|MaxTolerateTimeNormalizer]
	99	//
	100	// `wcc` optional WC config
	101	//
	102	func NewAverageETA(style TimeStyle, startTime time.Time, normalizer TimeNormalizer, wcc ...WC) Decorator {
112	103	d := &averageETA{
113		WC: wc,
114		style: style,
115		startTime: time.Now(),
	104	WC: initWC(wcc...),
	105	startTime: startTime,
	106	normalizer: normalizer,
	107	producer: chooseTimeProducer(style),
116	108	}
117	109	return d
118	110	}
119	111
120	112	type averageETA struct {
121	113	WC
122		style TimeStyle
123		startTime time.Time
124		completeMsg *string
125		}
126
127		func (d averageETA) Decor(st Statistics) string {
128		if st.Completed && d.completeMsg != nil {
129		return d.FormatMsg(*d.completeMsg)
130		}
131
132		var str string
133		timeElapsed := time.Since(d.startTime)
134		v := math.Round(float64(timeElapsed) / float64(st.Current))
135		if math.IsInf(v, 0) \|\| math.IsNaN(v) {
136		v = 0
137		}
138		remaining := time.Duration((st.Total - st.Current) * int64(v))
139		hours := int64((remaining / time.Hour) % 60)
140		minutes := int64((remaining / time.Minute) % 60)
141		seconds := int64((remaining / time.Second) % 60)
142
143		switch d.style {
144		case ET_STYLE_GO:
145		str = fmt.Sprint(time.Duration(remaining.Seconds()) * time.Second)
146		case ET_STYLE_HHMMSS:
147		str = fmt.Sprintf("%02d:%02d:%02d", hours, minutes, seconds)
148		case ET_STYLE_HHMM:
149		str = fmt.Sprintf("%02d:%02d", hours, minutes)
150		case ET_STYLE_MMSS:
151		if hours > 0 {
152		str = fmt.Sprintf("%02d:%02d:%02d", hours, minutes, seconds)
153		} else {
154		str = fmt.Sprintf("%02d:%02d", minutes, seconds)
155		}
156		}
157
158		return d.FormatMsg(str)
159		}
160
161		func (d *averageETA) OnCompleteMessage(msg string) {
162		d.completeMsg = &msg
163		}
164
	114	startTime time.Time
	115	normalizer TimeNormalizer
	116	producer func(time.Duration) string
	117	}
	118
	119	func (d averageETA) Decor(s Statistics) string {
	120	var remaining time.Duration
	121	if s.Current != 0 {
	122	durPerItem := float64(time.Since(d.startTime)) / float64(s.Current)
	123	durPerItem = math.Round(durPerItem)
	124	remaining = time.Duration((s.Total - s.Current) * int64(durPerItem))
	125	if d.normalizer != nil {
	126	remaining = d.normalizer.Normalize(remaining)
	127	}
	128	}
	129	return d.FormatMsg(d.producer(remaining))
	130	}
	131
	132	func (d *averageETA) AverageAdjust(startTime time.Time) {
	133	d.startTime = startTime
	134	}
	135
	136	// MaxTolerateTimeNormalizer returns implementation of TimeNormalizer.
165	137	func MaxTolerateTimeNormalizer(maxTolerate time.Duration) TimeNormalizer {
166	138	var normalized time.Duration
167	139	var lastCall time.Time
168		return func(remaining time.Duration) time.Duration {
169		if diff := normalized - remaining; diff <= 0 \|\| diff > maxTolerate \|\| remaining < maxTolerate/2 {
	140	return TimeNormalizerFunc(func(remaining time.Duration) time.Duration {
	141	if diff := normalized - remaining; diff <= 0 \|\| diff > maxTolerate \|\| remaining < time.Minute {
170	142	normalized = remaining
171	143	lastCall = time.Now()
172	144	return remaining

174	146	normalized -= time.Since(lastCall)
175	147	lastCall = time.Now()
176	148	return normalized
177		}
178		}
179
	149	})
	150	}
	151
	152	// FixedIntervalTimeNormalizer returns implementation of TimeNormalizer.
180	153	func FixedIntervalTimeNormalizer(updInterval int) TimeNormalizer {
181	154	var normalized time.Duration
182	155	var lastCall time.Time
183	156	var count int
184		return func(remaining time.Duration) time.Duration {
185		if count == 0 \|\| remaining <= time.Duration(15*time.Second) {
	157	return TimeNormalizerFunc(func(remaining time.Duration) time.Duration {
	158	if count == 0 \|\| remaining < time.Minute {
186	159	count = updInterval
187	160	normalized = remaining
188	161	lastCall = time.Now()

191	164	count--
192	165	normalized -= time.Since(lastCall)
193	166	lastCall = time.Now()
194		if normalized > 0 {
195		return normalized
196		}
197		return remaining
198		}
199		}
200
201		func NopNormalizer() TimeNormalizer {
202		return func(remaining time.Duration) time.Duration {
203		return remaining
204		}
205		}
	167	return normalized
	168	})
	169	}
	170
	171	func chooseTimeProducer(style TimeStyle) func(time.Duration) string {
	172	switch style {
	173	case ET_STYLE_HHMMSS:
	174	return func(remaining time.Duration) string {
	175	hours := int64(remaining/time.Hour) % 60
	176	minutes := int64(remaining/time.Minute) % 60
	177	seconds := int64(remaining/time.Second) % 60
	178	return fmt.Sprintf("%02d:%02d:%02d", hours, minutes, seconds)
	179	}
	180	case ET_STYLE_HHMM:
	181	return func(remaining time.Duration) string {
	182	hours := int64(remaining/time.Hour) % 60
	183	minutes := int64(remaining/time.Minute) % 60
	184	return fmt.Sprintf("%02d:%02d", hours, minutes)
	185	}
	186	case ET_STYLE_MMSS:
	187	return func(remaining time.Duration) string {
	188	hours := int64(remaining/time.Hour) % 60
	189	minutes := int64(remaining/time.Minute) % 60
	190	seconds := int64(remaining/time.Second) % 60
	191	if hours > 0 {
	192	return fmt.Sprintf("%02d:%02d:%02d", hours, minutes, seconds)
	193	}
	194	return fmt.Sprintf("%02d:%02d", minutes, seconds)
	195	}
	196	default:
	197	return func(remaining time.Duration) string {
	198	// strip off nanoseconds
	199	return ((remaining / time.Second) * time.Second).String()
	200	}
	201	}
	202	}

+106

-0

decor/merge.go less more

	0	package decor
	1
	2	import (
	3	"fmt"
	4	"strings"
	5	"unicode/utf8"
	6	)
	7
	8	// Merge wraps its decorator argument with intention to sync width
	9	// with several decorators of another bar. Visual example:
	10	//
	11	// +----+--------+---------+--------+
	12	// \| B1 \| MERGE(D, P1, Pn) \|
	13	// +----+--------+---------+--------+
	14	// \| B2 \| D0 \| D1 \| Dn \|
	15	// +----+--------+---------+--------+
	16	//
	17	func Merge(decorator Decorator, placeholders ...WC) Decorator {
	18	if _, ok := decorator.Sync(); !ok \|\| len(placeholders) == 0 {
	19	return decorator
	20	}
	21	md := &mergeDecorator{
	22	Decorator: decorator,
	23	wc: decorator.GetConf(),
	24	placeHolders: make([]*placeHolderDecorator, len(placeholders)),
	25	}
	26	decorator.SetConf(WC{})
	27	for i, wc := range placeholders {
	28	if (wc.C & DSyncWidth) == 0 {
	29	return decorator
	30	}
	31	md.placeHolders[i] = &placeHolderDecorator{wc.Init()}
	32	}
	33	return md
	34	}
	35
	36	type mergeDecorator struct {
	37	Decorator
	38	wc WC
	39	placeHolders []*placeHolderDecorator
	40	}
	41
	42	func (d *mergeDecorator) GetConf() WC {
	43	return d.wc
	44	}
	45
	46	func (d *mergeDecorator) SetConf(conf WC) {
	47	d.wc = conf.Init()
	48	}
	49
	50	func (d *mergeDecorator) MergeUnwrap() []Decorator {
	51	decorators := make([]Decorator, len(d.placeHolders))
	52	for i, ph := range d.placeHolders {
	53	decorators[i] = ph
	54	}
	55	return decorators
	56	}
	57
	58	func (d *mergeDecorator) Sync() (chan int, bool) {
	59	return d.wc.Sync()
	60	}
	61
	62	func (d *mergeDecorator) Base() Decorator {
	63	return d.Decorator
	64	}
	65
	66	func (d mergeDecorator) Decor(s Statistics) string {
	67	msg := d.Decorator.Decor(s)
	68	msgLen := utf8.RuneCountInString(msg)
	69	if (d.wc.C & DextraSpace) != 0 {
	70	msgLen++
	71	}
	72
	73	var total int
	74	max := utf8.RuneCountInString(d.placeHolders[0].FormatMsg(""))
	75	total += max
	76	pw := (msgLen - max) / len(d.placeHolders)
	77	rem := (msgLen - max) % len(d.placeHolders)
	78
	79	var diff int
	80	for i := 1; i < len(d.placeHolders); i++ {
	81	ph := d.placeHolders[i]
	82	width := pw - diff
	83	if (ph.WC.C & DextraSpace) != 0 {
	84	width--
	85	if width < 0 {
	86	width = 0
	87	}
	88	}
	89	max = utf8.RuneCountInString(ph.FormatMsg(strings.Repeat(" ", width)))
	90	total += max
	91	diff = max - pw
	92	}
	93
	94	d.wc.wsync <- pw + rem
	95	max = <-d.wc.wsync
	96	return fmt.Sprintf(fmt.Sprintf(d.wc.dynFormat, max+total), msg)
	97	}
	98
	99	type placeHolderDecorator struct {
	100	WC
	101	}
	102
	103	func (d placeHolderDecorator) Decor(Statistics) string {
	104	return ""
	105	}

+0

-67

~~decor/moving-average.go~~ less more

0		package decor
1
2		import (
3		"sort"
4
5		"github.com/VividCortex/ewma"
6		)
7
8		// MovingAverage is the interface that computes a moving average over
9		// a time-series stream of numbers. The average may be over a window
10		// or exponentially decaying.
11		type MovingAverage interface {
12		Add(float64)
13		Value() float64
14		Set(float64)
15		}
16
17		type medianWindow [3]float64
18
19		func (s *medianWindow) Len() int { return len(s) }
20		func (s *medianWindow) Swap(i, j int) { s[i], s[j] = s[j], s[i] }
21		func (s *medianWindow) Less(i, j int) bool { return s[i] < s[j] }
22
23		func (s *medianWindow) Add(value float64) {
24		s[0], s[1] = s[1], s[2]
25		s[2] = value
26		}
27
28		func (s *medianWindow) Value() float64 {
29		tmp := *s
30		sort.Sort(&tmp)
31		return tmp[1]
32		}
33
34		func (s *medianWindow) Set(value float64) {
35		for i := 0; i < len(s); i++ {
36		s[i] = value
37		}
38		}
39
40		// NewMedian is fixed last 3 samples median MovingAverage.
41		func NewMedian() MovingAverage {
42		return new(medianWindow)
43		}
44
45		type medianEwma struct {
46		count uint
47		median MovingAverage
48		MovingAverage
49		}
50
51		func (s *medianEwma) Add(v float64) {
52		s.median.Add(v)
53		if s.count >= 2 {
54		s.MovingAverage.Add(s.median.Value())
55		}
56		s.count++
57		}
58
59		// NewMedianEwma is ewma based MovingAverage, which gets its values
60		// from median MovingAverage.
61		func NewMedianEwma(age ...float64) MovingAverage {
62		return &medianEwma{
63		MovingAverage: ewma.NewMovingAverage(age...),
64		median: NewMedian(),
65		}
66		}

+68

-0

decor/moving_average.go less more

	0	package decor
	1
	2	import (
	3	"sort"
	4	"sync"
	5
	6	"github.com/VividCortex/ewma"
	7	)
	8
	9	type threadSafeMovingAverage struct {
	10	ewma.MovingAverage
	11	mu sync.Mutex
	12	}
	13
	14	func (s *threadSafeMovingAverage) Add(value float64) {
	15	s.mu.Lock()
	16	s.MovingAverage.Add(value)
	17	s.mu.Unlock()
	18	}
	19
	20	func (s *threadSafeMovingAverage) Value() float64 {
	21	s.mu.Lock()
	22	defer s.mu.Unlock()
	23	return s.MovingAverage.Value()
	24	}
	25
	26	func (s *threadSafeMovingAverage) Set(value float64) {
	27	s.mu.Lock()
	28	s.MovingAverage.Set(value)
	29	s.mu.Unlock()
	30	}
	31
	32	// NewThreadSafeMovingAverage converts provided ewma.MovingAverage
	33	// into thread safe ewma.MovingAverage.
	34	func NewThreadSafeMovingAverage(average ewma.MovingAverage) ewma.MovingAverage {
	35	if tsma, ok := average.(*threadSafeMovingAverage); ok {
	36	return tsma
	37	}
	38	return &threadSafeMovingAverage{MovingAverage: average}
	39	}
	40
	41	type medianWindow [3]float64
	42
	43	func (s *medianWindow) Len() int { return len(s) }
	44	func (s *medianWindow) Swap(i, j int) { s[i], s[j] = s[j], s[i] }
	45	func (s *medianWindow) Less(i, j int) bool { return s[i] < s[j] }
	46
	47	func (s *medianWindow) Add(value float64) {
	48	s[0], s[1] = s[1], s[2]
	49	s[2] = value
	50	}
	51
	52	func (s *medianWindow) Value() float64 {
	53	tmp := *s
	54	sort.Sort(&tmp)
	55	return tmp[1]
	56	}
	57
	58	func (s *medianWindow) Set(value float64) {
	59	for i := 0; i < len(s); i++ {
	60	s[i] = value
	61	}
	62	}
	63
	64	// NewMedian is fixed last 3 samples median MovingAverage.
	65	func NewMedian() ewma.MovingAverage {
	66	return NewThreadSafeMovingAverage(new(medianWindow))
	67	}

+6

-39

decor/name.go less more

0	0	package decor
1	1
2		// StaticName returns name decorator.
	2	// Name decorator displays text that is set once and can't be changed
	3	// during decorator's lifetime.
3	4	//
4		// `name` string to display
	5	// `str` string to display
5	6	//
6	7	// `wcc` optional WC config
7		func StaticName(name string, wcc ...WC) Decorator {
8		return Name(name, wcc...)
	8	//
	9	func Name(str string, wcc ...WC) Decorator {
	10	return Any(func(*Statistics) string { return str }, wcc...)
9	11	}
10
11		// Name returns name decorator.
12		//
13		// `name` string to display
14		//
15		// `wcc` optional WC config
16		func Name(name string, wcc ...WC) Decorator {
17		var wc WC
18		for _, widthConf := range wcc {
19		wc = widthConf
20		}
21		wc.Init()
22		d := &nameDecorator{
23		WC: wc,
24		msg: name,
25		}
26		return d
27		}
28
29		type nameDecorator struct {
30		WC
31		msg string
32		complete *string
33		}
34
35		func (d nameDecorator) Decor(st Statistics) string {
36		if st.Completed && d.complete != nil {
37		return d.FormatMsg(*d.complete)
38		}
39		return d.FormatMsg(d.msg)
40		}
41
42		func (d *nameDecorator) OnCompleteMessage(msg string) {
43		d.complete = &msg
44		}

+37

-0

decor/on_complete.go less more

	0	package decor
	1
	2	// OnComplete returns decorator, which wraps provided decorator, with
	3	// sole purpose to display provided message on complete event.
	4	//
	5	// `decorator` Decorator to wrap
	6	//
	7	// `message` message to display on complete event
	8	//
	9	func OnComplete(decorator Decorator, message string) Decorator {
	10	d := &onCompleteWrapper{
	11	Decorator: decorator,
	12	msg: message,
	13	}
	14	if md, ok := decorator.(*mergeDecorator); ok {
	15	d.Decorator, md.Decorator = md.Decorator, d
	16	return md
	17	}
	18	return d
	19	}
	20
	21	type onCompleteWrapper struct {
	22	Decorator
	23	msg string
	24	}
	25
	26	func (d onCompleteWrapper) Decor(s Statistics) string {
	27	if s.Completed {
	28	wc := d.GetConf()
	29	return wc.FormatMsg(d.msg)
	30	}
	31	return d.Decorator.Decor(s)
	32	}
	33
	34	func (d *onCompleteWrapper) Base() Decorator {
	35	return d.Decorator
	36	}

+43

-24

decor/percentage.go less more

1	1
2	2	import (
3	3	"fmt"
	4	"io"
	5	"strconv"
4	6
5		"github.com/vbauerster/mpb/internal"
	7	"github.com/vbauerster/mpb/v5/internal"
6	8	)
7	9
8		// Percentage returns percentage decorator.
9		//
10		// `wcc` optional WC config
11		func Percentage(wcc ...WC) Decorator {
12		var wc WC
13		for _, widthConf := range wcc {
14		wc = widthConf
	10	type percentageType float64
	11
	12	func (s percentageType) Format(st fmt.State, verb rune) {
	13	var prec int
	14	switch verb {
	15	case 'd':
	16	case 's':
	17	prec = -1
	18	default:
	19	if p, ok := st.Precision(); ok {
	20	prec = p
	21	} else {
	22	prec = 6
	23	}
15	24	}
16		wc.Init()
17		d := &percentageDecorator{
18		WC: wc,
	25
	26	io.WriteString(st, strconv.FormatFloat(float64(s), 'f', prec, 64))
	27
	28	if st.Flag(' ') {
	29	io.WriteString(st, " ")
19	30	}
20		return d
	31	io.WriteString(st, "%")
21	32	}
22	33
23		type percentageDecorator struct {
24		WC
25		completeMsg *string
	34	// Percentage returns percentage decorator. It's a wrapper of NewPercentage.
	35	func Percentage(wcc ...WC) Decorator {
	36	return NewPercentage("% d", wcc...)
26	37	}
27	38
28		func (d percentageDecorator) Decor(st Statistics) string {
29		if st.Completed && d.completeMsg != nil {
30		return d.FormatMsg(*d.completeMsg)
	39	// NewPercentage percentage decorator with custom format string.
	40	//
	41	// format examples:
	42	//
	43	// format="%.1f" output: "1.0%"
	44	// format="% .1f" output: "1.0 %"
	45	// format="%d" output: "1%"
	46	// format="% d" output: "1 %"
	47	//
	48	func NewPercentage(format string, wcc ...WC) Decorator {
	49	if format == "" {
	50	format = "% d"
31	51	}
32		str := fmt.Sprintf("%d %%", internal.Percentage(st.Total, st.Current, 100))
33		return d.FormatMsg(str)
	52	f := func(s *Statistics) string {
	53	p := internal.Percentage(s.Total, s.Current, 100)
	54	return fmt.Sprintf(format, percentageType(p))
	55	}
	56	return Any(f, wcc...)
34	57	}
35
36		func (d *percentageDecorator) OnCompleteMessage(msg string) {
37		d.completeMsg = &msg
38		}

+109

-0

decor/size_type.go less more

	0	package decor
	1
	2	import (
	3	"fmt"
	4	"io"
	5	"math"
	6	"strconv"
	7	)
	8
	9	//go:generate stringer -type=SizeB1024 -trimprefix=_i
	10	//go:generate stringer -type=SizeB1000 -trimprefix=_
	11
	12	const (
	13	_ib SizeB1024 = iota + 1
	14	_iKiB SizeB1024 = 1 << (iota * 10)
	15	_iMiB
	16	_iGiB
	17	_iTiB
	18	)
	19
	20	// SizeB1024 named type, which implements fmt.Formatter interface. It
	21	// adjusts its value according to byte size multiple by 1024 and appends
	22	// appropriate size marker (KiB, MiB, GiB, TiB).
	23	type SizeB1024 int64
	24
	25	func (self SizeB1024) Format(st fmt.State, verb rune) {
	26	var prec int
	27	switch verb {
	28	case 'd':
	29	case 's':
	30	prec = -1
	31	default:
	32	if p, ok := st.Precision(); ok {
	33	prec = p
	34	} else {
	35	prec = 6
	36	}
	37	}
	38
	39	var unit SizeB1024
	40	switch {
	41	case self < _iKiB:
	42	unit = _ib
	43	case self < _iMiB:
	44	unit = _iKiB
	45	case self < _iGiB:
	46	unit = _iMiB
	47	case self < _iTiB:
	48	unit = _iGiB
	49	case self <= math.MaxInt64:
	50	unit = _iTiB
	51	}
	52
	53	io.WriteString(st, strconv.FormatFloat(float64(self)/float64(unit), 'f', prec, 64))
	54
	55	if st.Flag(' ') {
	56	io.WriteString(st, " ")
	57	}
	58	io.WriteString(st, unit.String())
	59	}
	60
	61	const (
	62	_b SizeB1000 = 1
	63	_KB SizeB1000 = _b * 1000
	64	_MB SizeB1000 = _KB * 1000
	65	_GB SizeB1000 = _MB * 1000
	66	_TB SizeB1000 = _GB * 1000
	67	)
	68
	69	// SizeB1000 named type, which implements fmt.Formatter interface. It
	70	// adjusts its value according to byte size multiple by 1000 and appends
	71	// appropriate size marker (KB, MB, GB, TB).
	72	type SizeB1000 int64
	73
	74	func (self SizeB1000) Format(st fmt.State, verb rune) {
	75	var prec int
	76	switch verb {
	77	case 'd':
	78	case 's':
	79	prec = -1
	80	default:
	81	if p, ok := st.Precision(); ok {
	82	prec = p
	83	} else {
	84	prec = 6
	85	}
	86	}
	87
	88	var unit SizeB1000
	89	switch {
	90	case self < _KB:
	91	unit = _b
	92	case self < _MB:
	93	unit = _KB
	94	case self < _GB:
	95	unit = _MB
	96	case self < _TB:
	97	unit = _GB
	98	case self <= math.MaxInt64:
	99	unit = _TB
	100	}
	101
	102	io.WriteString(st, strconv.FormatFloat(float64(self)/float64(unit), 'f', prec, 64))
	103
	104	if st.Flag(' ') {
	105	io.WriteString(st, " ")
	106	}
	107	io.WriteString(st, unit.String())
	108	}

+102

-0

decor/size_type_test.go less more

	0	package decor
	1
	2	import (
	3	"fmt"
	4	"testing"
	5	)
	6
	7	func TestB1024(t *testing.T) {
	8	cases := map[string]struct {
	9	value int64
	10	verb string
	11	expected string
	12	}{
	13	"verb %f": {12345678, "%f", "11.773756MiB"},
	14	"verb %.0f": {12345678, "%.0f", "12MiB"},
	15	"verb %.1f": {12345678, "%.1f", "11.8MiB"},
	16	"verb %.2f": {12345678, "%.2f", "11.77MiB"},
	17	"verb %.3f": {12345678, "%.3f", "11.774MiB"},
	18
	19	"verb % f": {12345678, "% f", "11.773756 MiB"},
	20	"verb % .0f": {12345678, "% .0f", "12 MiB"},
	21	"verb % .1f": {12345678, "% .1f", "11.8 MiB"},
	22	"verb % .2f": {12345678, "% .2f", "11.77 MiB"},
	23	"verb % .3f": {12345678, "% .3f", "11.774 MiB"},
	24
	25	"1000 %f": {1000, "%f", "1000.000000b"},
	26	"1000 %d": {1000, "%d", "1000b"},
	27	"1000 %s": {1000, "%s", "1000b"},
	28	"1024 %f": {1024, "%f", "1.000000KiB"},
	29	"1024 %d": {1024, "%d", "1KiB"},
	30	"1024 %.1f": {1024, "%.1f", "1.0KiB"},
	31	"1024 %s": {1024, "%s", "1KiB"},
	32	"3MiB+140KiB %f": {3int64(_iMiB) + 140*int64(_iKiB), "%f", "3.136719MiB"},
	33	"3MiB+140KiB %d": {3int64(_iMiB) + 140*int64(_iKiB), "%d", "3MiB"},
	34	"3MiB+140KiB %.1f": {3int64(_iMiB) + 140*int64(_iKiB), "%.1f", "3.1MiB"},
	35	"3MiB+140KiB %s": {3int64(_iMiB) + 140*int64(_iKiB), "%s", "3.13671875MiB"},
	36	"2GiB %f": {2 int64(_iGiB), "%f", "2.000000GiB"},
	37	"2GiB %d": {2 int64(_iGiB), "%d", "2GiB"},
	38	"2GiB %.1f": {2 int64(_iGiB), "%.1f", "2.0GiB"},
	39	"2GiB %s": {2 int64(_iGiB), "%s", "2GiB"},
	40	"4TiB %f": {4 int64(_iTiB), "%f", "4.000000TiB"},
	41	"4TiB %d": {4 int64(_iTiB), "%d", "4TiB"},
	42	"4TiB %.1f": {4 int64(_iTiB), "%.1f", "4.0TiB"},
	43	"4TiB %s": {4 int64(_iTiB), "%s", "4TiB"},
	44	}
	45	for name, tc := range cases {
	46	t.Run(name, func(t *testing.T) {
	47	got := fmt.Sprintf(tc.verb, SizeB1024(tc.value))
	48	if got != tc.expected {
	49	t.Fatalf("expected: %q, got: %q\n", tc.expected, got)
	50	}
	51	})
	52	}
	53	}
	54
	55	func TestB1000(t *testing.T) {
	56	cases := map[string]struct {
	57	value int64
	58	verb string
	59	expected string
	60	}{
	61	"verb %f": {12345678, "%f", "12.345678MB"},
	62	"verb %.0f": {12345678, "%.0f", "12MB"},
	63	"verb %.1f": {12345678, "%.1f", "12.3MB"},
	64	"verb %.2f": {12345678, "%.2f", "12.35MB"},
	65	"verb %.3f": {12345678, "%.3f", "12.346MB"},
	66
	67	"verb % f": {12345678, "% f", "12.345678 MB"},
	68	"verb % .0f": {12345678, "% .0f", "12 MB"},
	69	"verb % .1f": {12345678, "% .1f", "12.3 MB"},
	70	"verb % .2f": {12345678, "% .2f", "12.35 MB"},
	71	"verb % .3f": {12345678, "% .3f", "12.346 MB"},
	72
	73	"1000 %f": {1000, "%f", "1.000000KB"},
	74	"1000 %d": {1000, "%d", "1KB"},
	75	"1000 %s": {1000, "%s", "1KB"},
	76	"1024 %f": {1024, "%f", "1.024000KB"},
	77	"1024 %d": {1024, "%d", "1KB"},
	78	"1024 %.1f": {1024, "%.1f", "1.0KB"},
	79	"1024 %s": {1024, "%s", "1.024KB"},
	80	"3MB+140KB %f": {3int64(_MB) + 140int64(_KB), "%f", "3.140000MB"},
	81	"3MB+140KB %d": {3int64(_MB) + 140int64(_KB), "%d", "3MB"},
	82	"3MB+140KB %.1f": {3int64(_MB) + 140int64(_KB), "%.1f", "3.1MB"},
	83	"3MB+140KB %s": {3int64(_MB) + 140int64(_KB), "%s", "3.14MB"},
	84	"2GB %f": {2 int64(_GB), "%f", "2.000000GB"},
	85	"2GB %d": {2 int64(_GB), "%d", "2GB"},
	86	"2GB %.1f": {2 int64(_GB), "%.1f", "2.0GB"},
	87	"2GB %s": {2 int64(_GB), "%s", "2GB"},
	88	"4TB %f": {4 int64(_TB), "%f", "4.000000TB"},
	89	"4TB %d": {4 int64(_TB), "%d", "4TB"},
	90	"4TB %.1f": {4 int64(_TB), "%.1f", "4.0TB"},
	91	"4TB %s": {4 int64(_TB), "%s", "4TB"},
	92	}
	93	for name, tc := range cases {
	94	t.Run(name, func(t *testing.T) {
	95	got := fmt.Sprintf(tc.verb, SizeB1000(tc.value))
	96	if got != tc.expected {
	97	t.Fatalf("expected: %q, got: %q\n", tc.expected, got)
	98	}
	99	})
	100	}
	101	}

+41

-0

decor/sizeb1000_string.go less more

	0	// Code generated by "stringer -type=SizeB1000 -trimprefix=_"; DO NOT EDIT.
	1
	2	package decor
	3
	4	import "strconv"
	5
	6	func _() {
	7	// An "invalid array index" compiler error signifies that the constant values have changed.
	8	// Re-run the stringer command to generate them again.
	9	var x [1]struct{}
	10	_ = x[_b-1]
	11	_ = x[_KB-1000]
	12	_ = x[_MB-1000000]
	13	_ = x[_GB-1000000000]
	14	_ = x[_TB-1000000000000]
	15	}
	16
	17	const (
	18	_SizeB1000_name_0 = "b"
	19	_SizeB1000_name_1 = "KB"
	20	_SizeB1000_name_2 = "MB"
	21	_SizeB1000_name_3 = "GB"
	22	_SizeB1000_name_4 = "TB"
	23	)
	24
	25	func (i SizeB1000) String() string {
	26	switch {
	27	case i == 1:
	28	return _SizeB1000_name_0
	29	case i == 1000:
	30	return _SizeB1000_name_1
	31	case i == 1000000:
	32	return _SizeB1000_name_2
	33	case i == 1000000000:
	34	return _SizeB1000_name_3
	35	case i == 1000000000000:
	36	return _SizeB1000_name_4
	37	default:
	38	return "SizeB1000(" + strconv.FormatInt(int64(i), 10) + ")"
	39	}
	40	}

+41

-0

decor/sizeb1024_string.go less more

	0	// Code generated by "stringer -type=SizeB1024 -trimprefix=_i"; DO NOT EDIT.
	1
	2	package decor
	3
	4	import "strconv"
	5
	6	func _() {
	7	// An "invalid array index" compiler error signifies that the constant values have changed.
	8	// Re-run the stringer command to generate them again.
	9	var x [1]struct{}
	10	_ = x[_ib-1]
	11	_ = x[_iKiB-1024]
	12	_ = x[_iMiB-1048576]
	13	_ = x[_iGiB-1073741824]
	14	_ = x[_iTiB-1099511627776]
	15	}
	16
	17	const (
	18	_SizeB1024_name_0 = "b"
	19	_SizeB1024_name_1 = "KiB"
	20	_SizeB1024_name_2 = "MiB"
	21	_SizeB1024_name_3 = "GiB"
	22	_SizeB1024_name_4 = "TiB"
	23	)
	24
	25	func (i SizeB1024) String() string {
	26	switch {
	27	case i == 1:
	28	return _SizeB1024_name_0
	29	case i == 1024:
	30	return _SizeB1024_name_1
	31	case i == 1048576:
	32	return _SizeB1024_name_2
	33	case i == 1073741824:
	34	return _SizeB1024_name_3
	35	case i == 1099511627776:
	36	return _SizeB1024_name_4
	37	default:
	38	return "SizeB1024(" + strconv.FormatInt(int64(i), 10) + ")"
	39	}
	40	}

+101

-201

decor/speed.go less more

3	3	"fmt"
4	4	"io"
5	5	"math"
6		"strconv"
7		"strings"
8	6	"time"
9	7
10	8	"github.com/VividCortex/ewma"
11	9	)
12	10
13		type SpeedKiB float64
14
15		func (s SpeedKiB) Format(st fmt.State, verb rune) {
16		prec, ok := st.Precision()
17
18		if verb == 'd' \|\| !ok {
19		prec = 0
20		}
21		if verb == 'f' && !ok {
22		prec = 6
23		}
24		// retain old beahavior if s verb used
25		if verb == 's' {
26		prec = 1
27		}
28
29		var res, unit string
30		switch {
31		case s >= TiB:
32		unit = "TiB/s"
33		res = strconv.FormatFloat(float64(s)/TiB, 'f', prec, 64)
34		case s >= GiB:
35		unit = "GiB/s"
36		res = strconv.FormatFloat(float64(s)/GiB, 'f', prec, 64)
37		case s >= MiB:
38		unit = "MiB/s"
39		res = strconv.FormatFloat(float64(s)/MiB, 'f', prec, 64)
40		case s >= KiB:
41		unit = "KiB/s"
42		res = strconv.FormatFloat(float64(s)/KiB, 'f', prec, 64)
43		default:
44		unit = "b/s"
45		res = strconv.FormatInt(int64(s), 10)
46		}
47
48		if st.Flag(' ') {
49		res += " "
50		}
51		res += unit
52
53		if w, ok := st.Width(); ok {
54		if len(res) < w {
55		pad := strings.Repeat(" ", w-len(res))
56		if st.Flag(int('-')) {
57		res += pad
58		} else {
59		res = pad + res
60		}
61		}
62		}
63
64		io.WriteString(st, res)
	11	// FmtAsSpeed adds "/s" to the end of the input formatter. To be
	12	// used with SizeB1000 or SizeB1024 types, for example:
	13	//
	14	// fmt.Printf("%.1f", FmtAsSpeed(SizeB1024(2048)))
	15	//
	16	func FmtAsSpeed(input fmt.Formatter) fmt.Formatter {
	17	return &speedFormatter{input}
65	18	}
66	19
67		type SpeedKB float64
68
69		func (s SpeedKB) Format(st fmt.State, verb rune) {
70		prec, ok := st.Precision()
71
72		if verb == 'd' \|\| !ok {
73		prec = 0
74		}
75		if verb == 'f' && !ok {
76		prec = 6
77		}
78		// retain old beahavior if s verb used
79		if verb == 's' {
80		prec = 1
81		}
82
83		var res, unit string
84		switch {
85		case s >= TB:
86		unit = "TB/s"
87		res = strconv.FormatFloat(float64(s)/TB, 'f', prec, 64)
88		case s >= GB:
89		unit = "GB/s"
90		res = strconv.FormatFloat(float64(s)/GB, 'f', prec, 64)
91		case s >= MB:
92		unit = "MB/s"
93		res = strconv.FormatFloat(float64(s)/MB, 'f', prec, 64)
94		case s >= KB:
95		unit = "kB/s"
96		res = strconv.FormatFloat(float64(s)/KB, 'f', prec, 64)
97		default:
98		unit = "b/s"
99		res = strconv.FormatInt(int64(s), 10)
100		}
101
102		if st.Flag(' ') {
103		res += " "
104		}
105		res += unit
106
107		if w, ok := st.Width(); ok {
108		if len(res) < w {
109		pad := strings.Repeat(" ", w-len(res))
110		if st.Flag(int('-')) {
111		res += pad
112		} else {
113		res = pad + res
114		}
115		}
116		}
117
118		io.WriteString(st, res)
	20	type speedFormatter struct {
	21	fmt.Formatter
119	22	}
120	23
121		// EwmaSpeed exponential-weighted-moving-average based speed decorator,
122		// with dynamic unit measure adjustment.
123		//
124		// `unit` one of [0\|UnitKiB\|UnitKB] zero for no unit
125		//
126		// `unitFormat` printf compatible verb for value, like "%f" or "%d"
127		//
128		// `average` MovingAverage implementation
129		//
130		// `wcc` optional WC config
131		//
132		// unitFormat example if UnitKiB is chosen:
133		//
134		// "%.1f" = "1.0MiB/s" or "% .1f" = "1.0 MiB/s"
135		func EwmaSpeed(unit int, unitFormat string, age float64, wcc ...WC) Decorator {
136		return MovingAverageSpeed(unit, unitFormat, ewma.NewMovingAverage(age), wcc...)
	24	func (self *speedFormatter) Format(st fmt.State, verb rune) {
	25	self.Formatter.Format(st, verb)
	26	io.WriteString(st, "/s")
	27	}
	28
	29	// EwmaSpeed exponential-weighted-moving-average based speed decorator.
	30	// For this decorator to work correctly you have to measure each
	31	// iteration's duration and pass it to the
	32	// *Bar.DecoratorEwmaUpdate(time.Duration) method after each increment.
	33	func EwmaSpeed(unit int, format string, age float64, wcc ...WC) Decorator {
	34	var average ewma.MovingAverage
	35	if age == 0 {
	36	average = ewma.NewMovingAverage()
	37	} else {
	38	average = ewma.NewMovingAverage(age)
	39	}
	40	return MovingAverageSpeed(unit, format, NewThreadSafeMovingAverage(average), wcc...)
137	41	}
138	42
139	43	// MovingAverageSpeed decorator relies on MovingAverage implementation

141	45	//
142	46	// `unit` one of [0\|UnitKiB\|UnitKB] zero for no unit
143	47	//
144		// `unitFormat` printf compatible verb for value, like "%f" or "%d"
	48	// `format` printf compatible verb for value, like "%f" or "%d"
145	49	//
146	50	// `average` MovingAverage implementation
147	51	//
148	52	// `wcc` optional WC config
149		func MovingAverageSpeed(unit int, unitFormat string, average MovingAverage, wcc ...WC) Decorator {
150		var wc WC
151		for _, widthConf := range wcc {
152		wc = widthConf
	53	//
	54	// format examples:
	55	//
	56	// unit=UnitKiB, format="%.1f" output: "1.0MiB/s"
	57	// unit=UnitKiB, format="% .1f" output: "1.0 MiB/s"
	58	// unit=UnitKB, format="%.1f" output: "1.0MB/s"
	59	// unit=UnitKB, format="% .1f" output: "1.0 MB/s"
	60	//
	61	func MovingAverageSpeed(unit int, format string, average ewma.MovingAverage, wcc ...WC) Decorator {
	62	if format == "" {
	63	format = "%.0f"
153	64	}
154		wc.Init()
155	65	d := &movingAverageSpeed{
156		WC: wc,
157		unit: unit,
158		unitFormat: unitFormat,
159		average: average,
	66	WC: initWC(wcc...),
	67	average: average,
	68	producer: chooseSpeedProducer(unit, format),
160	69	}
161	70	return d
162	71	}
163	72
164	73	type movingAverageSpeed struct {
165	74	WC
166		unit int
167		unitFormat string
168		average ewma.MovingAverage
169		msg string
170		completeMsg *string
	75	producer func(float64) string
	76	average ewma.MovingAverage
	77	msg string
171	78	}
172	79
173		func (d movingAverageSpeed) Decor(st Statistics) string {
174		if st.Completed {
175		if d.completeMsg != nil {
176		return d.FormatMsg(*d.completeMsg)
	80	func (d movingAverageSpeed) Decor(s Statistics) string {
	81	if !s.Completed {
	82	var speed float64
	83	if v := d.average.Value(); v > 0 {
	84	speed = 1 / v
177	85	}
178		return d.FormatMsg(d.msg)
	86	d.msg = d.producer(speed * 1e9)
179	87	}
180
181		speed := d.average.Value()
182		switch d.unit {
183		case UnitKiB:
184		d.msg = fmt.Sprintf(d.unitFormat, SpeedKiB(speed))
185		case UnitKB:
186		d.msg = fmt.Sprintf(d.unitFormat, SpeedKB(speed))
187		default:
188		d.msg = fmt.Sprintf(d.unitFormat, speed)
189		}
190
191	88	return d.FormatMsg(d.msg)
192	89	}
193	90
194		func (s *movingAverageSpeed) NextAmount(n int, wdd ...time.Duration) {
195		var workDuration time.Duration
196		for _, wd := range wdd {
197		workDuration = wd
198		}
199		speed := float64(n) / workDuration.Seconds() / 1000
200		if math.IsInf(speed, 0) \|\| math.IsNaN(speed) {
	91	func (d *movingAverageSpeed) EwmaUpdate(n int64, dur time.Duration) {
	92	durPerByte := float64(dur) / float64(n)
	93	if math.IsInf(durPerByte, 0) \|\| math.IsNaN(durPerByte) {
201	94	return
202	95	}
203		s.average.Add(speed)
	96	d.average.Add(durPerByte)
204	97	}
205	98
206		func (d *movingAverageSpeed) OnCompleteMessage(msg string) {
207		d.completeMsg = &msg
	99	// AverageSpeed decorator with dynamic unit measure adjustment. It's
	100	// a wrapper of NewAverageSpeed.
	101	func AverageSpeed(unit int, format string, wcc ...WC) Decorator {
	102	return NewAverageSpeed(unit, format, time.Now(), wcc...)
208	103	}
209	104
210		// AverageSpeed decorator with dynamic unit measure adjustment.
	105	// NewAverageSpeed decorator with dynamic unit measure adjustment and
	106	// user provided start time.
211	107	//
212	108	// `unit` one of [0\|UnitKiB\|UnitKB] zero for no unit
213	109	//
214		// `unitFormat` printf compatible verb for value, like "%f" or "%d"
	110	// `format` printf compatible verb for value, like "%f" or "%d"
	111	//
	112	// `startTime` start time
215	113	//
216	114	// `wcc` optional WC config
217	115	//
218		// unitFormat example if UnitKiB is chosen:
	116	// format examples:
219	117	//
220		// "%.1f" = "1.0MiB/s" or "% .1f" = "1.0 MiB/s"
221		func AverageSpeed(unit int, unitFormat string, wcc ...WC) Decorator {
222		var wc WC
223		for _, widthConf := range wcc {
224		wc = widthConf
	118	// unit=UnitKiB, format="%.1f" output: "1.0MiB/s"
	119	// unit=UnitKiB, format="% .1f" output: "1.0 MiB/s"
	120	// unit=UnitKB, format="%.1f" output: "1.0MB/s"
	121	// unit=UnitKB, format="% .1f" output: "1.0 MB/s"
	122	//
	123	func NewAverageSpeed(unit int, format string, startTime time.Time, wcc ...WC) Decorator {
	124	if format == "" {
	125	format = "%.0f"
225	126	}
226		wc.Init()
227	127	d := &averageSpeed{
228		WC: wc,
229		unit: unit,
230		unitFormat: unitFormat,
231		startTime: time.Now(),
	128	WC: initWC(wcc...),
	129	startTime: startTime,
	130	producer: chooseSpeedProducer(unit, format),
232	131	}
233	132	return d
234	133	}
235	134
236	135	type averageSpeed struct {
237	136	WC
238		unit int
239		unitFormat string
240		startTime time.Time
241		msg string
242		completeMsg *string
	137	startTime time.Time
	138	producer func(float64) string
	139	msg string
243	140	}
244	141
245		func (d averageSpeed) Decor(st Statistics) string {
246		if st.Completed {
247		if d.completeMsg != nil {
248		return d.FormatMsg(*d.completeMsg)
249		}
250		return d.FormatMsg(d.msg)
251		}
252
253		timeElapsed := time.Since(d.startTime)
254		speed := float64(st.Current) / timeElapsed.Seconds()
255
256		switch d.unit {
257		case UnitKiB:
258		d.msg = fmt.Sprintf(d.unitFormat, SpeedKiB(speed))
259		case UnitKB:
260		d.msg = fmt.Sprintf(d.unitFormat, SpeedKB(speed))
261		default:
262		d.msg = fmt.Sprintf(d.unitFormat, speed)
	142	func (d averageSpeed) Decor(s Statistics) string {
	143	if !s.Completed {
	144	speed := float64(s.Current) / float64(time.Since(d.startTime))
	145	d.msg = d.producer(speed * 1e9)
263	146	}
264	147
265	148	return d.FormatMsg(d.msg)
266	149	}
267	150
268		func (d *averageSpeed) OnCompleteMessage(msg string) {
269		d.completeMsg = &msg
	151	func (d *averageSpeed) AverageAdjust(startTime time.Time) {
	152	d.startTime = startTime
270	153	}
	154
	155	func chooseSpeedProducer(unit int, format string) func(float64) string {
	156	switch unit {
	157	case UnitKiB:
	158	return func(speed float64) string {
	159	return fmt.Sprintf(format, FmtAsSpeed(SizeB1024(math.Round(speed))))
	160	}
	161	case UnitKB:
	162	return func(speed float64) string {
	163	return fmt.Sprintf(format, FmtAsSpeed(SizeB1000(math.Round(speed))))
	164	}
	165	default:
	166	return func(speed float64) string {
	167	return fmt.Sprintf(format, speed)
	168	}
	169	}
	170	}

+243

-123

decor/speed_test.go less more

0	0	package decor
1	1
2	2	import (
3		"fmt"
4	3	"testing"
	4	"time"
5	5	)
6	6
7		func TestSpeedKiB(t *testing.T) {
8		cases := map[string]struct {
9		value int64
10		verb string
	7	func TestSpeedKiBDecor(t *testing.T) {
	8	cases := []struct {
	9	name string
	10	fmt string
	11	unit int
	12	current int64
	13	elapsed time.Duration
11	14	expected string
12	15	}{
13		"verb %f": {12345678, "%f", "11.773756MiB/s"},
14		"verb %.0f": {12345678, "%.0f", "12MiB/s"},
15		"verb %.1f": {12345678, "%.1f", "11.8MiB/s"},
16		"verb %.2f": {12345678, "%.2f", "11.77MiB/s"},
17		"verb %.3f": {12345678, "%.3f", "11.774MiB/s"},
18
19		"verb % f": {12345678, "% f", "11.773756 MiB/s"},
20		"verb % .0f": {12345678, "% .0f", "12 MiB/s"},
21		"verb % .1f": {12345678, "% .1f", "11.8 MiB/s"},
22		"verb % .2f": {12345678, "% .2f", "11.77 MiB/s"},
23		"verb % .3f": {12345678, "% .3f", "11.774 MiB/s"},
24
25		"verb %10.f": {12345678, "%10.f", " 12MiB/s"},
26		"verb %10.0f": {12345678, "%10.0f", " 12MiB/s"},
27		"verb %10.1f": {12345678, "%10.1f", " 11.8MiB/s"},
28		"verb %10.2f": {12345678, "%10.2f", "11.77MiB/s"},
29		"verb %10.3f": {12345678, "%10.3f", "11.774MiB/s"},
30
31		"verb % 10.f": {12345678, "% 10.f", " 12 MiB/s"},
32		"verb % 10.0f": {12345678, "% 10.0f", " 12 MiB/s"},
33		"verb % 10.1f": {12345678, "% 10.1f", "11.8 MiB/s"},
34
35		"verb %-10.f": {12345678, "%-10.f", "12MiB/s "},
36		"verb %-10.0f": {12345678, "%-10.0f", "12MiB/s "},
37		"verb %-10.1f": {12345678, "%-10.1f", "11.8MiB/s "},
38		"verb %-10.2f": {12345678, "%10.2f", "11.77MiB/s"},
39		"verb %-10.3f": {12345678, "%10.3f", "11.774MiB/s"},
40
41		"verb % -10.f": {12345678, "% -10.f", "12 MiB/s "},
42		"verb % -10.0f": {12345678, "% -10.0f", "12 MiB/s "},
43		"verb % -10.1f": {12345678, "% -10.1f", "11.8 MiB/s"},
44
45		"1000 %f": {1000, "%f", "1000b/s"},
46		"1000 %d": {1000, "%d", "1000b/s"},
47		"1000 %s": {1000, "%s", "1000b/s"},
48		"1024 %f": {1024, "%f", "1.000000KiB/s"},
49		"1024 %d": {1024, "%d", "1KiB/s"},
50		"1024 %.1f": {1024, "%.1f", "1.0KiB/s"},
51		"1024 %s": {1024, "%s", "1.0KiB/s"},
52		"3MiB/s+140KiB/s %f": {3MiB + 140*KiB, "%f", "3.136719MiB/s"},
53		"3MiB/s+140KiB/s %d": {3MiB + 140*KiB, "%d", "3MiB/s"},
54		"3MiB/s+140KiB/s %.1f": {3MiB + 140*KiB, "%.1f", "3.1MiB/s"},
55		"3MiB/s+140KiB/s %s": {3MiB + 140*KiB, "%s", "3.1MiB/s"},
56		"2GiB/s %f": {2 GiB, "%f", "2.000000GiB/s"},
57		"2GiB/s %d": {2 GiB, "%d", "2GiB/s"},
58		"2GiB/s %.1f": {2 GiB, "%.1f", "2.0GiB/s"},
59		"2GiB/s %s": {2 GiB, "%s", "2.0GiB/s"},
60		"4TiB/s %f": {4 TiB, "%f", "4.000000TiB/s"},
61		"4TiB/s %d": {4 TiB, "%d", "4TiB/s"},
62		"4TiB/s %.1f": {4 TiB, "%.1f", "4.0TiB/s"},
63		"4TiB/s %s": {4 TiB, "%s", "4.0TiB/s"},
64		}
65		for name, tc := range cases {
66		t.Run(name, func(t *testing.T) {
67		got := fmt.Sprintf(tc.verb, SpeedKiB(tc.value))
68		if got != tc.expected {
69		t.Fatalf("expected: %q, got: %q\n", tc.expected, got)
	16	{
	17	name: "empty fmt",
	18	unit: UnitKiB,
	19	fmt: "",
	20	current: 0,
	21	elapsed: time.Second,
	22	expected: "0b/s",
	23	},
	24	{
	25	name: "UnitKiB:%d:0b",
	26	unit: UnitKiB,
	27	fmt: "%d",
	28	current: 0,
	29	elapsed: time.Second,
	30	expected: "0b/s",
	31	},
	32	{
	33	name: "UnitKiB:% .2f:0b",
	34	unit: UnitKiB,
	35	fmt: "% .2f",
	36	current: 0,
	37	elapsed: time.Second,
	38	expected: "0.00 b/s",
	39	},
	40	{
	41	name: "UnitKiB:%d:1b",
	42	unit: UnitKiB,
	43	fmt: "%d",
	44	current: 1,
	45	elapsed: time.Second,
	46	expected: "1b/s",
	47	},
	48	{
	49	name: "UnitKiB:% .2f:1b",
	50	unit: UnitKiB,
	51	fmt: "% .2f",
	52	current: 1,
	53	elapsed: time.Second,
	54	expected: "1.00 b/s",
	55	},
	56	{
	57	name: "UnitKiB:%d:KiB",
	58	unit: UnitKiB,
	59	fmt: "%d",
	60	current: 2 * int64(_iKiB),
	61	elapsed: 1 * time.Second,
	62	expected: "2KiB/s",
	63	},
	64	{
	65	name: "UnitKiB:% .f:KiB",
	66	unit: UnitKiB,
	67	fmt: "% .2f",
	68	current: 2 * int64(_iKiB),
	69	elapsed: 1 * time.Second,
	70	expected: "2.00 KiB/s",
	71	},
	72	{
	73	name: "UnitKiB:%d:MiB",
	74	unit: UnitKiB,
	75	fmt: "%d",
	76	current: 2 * int64(_iMiB),
	77	elapsed: 1 * time.Second,
	78	expected: "2MiB/s",
	79	},
	80	{
	81	name: "UnitKiB:% .2f:MiB",
	82	unit: UnitKiB,
	83	fmt: "% .2f",
	84	current: 2 * int64(_iMiB),
	85	elapsed: 1 * time.Second,
	86	expected: "2.00 MiB/s",
	87	},
	88	{
	89	name: "UnitKiB:%d:GiB",
	90	unit: UnitKiB,
	91	fmt: "%d",
	92	current: 2 * int64(_iGiB),
	93	elapsed: 1 * time.Second,
	94	expected: "2GiB/s",
	95	},
	96	{
	97	name: "UnitKiB:% .2f:GiB",
	98	unit: UnitKiB,
	99	fmt: "% .2f",
	100	current: 2 * int64(_iGiB),
	101	elapsed: 1 * time.Second,
	102	expected: "2.00 GiB/s",
	103	},
	104	{
	105	name: "UnitKiB:%d:TiB",
	106	unit: UnitKiB,
	107	fmt: "%d",
	108	current: 2 * int64(_iTiB),
	109	elapsed: 1 * time.Second,
	110	expected: "2TiB/s",
	111	},
	112	{
	113	name: "UnitKiB:% .2f:TiB",
	114	unit: UnitKiB,
	115	fmt: "% .2f",
	116	current: 2 * int64(_iTiB),
	117	elapsed: 1 * time.Second,
	118	expected: "2.00 TiB/s",
	119	},
	120	}
	121	for _, tc := range cases {
	122	t.Run(tc.name, func(t *testing.T) {
	123	decor := NewAverageSpeed(tc.unit, tc.fmt, time.Now().Add(-tc.elapsed))
	124	stat := &Statistics{
	125	Current: tc.current,
	126	}
	127	res := decor.Decor(stat)
	128	if res != tc.expected {
	129	t.Fatalf("expected: %q, got: %q\n", tc.expected, res)
70	130	}
71	131	})
72	132	}
73	133	}
74	134
75		func TestSpeedKB(t *testing.T) {
76		cases := map[string]struct {
77		value int64
78		verb string
	135	func TestSpeedKBDecor(t *testing.T) {
	136	cases := []struct {
	137	name string
	138	fmt string
	139	unit int
	140	current int64
	141	elapsed time.Duration
79	142	expected string
80	143	}{
81		"verb %f": {12345678, "%f", "12.345678MB/s"},
82		"verb %.0f": {12345678, "%.0f", "12MB/s"},
83		"verb %.1f": {12345678, "%.1f", "12.3MB/s"},
84		"verb %.2f": {12345678, "%.2f", "12.35MB/s"},
85		"verb %.3f": {12345678, "%.3f", "12.346MB/s"},
86
87		"verb % f": {12345678, "% f", "12.345678 MB/s"},
88		"verb % .0f": {12345678, "% .0f", "12 MB/s"},
89		"verb % .1f": {12345678, "% .1f", "12.3 MB/s"},
90		"verb % .2f": {12345678, "% .2f", "12.35 MB/s"},
91		"verb % .3f": {12345678, "% .3f", "12.346 MB/s"},
92
93		"verb %10.f": {12345678, "%10.f", " 12MB/s"},
94		"verb %10.0f": {12345678, "%10.0f", " 12MB/s"},
95		"verb %10.1f": {12345678, "%10.1f", " 12.3MB/s"},
96		"verb %10.2f": {12345678, "%10.2f", " 12.35MB/s"},
97		"verb %10.3f": {12345678, "%10.3f", "12.346MB/s"},
98
99		"verb % 10.f": {12345678, "% 10.f", " 12 MB/s"},
100		"verb % 10.0f": {12345678, "% 10.0f", " 12 MB/s"},
101		"verb % 10.1f": {12345678, "% 10.1f", " 12.3 MB/s"},
102
103		"verb %-10.f": {12345678, "%-10.f", "12MB/s "},
104		"verb %-10.0f": {12345678, "%-10.0f", "12MB/s "},
105		"verb %-10.1f": {12345678, "%-10.1f", "12.3MB/s "},
106		"verb %-10.2f": {12345678, "%10.2f", " 12.35MB/s"},
107		"verb %-10.3f": {12345678, "%10.3f", "12.346MB/s"},
108
109		"verb % -10.f": {12345678, "% -10.f", "12 MB/s "},
110		"verb % -10.0f": {12345678, "% -10.0f", "12 MB/s "},
111		"verb % -10.1f": {12345678, "% -10.1f", "12.3 MB/s "},
112
113		"1000 %f": {1000, "%f", "1.000000kB/s"},
114		"1000 %d": {1000, "%d", "1kB/s"},
115		"1000 %s": {1000, "%s", "1.0kB/s"},
116		"1024 %f": {1024, "%f", "1.024000kB/s"},
117		"1024 %d": {1024, "%d", "1kB/s"},
118		"1024 %.1f": {1024, "%.1f", "1.0kB/s"},
119		"1024 %s": {1024, "%s", "1.0kB/s"},
120		"3MB/s+140KB/s %f": {3MB + 140KB, "%f", "3.140000MB/s"},
121		"3MB/s+140KB/s %d": {3MB + 140KB, "%d", "3MB/s"},
122		"3MB/s+140KB/s %.1f": {3MB + 140KB, "%.1f", "3.1MB/s"},
123		"3MB/s+140KB/s %s": {3MB + 140KB, "%s", "3.1MB/s"},
124		"2GB/s %f": {2 GB, "%f", "2.000000GB/s"},
125		"2GB/s %d": {2 GB, "%d", "2GB/s"},
126		"2GB/s %.1f": {2 GB, "%.1f", "2.0GB/s"},
127		"2GB/s %s": {2 GB, "%s", "2.0GB/s"},
128		"4TB/s %f": {4 TB, "%f", "4.000000TB/s"},
129		"4TB/s %d": {4 TB, "%d", "4TB/s"},
130		"4TB/s %.1f": {4 TB, "%.1f", "4.0TB/s"},
131		"4TB/s %s": {4 TB, "%s", "4.0TB/s"},
132		}
133		for name, tc := range cases {
134		t.Run(name, func(t *testing.T) {
135		got := fmt.Sprintf(tc.verb, SpeedKB(tc.value))
136		if got != tc.expected {
137		t.Fatalf("expected: %q, got: %q\n", tc.expected, got)
	144	{
	145	name: "empty fmt",
	146	unit: UnitKB,
	147	fmt: "",
	148	current: 0,
	149	elapsed: time.Second,
	150	expected: "0b/s",
	151	},
	152	{
	153	name: "UnitKB:%d:0b",
	154	unit: UnitKB,
	155	fmt: "%d",
	156	current: 0,
	157	elapsed: time.Second,
	158	expected: "0b/s",
	159	},
	160	{
	161	name: "UnitKB:% .2f:0b",
	162	unit: UnitKB,
	163	fmt: "% .2f",
	164	current: 0,
	165	elapsed: time.Second,
	166	expected: "0.00 b/s",
	167	},
	168	{
	169	name: "UnitKB:%d:1b",
	170	unit: UnitKB,
	171	fmt: "%d",
	172	current: 1,
	173	elapsed: time.Second,
	174	expected: "1b/s",
	175	},
	176	{
	177	name: "UnitKB:% .2f:1b",
	178	unit: UnitKB,
	179	fmt: "% .2f",
	180	current: 1,
	181	elapsed: time.Second,
	182	expected: "1.00 b/s",
	183	},
	184	{
	185	name: "UnitKB:%d:KB",
	186	unit: UnitKB,
	187	fmt: "%d",
	188	current: 2 * int64(_KB),
	189	elapsed: 1 * time.Second,
	190	expected: "2KB/s",
	191	},
	192	{
	193	name: "UnitKB:% .f:KB",
	194	unit: UnitKB,
	195	fmt: "% .2f",
	196	current: 2 * int64(_KB),
	197	elapsed: 1 * time.Second,
	198	expected: "2.00 KB/s",
	199	},
	200	{
	201	name: "UnitKB:%d:MB",
	202	unit: UnitKB,
	203	fmt: "%d",
	204	current: 2 * int64(_MB),
	205	elapsed: 1 * time.Second,
	206	expected: "2MB/s",
	207	},
	208	{
	209	name: "UnitKB:% .2f:MB",
	210	unit: UnitKB,
	211	fmt: "% .2f",
	212	current: 2 * int64(_MB),
	213	elapsed: 1 * time.Second,
	214	expected: "2.00 MB/s",
	215	},
	216	{
	217	name: "UnitKB:%d:GB",
	218	unit: UnitKB,
	219	fmt: "%d",
	220	current: 2 * int64(_GB),
	221	elapsed: 1 * time.Second,
	222	expected: "2GB/s",
	223	},
	224	{
	225	name: "UnitKB:% .2f:GB",
	226	unit: UnitKB,
	227	fmt: "% .2f",
	228	current: 2 * int64(_GB),
	229	elapsed: 1 * time.Second,
	230	expected: "2.00 GB/s",
	231	},
	232	{
	233	name: "UnitKB:%d:TB",
	234	unit: UnitKB,
	235	fmt: "%d",
	236	current: 2 * int64(_TB),
	237	elapsed: 1 * time.Second,
	238	expected: "2TB/s",
	239	},
	240	{
	241	name: "UnitKB:% .2f:TB",
	242	unit: UnitKB,
	243	fmt: "% .2f",
	244	current: 2 * int64(_TB),
	245	elapsed: 1 * time.Second,
	246	expected: "2.00 TB/s",
	247	},
	248	}
	249	for _, tc := range cases {
	250	t.Run(tc.name, func(t *testing.T) {
	251	decor := NewAverageSpeed(tc.unit, tc.fmt, time.Now().Add(-tc.elapsed))
	252	stat := &Statistics{
	253	Current: tc.current,
	254	}
	255	res := decor.Decor(stat)
	256	if res != tc.expected {
	257	t.Fatalf("expected: %q, got: %q\n", tc.expected, res)
138	258	}
139	259	})
140	260	}

+21

-0

decor/spinner.go less more

	0	package decor
	1
	2	var defaultSpinnerStyle = []string{"⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"}
	3
	4	// Spinner returns spinner decorator.
	5	//
	6	// `frames` spinner frames, if nil or len==0, default is used
	7	//
	8	// `wcc` optional WC config
	9	func Spinner(frames []string, wcc ...WC) Decorator {
	10	if len(frames) == 0 {
	11	frames = defaultSpinnerStyle
	12	}
	13	var count uint
	14	f := func(s *Statistics) string {
	15	frame := frames[count%uint(len(frames))]
	16	count++
	17	return frame
	18	}
	19	return Any(f, wcc...)
	20	}

+12

-12

decorators_test.go less more

3	3	"sync"
4	4	"testing"
5	5
6		. "github.com/vbauerster/mpb"
7		"github.com/vbauerster/mpb/decor"
	6	. "github.com/vbauerster/mpb/v5"
	7	"github.com/vbauerster/mpb/v5/decor"
8	8	)
9	9
10	10	func TestNameDecorator(t *testing.T) {

47	47	func TestPercentageDwidthSync(t *testing.T) {
48	48
49	49	testCases := [][]step{
50		[]step{
	50	{
51	51	{
52	52	&decor.Statistics{Total: 100, Current: 8},
53	53	decor.Percentage(decor.WCSyncWidth),

59	59	"9 %",
60	60	},
61	61	},
62		[]step{
	62	{
63	63	{
64	64	&decor.Statistics{Total: 100, Current: 9},
65	65	decor.Percentage(decor.WCSyncWidth),

71	71	"10 %",
72	72	},
73	73	},
74		[]step{
	74	{
75	75	{
76	76	&decor.Statistics{Total: 100, Current: 9},
77	77	decor.Percentage(decor.WCSyncWidth),

91	91	func TestPercentageDwidthSyncDidentRight(t *testing.T) {
92	92
93	93	testCases := [][]step{
94		[]step{
	94	{
95	95	{
96	96	&decor.Statistics{Total: 100, Current: 8},
97	97	decor.Percentage(decor.WCSyncWidthR),

103	103	"9 %",
104	104	},
105	105	},
106		[]step{
	106	{
107	107	{
108	108	&decor.Statistics{Total: 100, Current: 9},
109	109	decor.Percentage(decor.WCSyncWidthR),

115	115	"10 %",
116	116	},
117	117	},
118		[]step{
	118	{
119	119	{
120	120	&decor.Statistics{Total: 100, Current: 9},
121	121	decor.Percentage(decor.WCSyncWidthR),

135	135	func TestPercentageDSyncSpace(t *testing.T) {
136	136
137	137	testCases := [][]step{
138		[]step{
	138	{
139	139	{
140	140	&decor.Statistics{Total: 100, Current: 8},
141	141	decor.Percentage(decor.WCSyncSpace),

147	147	" 9 %",
148	148	},
149	149	},
150		[]step{
	150	{
151	151	{
152	152	&decor.Statistics{Total: 100, Current: 9},
153	153	decor.Percentage(decor.WCSyncSpace),

159	159	" 10 %",
160	160	},
161	161	},
162		[]step{
	162	{
163	163	{
164	164	&decor.Statistics{Total: 100, Current: 9},
165	165	decor.Percentage(decor.WCSyncSpace),

210	210	func toSyncMatrix(ss []step) map[int][]chan int {
211	211	var column []chan int
212	212	for _, s := range ss {
213		if ok, ch := s.decorator.Syncable(); ok {
	213	if ch, ok := s.decorator.Sync(); ok {
214	214	column = append(column, ch)
215	215	}
216	216	}

+0

-4

doc.go less more

0		// Copyright (C) 2016-2018 Vladimir Bauer
1		// Use of this source code is governed by a BSD-style
2		// license that can be found in the LICENSE file.
3
4	0	// Package mpb is a library for rendering progress bars in terminal applications.
5	1	package mpb

+60

-6

draw_test.go less more

12	12	total, current int64
13	13	barWidth int
14	14	trimSpace bool
	15	reverse bool
15	16	rup int64
16	17	want string
17	18	}{
	19	0: {
	20	{
	21	name: "t,c,bw{60,20,80}",
	22	total: 60,
	23	current: 20,
	24	barWidth: 80,
	25	want: "",
	26	},
	27	{
	28	name: "t,c,bw{60,20,80}",
	29	total: 60,
	30	current: 20,
	31	barWidth: 80,
	32	trimSpace: true,
	33	want: "",
	34	},
	35	},
	36	1: {
	37	{
	38	name: "t,c,bw{60,20,80}",
	39	total: 60,
	40	current: 20,
	41	barWidth: 80,
	42	want: "",
	43	},
	44	{
	45	name: "t,c,bw{60,20,80}",
	46	total: 60,
	47	current: 20,
	48	barWidth: 80,
	49	trimSpace: true,
	50	want: "",
	51	},
	52	},
18	53	2: {
19	54	{
20	55	name: "t,c,bw{60,20,80}",

63	98	current: 20,
64	99	barWidth: 80,
65	100	trimSpace: true,
66		want: "[]",
	101	want: "[>-]",
67	102	},
68	103	},
69	104	5: {

89	124	total: 60,
90	125	current: 20,
91	126	barWidth: 80,
92		want: " [] ",
	127	want: " [>-] ",
93	128	},
94	129	{
95	130	name: "t,c,bw,trim{60,20,80,true}",

196	231	barWidth: 100,
197	232	trimSpace: true,
198	233	want: "[===============================>------------------------------------------------------------------]",
	234	},
	235	{
	236	name: "t,c,bw,trim,rev{100,33,100,true,true}",
	237	total: 100,
	238	current: 33,
	239	barWidth: 100,
	240	trimSpace: true,
	241	reverse: true,
	242	want: "[------------------------------------------------------------------<===============================]",
199	243	},
200	244	{
201	245	name: "t,c,bw,rup{100,33,100,33}",

213	257	rup: 33,
214	258	trimSpace: true,
215	259	want: "[+++++++++++++++++++++++++++++++>------------------------------------------------------------------]",
	260	},
	261	{
	262	name: "t,c,bw,rup,trim,rev{100,33,100,33,true,true}",
	263	total: 100,
	264	current: 33,
	265	barWidth: 100,
	266	rup: 33,
	267	trimSpace: true,
	268	reverse: true,
	269	want: "[------------------------------------------------------------------<+++++++++++++++++++++++++++++++]",
216	270	},
217	271	{
218	272	name: "t,c,bw,rup{100,40,100,32}",

267	321	var tmpBuf bytes.Buffer
268	322	for termWidth, cases := range testSuite {
269	323	for _, tc := range cases {
270		s := newTestState()
	324	s := newTestState(tc.reverse)
271	325	s.width = tc.barWidth
272	326	s.total = tc.total
273	327	s.current = tc.current

278	332	}
279	333	}
280	334	tmpBuf.Reset()
281		tmpBuf.ReadFrom(s.draw(termWidth))
	335	tmpBuf.ReadFrom(s.draw(termWidth, newStatistics(s)))
282	336	by := tmpBuf.Bytes()
283	337	by = by[:len(by)-1]
284	338

294	348	}
295	349	}
296	350
297		func newTestState() *bState {
	351	func newTestState(reverse bool) *bState {
298	352	s := &bState{
299		filler: newDefaultBarFiller(),
	353	filler: NewBarFiller(DefaultBarStyle, reverse),
300	354	bufP: new(bytes.Buffer),
301	355	bufB: new(bytes.Buffer),
302	356	bufA: new(bytes.Buffer),

+22

-22

example_test.go less more

0	0	package mpb_test
1	1
2	2	import (
	3	crand "crypto/rand"
3	4	"io"
4	5	"io/ioutil"
5	6	"math/rand"
6		"net/http"
7	7	"time"
8	8
9		"github.com/vbauerster/mpb"
10		"github.com/vbauerster/mpb/decor"
	9	"github.com/vbauerster/mpb/v5"
	10	"github.com/vbauerster/mpb/v5/decor"
11	11	)
12	12
13	13	func Example() {
14		p := mpb.New(
15		// override default (80) width
16		mpb.WithWidth(64),
17		// override default 120ms refresh rate
18		mpb.WithRefreshRate(180*time.Millisecond),
19		)
	14	// initialize progress container, with custom width
	15	p := mpb.New(mpb.WithWidth(64))
20	16
21	17	total := 100
22	18	name := "Single Bar:"
23		// adding a single bar
	19	// adding a single bar, which will inherit container's width
24	20	bar := p.AddBar(int64(total),
25		// override default "[=>-]" style
	21	// override DefaultBarStyle, which is "[=>-]<+"
26	22	mpb.BarStyle("╢▌▌░╟"),
27	23	mpb.PrependDecorators(
28	24	// display our name with one space on the right

38	34	// simulating some work
39	35	max := 100 * time.Millisecond
40	36	for i := 0; i < total; i++ {
	37	// start variable is solely for EWMA calculation
	38	// EWMA's unit of measure is an iteration's duration
41	39	start := time.Now()
42	40	time.Sleep(time.Duration(rand.Intn(10)+1) * max / 10)
43		// ewma based decorators require work duration measurement
44		bar.IncrBy(1, time.Since(start))
	41	bar.Increment()
	42	// we need to call DecoratorEwmaUpdate to fulfill ewma decorator's contract
	43	bar.DecoratorEwmaUpdate(time.Since(start))
45	44	}
46	45	// wait for our bar to complete and flush
47	46	p.Wait()

61	60	}
62	61
63	62	func ExampleBar_ProxyReader() {
	63	// import crand "crypto/rand"
	64
	65	var total int64 = 1024 * 1024 * 500
	66	reader := io.LimitReader(crand.Reader, total)
	67
64	68	p := mpb.New()
65		// make http get request, ignoring errors
66		resp, _ := http.Get("https://homebrew.bintray.com/bottles/libtiff-4.0.7.sierra.bottle.tar.gz")
67		defer resp.Body.Close()
68
69		// Assuming ContentLength > 0
70		bar := p.AddBar(resp.ContentLength,
	69	bar := p.AddBar(total,
71	70	mpb.AppendDecorators(
72		decor.CountersKibiByte("%6.1f / %6.1f"),
	71	decor.CountersKibiByte("% .2f / % .2f"),
73	72	),
74	73	)
75	74
76	75	// create proxy reader
77		reader := bar.ProxyReader(resp.Body)
	76	proxyReader := bar.ProxyReader(reader)
	77	defer proxyReader.Close()
78	78
79	79	// and copy from reader, ignoring errors
80		io.Copy(ioutil.Discard, reader)
	80	io.Copy(ioutil.Discard, proxyReader)
81	81
82	82	p.Wait()
83	83	}

+0

-60

~~examples/barNewLineExtend/main.go~~ less more

0		package main
1
2		import (
3		"fmt"
4		"io"
5		"math/rand"
6		"sync"
7		"time"
8
9		"github.com/vbauerster/mpb"
10		"github.com/vbauerster/mpb/decor"
11		)
12
13		func init() {
14		rand.Seed(time.Now().UnixNano())
15		}
16
17		func main() {
18		var wg sync.WaitGroup
19		p := mpb.New(mpb.WithWaitGroup(&wg))
20		total, numBars := 100, 3
21		wg.Add(numBars)
22
23		for i := 0; i < numBars; i++ {
24		name := fmt.Sprintf("Bar#%d:", i)
25		efn := func(w io.Writer, s *decor.Statistics) {
26		if s.Completed {
27		fmt.Fprintf(w, "Bar id: %d has been completed\n", s.ID)
28		}
29		}
30		bar := p.AddBar(int64(total), mpb.BarNewLineExtend(efn),
31		mpb.PrependDecorators(
32		// simple name decorator
33		decor.Name(name),
34		// decor.DSyncWidth bit enables column width synchronization
35		decor.Percentage(decor.WCSyncSpace),
36		),
37		mpb.AppendDecorators(
38		// replace ETA decorator with "done" message, OnComplete event
39		decor.OnComplete(
40		// ETA decorator with ewma age of 60
41		decor.EwmaETA(decor.ET_STYLE_GO, 60), "done",
42		),
43		),
44		)
45		// simulating some work
46		go func() {
47		defer wg.Done()
48		max := 100 * time.Millisecond
49		for i := 0; i < total; i++ {
50		start := time.Now()
51		time.Sleep(time.Duration(rand.Intn(10)+1) * max / 10)
52		// ewma based decorators require work duration measurement
53		bar.IncrBy(1, time.Since(start))
54		}
55		}()
56		}
57		// wait for all bars to complete and flush
58		p.Wait()
59		}

+0

-56

~~examples/cancel/main.go~~ less more

0		package main
1
2		import (
3		"context"
4		"fmt"
5		"math/rand"
6		"sync"
7		"time"
8
9		"github.com/vbauerster/mpb"
10		"github.com/vbauerster/mpb/decor"
11		)
12
13		func init() {
14		rand.Seed(time.Now().UnixNano())
15		}
16
17		func main() {
18		ctx, cancel := context.WithTimeout(context.Background(), 3*time.Second)
19		defer cancel()
20
21		var wg sync.WaitGroup
22		p := mpb.New(
23		mpb.WithWaitGroup(&wg),
24		mpb.WithContext(ctx),
25		)
26		total := 300
27		numBars := 3
28		wg.Add(numBars)
29
30		for i := 0; i < numBars; i++ {
31		name := fmt.Sprintf("Bar#%d:", i)
32		bar := p.AddBar(int64(total),
33		mpb.PrependDecorators(
34		decor.Name(name),
35		decor.EwmaETA(decor.ET_STYLE_GO, 60, decor.WCSyncSpace),
36		),
37		mpb.AppendDecorators(
38		decor.Percentage(decor.WC{W: 5}),
39		),
40		)
41
42		go func() {
43		defer wg.Done()
44		max := 100 * time.Millisecond
45		for !bar.Completed() {
46		start := time.Now()
47		time.Sleep(time.Duration(rand.Intn(10)+1) * max / 10)
48		// ewma based decorators require work duration measurement
49		bar.IncrBy(1, time.Since(start))
50		}
51		}()
52		}
53
54		p.Wait()
55		}

+0

-79

~~examples/complex/main.go~~ less more

0		package main
1
2		import (
3		"fmt"
4		"math/rand"
5		"sync"
6		"time"
7
8		"github.com/vbauerster/mpb"
9		"github.com/vbauerster/mpb/decor"
10		)
11
12		func init() {
13		rand.Seed(time.Now().UnixNano())
14		}
15
16		func main() {
17		doneWg := new(sync.WaitGroup)
18		p := mpb.New(mpb.WithWidth(64), mpb.WithWaitGroup(doneWg))
19		numBars := 4
20
21		var bars []*mpb.Bar
22		var downloadWgg []*sync.WaitGroup
23		for i := 0; i < numBars; i++ {
24		wg := new(sync.WaitGroup)
25		wg.Add(1)
26		downloadWgg = append(downloadWgg, wg)
27		task := fmt.Sprintf("Task#%02d:", i)
28		job := "downloading"
29		b := p.AddBar(rand.Int63n(201)+100,
30		mpb.BarRemoveOnComplete(),
31		mpb.PrependDecorators(
32		decor.Name(task, decor.WC{W: len(task) + 1, C: decor.DidentRight}),
33		decor.Name(job, decor.WCSyncSpaceR),
34		decor.CountersNoUnit("%d / %d", decor.WCSyncWidth),
35		),
36		mpb.AppendDecorators(decor.Percentage(decor.WC{W: 5})),
37		)
38		go newTask(wg, b, i+1)
39		bars = append(bars, b)
40		}
41
42		for i := 0; i < numBars; i++ {
43		doneWg.Add(1)
44		i := i
45		go func() {
46		task := fmt.Sprintf("Task#%02d:", i)
47		job := "installing"
48		// preparing delayed bars
49		b := p.AddBar(rand.Int63n(101)+100,
50		mpb.BarReplaceOnComplete(bars[i]),
51		mpb.BarClearOnComplete(),
52		mpb.PrependDecorators(
53		decor.Name(task, decor.WC{W: len(task) + 1, C: decor.DidentRight}),
54		decor.OnComplete(decor.Name(job, decor.WCSyncSpaceR), "done!"),
55		decor.OnComplete(decor.EwmaETA(decor.ET_STYLE_MMSS, 60, decor.WCSyncWidth), "")),
56		mpb.AppendDecorators(
57		decor.OnComplete(decor.Percentage(decor.WC{W: 5}), ""),
58		),
59		)
60		// waiting for download to complete, before starting install job
61		downloadWgg[i].Wait()
62		go newTask(doneWg, b, numBars-i)
63		}()
64		}
65
66		p.Wait()
67		}
68
69		func newTask(wg sync.WaitGroup, b mpb.Bar, incrBy int) {
70		defer wg.Done()
71		max := 100 * time.Millisecond
72		for !b.Completed() {
73		start := time.Now()
74		time.Sleep(time.Duration(rand.Intn(10)+1) * max / 10)
75		// ewma based decorators require work duration measurement
76		b.IncrBy(incrBy, time.Since(start))
77		}
78		}

+0

-60

~~examples/differentWidth/main.go~~ less more

0		package main
1
2		import (
3		"fmt"
4		"math/rand"
5		"sync"
6		"time"
7
8		"github.com/vbauerster/mpb"
9		"github.com/vbauerster/mpb/decor"
10		)
11
12		func init() {
13		rand.Seed(time.Now().UnixNano())
14		}
15
16		func main() {
17		var wg sync.WaitGroup
18		p := mpb.New(
19		mpb.WithWaitGroup(&wg),
20		// container's width.
21		mpb.WithWidth(60),
22		)
23		total, numBars := 100, 3
24		wg.Add(numBars)
25
26		for i := 0; i < numBars; i++ {
27		name := fmt.Sprintf("Bar#%d:", i)
28		bar := p.AddBar(int64(total),
29		// set BarWidth 40 for bar 1 and 2
30		mpb.OptionOnCondition(mpb.BarWidth(40), func() bool { return i > 0 }),
31		mpb.PrependDecorators(
32		// simple name decorator
33		decor.Name(name),
34		// decor.DSyncWidth bit enables column width synchronization
35		decor.Percentage(decor.WCSyncSpace),
36		),
37		mpb.AppendDecorators(
38		// replace ETA decorator with "done" message, OnComplete event
39		decor.OnComplete(
40		// ETA decorator with ewma age of 60
41		decor.EwmaETA(decor.ET_STYLE_GO, 60), "done",
42		),
43		),
44		)
45		// simulating some work
46		go func() {
47		defer wg.Done()
48		max := 100 * time.Millisecond
49		for i := 0; i < total; i++ {
50		start := time.Now()
51		time.Sleep(time.Duration(rand.Intn(10)+1) * max / 10)
52		// ewma based decorators require work duration measurement
53		bar.IncrBy(1, time.Since(start))
54		}
55		}()
56		}
57		// wait for all bars to complete and flush
58		p.Wait()
59		}

+0

-52

~~examples/dynTotal/main.go~~ less more

0		package main
1
2		import (
3		"io"
4		"math/rand"
5		"time"
6
7		"github.com/vbauerster/mpb"
8		"github.com/vbauerster/mpb/decor"
9		)
10
11		func init() {
12		rand.Seed(time.Now().UnixNano())
13		}
14
15		func main() {
16		p := mpb.New(mpb.WithWidth(64))
17
18		var total int64
19		bar := p.AddBar(total,
20		mpb.PrependDecorators(decor.Counters(decor.UnitKiB, "% .1f / % .1f")),
21		mpb.AppendDecorators(decor.Percentage()),
22		)
23
24		maxSleep := 100 * time.Millisecond
25		read := makeStream(200)
26		for {
27		n, err := read()
28		total += int64(n)
29		time.Sleep(time.Duration(rand.Intn(10)+1) * maxSleep / 10)
30		bar.IncrBy(n)
31		if err == io.EOF {
32		// total is known, final=true
33		bar.SetTotal(total, true)
34		break
35		}
36		// total is unknown, final=false
37		bar.SetTotal(total+2048, false)
38		}
39
40		p.Wait()
41		}
42
43		func makeStream(limit int) func() (int, error) {
44		return func() (int, error) {
45		if limit <= 0 {
46		return 0, io.EOF
47		}
48		limit--
49		return rand.Intn(1024) + 1, nil
50		}
51		}

+0

-1

~~examples/gifs/godEMrCZmJkHYH1X9dN4Nm0U7.svg~~ less more

0

+0

-1

~~examples/gifs/hIpTa3A5rQz65ssiVuRJu87X6.svg~~ less more

0

+0

-1

~~examples/gifs/wHzf1M7sd7B3zVa2scBMnjqRf.svg~~ less more

0

+0

-83

~~examples/io/multiple/main.go~~ less more

0		package main
1
2		import (
3		"fmt"
4		"io"
5		"log"
6		"net/http"
7		"os"
8		"path/filepath"
9		"sync"
10
11		"github.com/vbauerster/mpb"
12		"github.com/vbauerster/mpb/decor"
13		)
14
15		func main() {
16		log.SetOutput(os.Stderr)
17
18		url1 := "https://homebrew.bintray.com/bottles/youtube-dl-2016.12.12.sierra.bottle.tar.gz"
19		url2 := "https://homebrew.bintray.com/bottles/libtiff-4.0.7.sierra.bottle.tar.gz"
20
21		var wg sync.WaitGroup
22		p := mpb.New(mpb.WithWidth(64), mpb.WithWaitGroup(&wg))
23
24		for i, url := range [...]string{url1, url2} {
25		wg.Add(1)
26		name := fmt.Sprintf("url%d:", i+1)
27		go download(&wg, p, name, url, i)
28		}
29
30		p.Wait()
31		}
32
33		func download(wg sync.WaitGroup, p mpb.Progress, name, url string, n int) {
34		defer wg.Done()
35		resp, err := http.Get(url)
36		if err != nil {
37		log.Printf("%s: %v", name, err)
38		return
39		}
40		defer resp.Body.Close()
41
42		if resp.StatusCode != http.StatusOK {
43		err = fmt.Errorf("non-200 status: %s", resp.Status)
44		log.Printf("%s: %v", name, err)
45		return
46		}
47
48		size := resp.ContentLength
49
50		// create dest
51		destName := filepath.Base(url)
52		dest, err := os.Create(destName)
53		if err != nil {
54		err = fmt.Errorf("Can't create %s: %v", destName, err)
55		log.Printf("%s: %v", name, err)
56		return
57		}
58
59		// create bar with appropriate decorators
60		bar := p.AddBar(size, mpb.BarPriority(n),
61		mpb.PrependDecorators(
62		decor.Name(name, decor.WC{W: len(name) + 1, C: decor.DidentRight}),
63		decor.CountersKibiByte("%6.1f / %6.1f", decor.WCSyncWidth),
64		),
65		mpb.AppendDecorators(
66		decor.EwmaETA(decor.ET_STYLE_HHMMSS, 1024*4, decor.WCSyncWidth),
67		decor.AverageSpeed(decor.UnitKiB, "% .2f"),
68		),
69		)
70
71		// create proxy reader
72		reader := bar.ProxyReader(resp.Body)
73		// and copy from reader
74		_, err = io.Copy(dest, reader)
75
76		if e := dest.Close(); err == nil {
77		err = e
78		}
79		if err != nil {
80		log.Printf("%s: %v", name, err)
81		}
82		}

+0

-63

~~examples/io/single/main.go~~ less more

0		package main
1
2		import (
3		"fmt"
4		"io"
5		"net/http"
6		"os"
7		"path/filepath"
8		"time"
9
10		"github.com/vbauerster/mpb"
11		"github.com/vbauerster/mpb/decor"
12		)
13
14		func main() {
15		url := "https://github.com/onivim/oni/releases/download/v0.3.4/Oni-0.3.4-amd64-linux.deb"
16
17		resp, err := http.Get(url)
18		if err != nil {
19		panic(err)
20		}
21		defer resp.Body.Close()
22
23		if resp.StatusCode != http.StatusOK {
24		fmt.Printf("Server return non-200 status: %s\n", resp.Status)
25		return
26		}
27
28		size := resp.ContentLength
29
30		// create dest
31		destName := filepath.Base(url)
32		dest, err := os.Create(destName)
33		if err != nil {
34		fmt.Printf("Can't create %s: %v\n", destName, err)
35		return
36		}
37		defer dest.Close()
38
39		p := mpb.New(
40		mpb.WithWidth(60),
41		mpb.WithRefreshRate(180*time.Millisecond),
42		)
43
44		bar := p.AddBar(size, mpb.BarStyle("[=>-\|"),
45		mpb.PrependDecorators(
46		decor.CountersKibiByte("% 6.1f / % 6.1f"),
47		),
48		mpb.AppendDecorators(
49		decor.EwmaETA(decor.ET_STYLE_MMSS, float64(size)/2048),
50		decor.Name(" ] "),
51		decor.AverageSpeed(decor.UnitKiB, "% .2f"),
52		),
53		)
54
55		// create proxy reader
56		reader := bar.ProxyReader(resp.Body)
57
58		// and copy from reader, ignoring errors
59		io.Copy(dest, reader)
60
61		p.Wait()
62		}

+0

-57

~~examples/panic/main.go~~ less more

0		package main
1
2		import (
3		"fmt"
4		"os"
5		"sync"
6		"time"
7
8		"github.com/vbauerster/mpb"
9		"github.com/vbauerster/mpb/decor"
10		)
11
12		func main() {
13		var wg sync.WaitGroup
14		p := mpb.New(mpb.WithWaitGroup(&wg), mpb.WithDebugOutput(os.Stderr))
15
16		wantPanic := "Some really long panic panic panic panic panic panic panic, really it is very long"
17		numBars := 3
18		wg.Add(numBars)
19
20		for i := 0; i < numBars; i++ {
21		name := fmt.Sprintf("b#%02d:", i)
22		bar := p.AddBar(100, mpb.BarID(i), mpb.PrependDecorators(panicDecorator(name, wantPanic)))
23
24		go func() {
25		defer wg.Done()
26		for i := 0; i < 100; i++ {
27		time.Sleep(50 * time.Millisecond)
28		bar.Increment()
29		}
30		}()
31		}
32
33		p.Wait()
34		}
35
36		func panicDecorator(name, panicMsg string) decor.Decorator {
37		d := &decorator{
38		msg: name,
39		panicMsg: panicMsg,
40		}
41		d.Init()
42		return d
43		}
44
45		type decorator struct {
46		decor.WC
47		msg string
48		panicMsg string
49		}
50
51		func (d decorator) Decor(st decor.Statistics) string {
52		if st.ID == 1 && st.Current >= 42 {
53		panic(d.panicMsg)
54		}
55		return d.FormatMsg(d.msg)
56		}

+0

-51

~~examples/remove/main.go~~ less more

0		package main
1
2		import (
3		"fmt"
4		"math/rand"
5		"sync"
6		"time"
7
8		"github.com/vbauerster/mpb"
9		"github.com/vbauerster/mpb/decor"
10		)
11
12		func init() {
13		rand.Seed(time.Now().UnixNano())
14		}
15
16		func main() {
17		var wg sync.WaitGroup
18		p := mpb.New(mpb.WithWaitGroup(&wg))
19		total := 100
20		numBars := 3
21		wg.Add(numBars)
22
23		for i := 0; i < numBars; i++ {
24		name := fmt.Sprintf("Bar#%d:", i)
25		b := p.AddBar(int64(total), mpb.BarID(i),
26		mpb.OptionOnCondition(mpb.BarRemoveOnComplete(), func() bool { return i == 0 }),
27		mpb.PrependDecorators(
28		decor.Name(name),
29		decor.EwmaETA(decor.ET_STYLE_GO, 60, decor.WCSyncSpace),
30		),
31		mpb.AppendDecorators(decor.Percentage()),
32		)
33		go func() {
34		defer wg.Done()
35		max := 100 * time.Millisecond
36		for i := 0; i < total; i++ {
37		start := time.Now()
38		if b.ID() == 2 && i == 42 {
39		p.Abort(b, true)
40		return
41		}
42		time.Sleep(time.Duration(rand.Intn(10)+1) * max / 10)
43		// ewma based decorators require work duration measurement
44		b.IncrBy(1, time.Since(start))
45		}
46		}()
47		}
48
49		p.Wait()
50		}

+0

-54

~~examples/simple/main.go~~ less more

0		package main
1
2		import (
3		"fmt"
4		"math/rand"
5		"sync"
6		"time"
7
8		"github.com/vbauerster/mpb"
9		"github.com/vbauerster/mpb/decor"
10		)
11
12		func init() {
13		rand.Seed(time.Now().UnixNano())
14		}
15
16		func main() {
17		var wg sync.WaitGroup
18		p := mpb.New(mpb.WithWaitGroup(&wg))
19		total, numBars := 100, 3
20		wg.Add(numBars)
21
22		for i := 0; i < numBars; i++ {
23		name := fmt.Sprintf("Bar#%d:", i)
24		bar := p.AddBar(int64(total),
25		mpb.PrependDecorators(
26		// simple name decorator
27		decor.Name(name),
28		// decor.DSyncWidth bit enables column width synchronization
29		decor.Percentage(decor.WCSyncSpace),
30		),
31		mpb.AppendDecorators(
32		// replace ETA decorator with "done" message, OnComplete event
33		decor.OnComplete(
34		// ETA decorator with ewma age of 60
35		decor.EwmaETA(decor.ET_STYLE_GO, 60), "done",
36		),
37		),
38		)
39		// simulating some work
40		go func() {
41		defer wg.Done()
42		max := 100 * time.Millisecond
43		for i := 0; i < total; i++ {
44		start := time.Now()
45		time.Sleep(time.Duration(rand.Intn(10)+1) * max / 10)
46		// ewma based decorators require work duration measurement
47		bar.IncrBy(1, time.Since(start))
48		}
49		}()
50		}
51		// wait for all bars to complete and flush
52		p.Wait()
53		}

+0

-46

~~examples/singleBar/main.go~~ less more

0		package main
1
2		import (
3		"math/rand"
4		"time"
5
6		"github.com/vbauerster/mpb"
7		"github.com/vbauerster/mpb/decor"
8		)
9
10		func main() {
11		p := mpb.New(
12		// override default (80) width
13		mpb.WithWidth(64),
14		// override default 120ms refresh rate
15		mpb.WithRefreshRate(180*time.Millisecond),
16		)
17
18		total := 100
19		name := "Single Bar:"
20		// adding a single bar
21		bar := p.AddBar(int64(total),
22		// override default "[=>-]" style
23		mpb.BarStyle("╢▌▌░╟"),
24		mpb.PrependDecorators(
25		// display our name with one space on the right
26		decor.Name(name, decor.WC{W: len(name) + 1, C: decor.DidentRight}),
27		// replace ETA decorator with "done" message, OnComplete event
28		decor.OnComplete(
29		// ETA decorator with ewma age of 60, and width reservation of 4
30		decor.EwmaETA(decor.ET_STYLE_GO, 60, decor.WC{W: 4}), "done",
31		),
32		),
33		mpb.AppendDecorators(decor.Percentage()),
34		)
35		// simulating some work
36		max := 100 * time.Millisecond
37		for i := 0; i < total; i++ {
38		start := time.Now()
39		time.Sleep(time.Duration(rand.Intn(10)+1) * max / 10)
40		// ewma based decorators require work duration measurement
41		bar.IncrBy(1, time.Since(start))
42		}
43		// wait for our bar to complete and flush
44		p.Wait()
45		}

+0

-55

~~examples/sort/main.go~~ less more

0		package main
1
2		import (
3		"fmt"
4		"math/rand"
5		"sync"
6		"time"
7
8		"github.com/vbauerster/mpb"
9		"github.com/vbauerster/mpb/decor"
10		)
11
12		func init() {
13		rand.Seed(time.Now().UnixNano())
14		}
15
16		func main() {
17		var wg sync.WaitGroup
18		p := mpb.New(mpb.WithWaitGroup(&wg))
19		total := 100
20		numBars := 3
21		wg.Add(numBars)
22
23		for i := 0; i < numBars; i++ {
24		var name string
25		if i != 1 {
26		name = fmt.Sprintf("Bar#%d:", i)
27		}
28		b := p.AddBar(int64(total),
29		mpb.PrependDecorators(
30		decor.Name(name, decor.WCSyncWidth),
31		decor.CountersNoUnit("%d / %d", decor.WCSyncSpace),
32		),
33		mpb.AppendDecorators(
34		decor.EwmaETA(decor.ET_STYLE_GO, 60, decor.WC{W: 3}),
35		),
36		)
37		go func() {
38		defer wg.Done()
39		max := 100 * time.Millisecond
40		for i := 0; i < total; i++ {
41		start := time.Now()
42		time.Sleep(time.Duration(rand.Intn(10)+1) * max / 10)
43		if i&1 == 1 {
44		priority := total - int(b.Current())
45		p.UpdateBarPriority(b, priority)
46		}
47		// ewma based decorators require work duration measurement
48		b.IncrBy(1, time.Since(start))
49		}
50		}()
51		}
52
53		p.Wait()
54		}

+0

-77

~~examples/spinner/main.go~~ less more

0		package main
1
2		import (
3		"fmt"
4		"math/rand"
5		"sync"
6		"time"
7
8		"github.com/vbauerster/mpb"
9		"github.com/vbauerster/mpb/decor"
10		)
11
12		func init() {
13		rand.Seed(time.Now().UnixNano())
14		}
15
16		func main() {
17		var wg sync.WaitGroup
18		p := mpb.New(
19		mpb.WithWaitGroup(&wg),
20		mpb.WithWidth(13),
21		)
22		total, numBars := 101, 3
23		wg.Add(numBars)
24
25		for i := 0; i < numBars; i++ {
26		name := fmt.Sprintf("Bar#%d:", i)
27		var bar *mpb.Bar
28		if i == 0 {
29		bar = p.AddBar(int64(total),
30		// override default "[=>-]" style
31		mpb.BarStyle("╢▌▌░╟"),
32		mpb.PrependDecorators(
33		// simple name decorator
34		decor.Name(name),
35		),
36		mpb.AppendDecorators(
37		// replace ETA decorator with "done" message, OnComplete event
38		decor.OnComplete(
39		// ETA decorator with ewma age of 60
40		decor.EwmaETA(decor.ET_STYLE_GO, 60), "done",
41		),
42		),
43		)
44		} else {
45		bar = p.AddSpinner(int64(total), mpb.SpinnerOnMiddle,
46		// override default {"⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"} style
47		mpb.SpinnerStyle([]string{"∙∙∙", "●∙∙", "∙●∙", "∙∙●", "∙∙∙"}),
48		mpb.PrependDecorators(
49		// simple name decorator
50		decor.Name(name),
51		),
52		mpb.AppendDecorators(
53		// replace ETA decorator with "done" message, OnComplete event
54		decor.OnComplete(
55		// ETA decorator with ewma age of 60
56		decor.EwmaETA(decor.ET_STYLE_GO, 60), "done",
57		),
58		),
59		)
60		}
61
62		// simulating some work
63		go func() {
64		defer wg.Done()
65		max := 100 * time.Millisecond
66		for i := 0; i < total; i++ {
67		start := time.Now()
68		time.Sleep(time.Duration(rand.Intn(10)+1) * max / 10)
69		// ewma based decorators require work duration measurement
70		bar.IncrBy(1, time.Since(start))
71		}
72		}()
73		}
74		// wait for all bars to complete and flush
75		p.Wait()
76		}

+0

-55

~~examples/stress/main.go~~ less more

0		package main
1
2		import (
3		"fmt"
4		"math/rand"
5		"sync"
6		"time"
7
8		"github.com/vbauerster/mpb"
9		"github.com/vbauerster/mpb/decor"
10		)
11
12		const (
13		totalBars = 32
14		)
15
16		func init() {
17		rand.Seed(time.Now().UnixNano())
18		}
19
20		func main() {
21		var wg sync.WaitGroup
22		p := mpb.New(
23		mpb.WithWaitGroup(&wg),
24		mpb.WithRefreshRate(50*time.Millisecond),
25		)
26		wg.Add(totalBars)
27
28		for i := 0; i < totalBars; i++ {
29		name := fmt.Sprintf("Bar#%02d: ", i)
30		total := rand.Intn(320) + 10
31		bar := p.AddBar(int64(total),
32		mpb.PrependDecorators(
33		decor.Name(name),
34		decor.EwmaETA(decor.ET_STYLE_GO, 60, decor.WCSyncSpace),
35		),
36		mpb.AppendDecorators(
37		decor.Percentage(decor.WC{W: 5}),
38		),
39		)
40
41		go func() {
42		defer wg.Done()
43		max := 100 * time.Millisecond
44		for !bar.Completed() {
45		start := time.Now()
46		time.Sleep(time.Duration(rand.Intn(10)+1) * max / 10)
47		// ewma based decorators require work duration measurement
48		bar.IncrBy(1, time.Since(start))
49		}
50		}()
51		}
52
53		p.Wait()
54		}

+2

-4

export_test.go less more

0	0	package mpb
1	1
2		var (
3		SyncWidth = syncWidth
4		DefaultBarStyle = defaultBarStyle
5		)
	2	// make syncWidth func public in test
	3	var SyncWidth = syncWidth

+10

-0

go.mod less more

	0	module github.com/vbauerster/mpb/v5
	1
	2	require (
	3	github.com/VividCortex/ewma v1.1.1
	4	github.com/acarl005/stripansi v0.0.0-20180116102854-5a71ef0e047d
	5	golang.org/x/crypto v0.0.0-20200311171314-f7b00557c8c4
	6	golang.org/x/sys v0.0.0-20200302150141-5c8b2ff67527 // indirect
	7	)
	8
	9	go 1.14

+13

-0

go.sum less more

	0	github.com/VividCortex/ewma v1.1.1 h1:MnEK4VOv6n0RSY4vtRe3h11qjxL3+t0B8yOL8iMXdcM=
	1	github.com/VividCortex/ewma v1.1.1/go.mod h1:2Tkkvm3sRDVXaiyucHiACn4cqf7DpdyLvmxzcbUokwA=
	2	github.com/acarl005/stripansi v0.0.0-20180116102854-5a71ef0e047d h1:licZJFw2RwpHMqeKTCYkitsPqHNxTmd4SNR5r94FGM8=
	3	github.com/acarl005/stripansi v0.0.0-20180116102854-5a71ef0e047d/go.mod h1:asat636LX7Bqt5lYEZ27JNDcqxfjdBQuJ/MM4CN/Lzo=
	4	golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
	5	golang.org/x/crypto v0.0.0-20200311171314-f7b00557c8c4 h1:QmwruyY+bKbDDL0BaglrbZABEali68eoMFhTZpCjYVA=
	6	golang.org/x/crypto v0.0.0-20200311171314-f7b00557c8c4/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
	7	golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
	8	golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
	9	golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
	10	golang.org/x/sys v0.0.0-20200302150141-5c8b2ff67527 h1:uYVVQ9WP/Ds2ROhcaGPeIdVq0RIXVLwsHlnvJ+cT1So=
	11	golang.org/x/sys v0.0.0-20200302150141-5c8b2ff67527/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
	12	golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=

+0

-12

~~go.test.sh~~ less more

0		#!/usr/bin/env bash
1
2		set -e
3		echo "" > coverage.txt
4
5		for d in $(go list ./... \| grep -v vendor); do
6		go test -race -coverprofile=profile.out -covermode=atomic $d
7		if [ -f profile.out ]; then
8		cat profile.out >> coverage.txt
9		rm profile.out
10		fi
11		done

+6

-3

internal/percentage.go less more

2	2	import "math"
3	3
4	4	// Percentage is a helper function, to calculate percentage.
5		func Percentage(total, current, width int64) int64 {
	5	func Percentage(total, current int64, width int) float64 {
6	6	if total <= 0 {
7	7	return 0
8	8	}
9		p := float64(width*current) / float64(total)
10		return int64(math.Round(p))
	9	return float64(int64(width)*current) / float64(total)
11	10	}
	11
	12	func PercentageRound(total, current int64, width int) float64 {
	13	return math.Round(Percentage(total, current, width))
	14	}

+6

-4

internal/percentage_test.go less more

3	3
4	4	func TestPercentage(t *testing.T) {
5	5	// key is barWidth
6		testSuite := map[int64][]struct {
7		name string
8		total, current, expected int64
	6	testSuite := map[int][]struct {
	7	name string
	8	total int64
	9	current int64
	10	expected int64
9	11	}{
10	12	100: {
11	13	{"t,c,e{-1,-1,0}", -1, -1, 0},

63	65
64	66	for width, cases := range testSuite {
65	67	for _, tc := range cases {
66		got := Percentage(tc.total, tc.current, width)
	68	got := int64(PercentageRound(tc.total, tc.current, width))
67	69	if got != tc.expected {
68	70	t.Errorf("width %d; %s: Expected: %d, got: %d\n", width, tc.name, tc.expected, got)
69	71	}

+45

-30

options.go less more

0	0	package mpb
1	1
2	2	import (
3		"context"
4	3	"io"
	4	"io/ioutil"
5	5	"sync"
6	6	"time"
7
8		"github.com/vbauerster/mpb/cwriter"
9	7	)
10	8
11		// ProgressOption is a function option which changes the default
12		// behavior of progress pool, if passed to mpb.New(...ProgressOption).
13		type ProgressOption func(*pState)
	9	// ContainerOption is a function option which changes the default
	10	// behavior of progress container, if passed to mpb.New(...ContainerOption).
	11	type ContainerOption func(*pState)
14	12
15	13	// WithWaitGroup provides means to have a single joint point. If
16	14	// *sync.WaitGroup is provided, you can safely call just p.Wait()
17	15	// without calling Wait() on provided *sync.WaitGroup. Makes sense
18	16	// when there are more than one bar to render.
19		func WithWaitGroup(wg *sync.WaitGroup) ProgressOption {
	17	func WithWaitGroup(wg *sync.WaitGroup) ContainerOption {
20	18	return func(s *pState) {
21	19	s.uwg = wg
22	20	}

24	22
25	23	// WithWidth sets container width. Default is 80. Bars inherit this
26	24	// width, as long as no BarWidth is applied.
27		func WithWidth(w int) ProgressOption {
	25	func WithWidth(w int) ContainerOption {
28	26	return func(s *pState) {
29		if w >= 0 {
30		s.width = w
	27	if w < 0 {
	28	return
31	29	}
	30	s.width = w
32	31	}
33	32	}
34	33
35	34	// WithRefreshRate overrides default 120ms refresh rate.
36		func WithRefreshRate(d time.Duration) ProgressOption {
	35	func WithRefreshRate(d time.Duration) ContainerOption {
37	36	return func(s *pState) {
38		if d < 10*time.Millisecond {
39		return
40		}
41	37	s.rr = d
42	38	}
43	39	}
44	40
45	41	// WithManualRefresh disables internal auto refresh time.Ticker.
46	42	// Refresh will occur upon receive value from provided ch.
47		func WithManualRefresh(ch <-chan time.Time) ProgressOption {
	43	func WithManualRefresh(ch <-chan time.Time) ContainerOption {
48	44	return func(s *pState) {
49		s.manualRefreshCh = ch
	45	s.refreshSrc = ch
50	46	}
51	47	}
52	48
53		// WithContext provided context will be used for cancellation purposes.
54		func WithContext(ctx context.Context) ProgressOption {
	49	// WithRenderDelay delays rendering. By default rendering starts as
	50	// soon as bar is added, with this option it's possible to delay
	51	// rendering process by keeping provided chan unclosed. In other words
	52	// rendering will start as soon as provided chan is closed.
	53	func WithRenderDelay(ch <-chan struct{}) ContainerOption {
55	54	return func(s *pState) {
56		if ctx == nil {
57		return
58		}
59		s.ctx = ctx
	55	s.renderDelay = ch
60	56	}
61	57	}
62	58
63	59	// WithShutdownNotifier provided chanel will be closed, after all bars
64	60	// have been rendered.
65		func WithShutdownNotifier(ch chan struct{}) ProgressOption {
	61	func WithShutdownNotifier(ch chan struct{}) ContainerOption {
66	62	return func(s *pState) {
67	63	s.shutdownNotifier = ch
68	64	}
69	65	}
70	66
71		// WithOutput overrides default output os.Stdout.
72		func WithOutput(w io.Writer) ProgressOption {
	67	// WithOutput overrides default os.Stdout output. Setting it to nil
	68	// will effectively disable auto refresh rate and discard any output,
	69	// useful if you want to disable progress bars with little overhead.
	70	func WithOutput(w io.Writer) ContainerOption {
73	71	return func(s *pState) {
74	72	if w == nil {
	73	s.refreshSrc = make(chan time.Time)
	74	s.output = ioutil.Discard
75	75	return
76	76	}
77		s.cw = cwriter.New(w)
	77	s.output = w
78	78	}
79	79	}
80	80
81	81	// WithDebugOutput sets debug output.
82		func WithDebugOutput(w io.Writer) ProgressOption {
	82	func WithDebugOutput(w io.Writer) ContainerOption {
	83	if w == nil {
	84	return nil
	85	}
83	86	return func(s *pState) {
84		if w == nil {
85		return
86		}
87	87	s.debugOut = w
88	88	}
89	89	}
	90
	91	// PopCompletedMode will pop and stop rendering completed bars.
	92	func PopCompletedMode() ContainerOption {
	93	return func(s *pState) {
	94	s.popCompleted = true
	95	}
	96	}
	97
	98	// ContainerOptOn returns option when condition evaluates to true.
	99	func ContainerOptOn(option ContainerOption, condition func() bool) ContainerOption {
	100	if condition() {
	101	return option
	102	}
	103	return nil
	104	}

+7

-15

priority_queue.go less more

0	0	package mpb
1
2		import "container/heap"
3	1
4	2	// A priorityQueue implements heap.Interface
5	3	type priorityQueue []*Bar

17	15	}
18	16
19	17	func (pq *priorityQueue) Push(x interface{}) {
20		n := len(*pq)
	18	s := *pq
21	19	bar := x.(*Bar)
22		bar.index = n
23		pq = append(pq, bar)
	20	bar.index = len(s)
	21	s = append(s, bar)
	22	*pq = s
24	23	}
25	24
26	25	func (pq *priorityQueue) Pop() interface{} {
27		old := *pq
28		n := len(old)
29		bar := old[n-1]
	26	s := *pq
	27	*pq = s[0 : len(s)-1]
	28	bar := s[len(s)-1]
30	29	bar.index = -1 // for safety
31		*pq = old[0 : n-1]
32	30	return bar
33	31	}
34
35		// update modifies the priority of a Bar in the queue.
36		func (pq priorityQueue) update(bar Bar, priority int) {
37		bar.priority = priority
38		heap.Fix(pq, bar.index)
39		}

+269

-137

progress.go less more

0	0	package mpb
1	1
2	2	import (
	3	"bytes"
3	4	"container/heap"
4	5	"context"
5	6	"fmt"
6	7	"io"
7	8	"io/ioutil"
	9	"log"
8	10	"os"
9	11	"sync"
10	12	"time"
11	13
12		"github.com/vbauerster/mpb/cwriter"
	14	"github.com/vbauerster/mpb/v5/cwriter"
	15	"github.com/vbauerster/mpb/v5/decor"
13	16	)
14	17
15	18	const (

21	24
22	25	// Progress represents the container that renders Progress bars
23	26	type Progress struct {
24		wg *sync.WaitGroup
	27	ctx context.Context
25	28	uwg *sync.WaitGroup
	29	cwg *sync.WaitGroup
	30	bwg *sync.WaitGroup
26	31	operateState chan func(*pState)
27	32	done chan struct{}
	33	refreshCh chan time.Time
	34	once sync.Once
	35	dlogger *log.Logger
28	36	}
29	37
30	38	type pState struct {
31		bHeap *priorityQueue
32		shutdownPending []*Bar
33		heapUpdated bool
34		zeroWait bool
35		idCounter int
36		width int
37		format string
38		rr time.Duration
39		cw *cwriter.Writer
40		pMatrix map[int][]chan int
41		aMatrix map[int][]chan int
	39	bHeap priorityQueue
	40	heapUpdated bool
	41	pMatrix map[int][]chan int
	42	aMatrix map[int][]chan int
	43	barShutdownQueue []*Bar
	44	barPopQueue []*Bar
42	45
43	46	// following are provided/overrided by user
44		ctx context.Context
	47	idCount int
	48	width int
	49	popCompleted bool
	50	rr time.Duration
45	51	uwg *sync.WaitGroup
46		manualRefreshCh <-chan time.Time
	52	refreshSrc <-chan time.Time
	53	renderDelay <-chan struct{}
47	54	shutdownNotifier chan struct{}
48		waitBars map[Bar]Bar
	55	parkedBars map[Bar]Bar
	56	output io.Writer
49	57	debugOut io.Writer
50	58	}
51	59
52		// New creates new Progress instance, which orchestrates bars rendering
53		// process. Accepts mpb.ProgressOption funcs for customization.
54		func New(options ...ProgressOption) *Progress {
55		pq := make(priorityQueue, 0)
56		heap.Init(&pq)
	60	// New creates new Progress container instance. It's not possible to
	61	// reuse instance after *Progress.Wait() method has been called.
	62	func New(options ...ContainerOption) *Progress {
	63	return NewWithContext(context.Background(), options...)
	64	}
	65
	66	// NewWithContext creates new Progress container instance with provided
	67	// context. It's not possible to reuse instance after *Progress.Wait()
	68	// method has been called.
	69	func NewWithContext(ctx context.Context, options ...ContainerOption) *Progress {
57	70	s := &pState{
58		ctx: context.Background(),
59		bHeap: &pq,
60		width: pwidth,
61		cw: cwriter.New(os.Stdout),
62		rr: prr,
63		waitBars: make(map[Bar]Bar),
64		debugOut: ioutil.Discard,
	71	bHeap: priorityQueue{},
	72	width: pwidth,
	73	rr: prr,
	74	parkedBars: make(map[Bar]Bar),
	75	output: os.Stdout,
	76	debugOut: ioutil.Discard,
65	77	}
66	78
67	79	for _, opt := range options {

71	83	}
72	84
73	85	p := &Progress{
	86	ctx: ctx,
74	87	uwg: s.uwg,
75		wg: new(sync.WaitGroup),
	88	cwg: new(sync.WaitGroup),
	89	bwg: new(sync.WaitGroup),
76	90	operateState: make(chan func(*pState)),
77	91	done: make(chan struct{}),
78		}
79		go p.serve(s)
	92	dlogger: log.New(s.debugOut, "[mpb] ", log.Lshortfile),
	93	}
	94
	95	p.cwg.Add(1)
	96	go p.serve(s, cwriter.New(s.output))
80	97	return p
81	98	}
82	99
83		// AddBar creates a new progress bar and adds to the container.
	100	// AddBar creates a new progress bar and adds it to the rendering queue.
84	101	func (p Progress) AddBar(total int64, options ...BarOption) Bar {
85		return p.Add(total, newDefaultBarFiller(), options...)
86		}
87
88		// AddSpinner creates a new spinner bar and adds to the container.
	102	return p.Add(total, NewBarFiller(DefaultBarStyle, false), options...)
	103	}
	104
	105	// AddSpinner creates a new spinner bar and adds it to the rendering queue.
89	106	func (p Progress) AddSpinner(total int64, alignment SpinnerAlignment, options ...BarOption) Bar {
90		filler := &spinnerFiller{
91		frames: defaultSpinnerStyle,
92		alignment: alignment,
93		}
94		return p.Add(total, filler, options...)
	107	return p.Add(total, NewSpinnerFiller(DefaultSpinnerStyle, alignment), options...)
95	108	}
96	109
97	110	// Add creates a bar which renders itself by provided filler.
98		func (p Progress) Add(total int64, filler Filler, options ...BarOption) Bar {
	111	// Set total to 0, if you plan to update it later.
	112	// Panics if Progress instance is done, i.e. called after Progress.Wait().
	113	func (p Progress) Add(total int64, filler BarFiller, options ...BarOption) Bar {
99	114	if filler == nil {
100		filler = newDefaultBarFiller()
101		}
102		p.wg.Add(1)
	115	filler = NewBarFiller(DefaultBarStyle, false)
	116	}
	117	p.bwg.Add(1)
103	118	result := make(chan *Bar)
104	119	select {
105		case p.operateState <- func(s *pState) {
106		b := newBar(s.ctx, p.wg, filler, s.idCounter, s.width, total, options...)
107		if b.runningBar != nil {
108		s.waitBars[b.runningBar] = b
	120	case p.operateState <- func(ps *pState) {
	121	bs := ps.makeBarState(total, filler, options...)
	122	bar := newBar(p, bs)
	123	if bs.runningBar != nil {
	124	bs.runningBar.noPop = true
	125	ps.parkedBars[bs.runningBar] = bar
109	126	} else {
110		heap.Push(s.bHeap, b)
111		s.heapUpdated = true
112		}
113		s.idCounter++
114		result <- b
	127	heap.Push(&ps.bHeap, bar)
	128	ps.heapUpdated = true
	129	}
	130	ps.idCount++
	131	result <- bar
115	132	}:
116		return <-result
	133	bar := <-result
	134	bar.subscribeDecorators()
	135	return bar
117	136	case <-p.done:
118		p.wg.Done()
119		return nil
120		}
121		}
122
123		// Abort is only effective while bar progress is running, it means
124		// remove bar now without waiting for its completion. If bar is already
125		// completed, there is nothing to abort. If you need to remove bar
126		// after completion, use BarRemoveOnComplete BarOption.
127		func (p Progress) Abort(b Bar, remove bool) {
	137	p.bwg.Done()
	138	panic(fmt.Sprintf("%T instance can't be reused after it's done!", p))
	139	}
	140	}
	141
	142	func (p Progress) dropBar(b Bar) {
128	143	select {
129	144	case p.operateState <- func(s *pState) {
130	145	if b.index < 0 {
131	146	return
132	147	}
133		if remove {
134		s.heapUpdated = heap.Remove(s.bHeap, b.index) != nil
135		}
136		s.shutdownPending = append(s.shutdownPending, b)
	148	heap.Remove(&s.bHeap, b.index)
	149	s.heapUpdated = true
137	150	}:
138	151	case <-p.done:
139	152	}
140	153	}
141	154
142		// UpdateBarPriority provides a way to change bar's order position.
143		// Zero is highest priority, i.e. bar will be on top.
	155	func (p Progress) setBarPriority(b Bar, priority int) {
	156	select {
	157	case p.operateState <- func(s *pState) {
	158	if b.index < 0 {
	159	return
	160	}
	161	b.priority = priority
	162	heap.Fix(&s.bHeap, b.index)
	163	}:
	164	case <-p.done:
	165	}
	166	}
	167
	168	// UpdateBarPriority same as *Bar.SetPriority(int).
144	169	func (p Progress) UpdateBarPriority(b Bar, priority int) {
145		select {
146		case p.operateState <- func(s *pState) { s.bHeap.update(b, priority) }:
147		case <-p.done:
148		}
	170	p.setBarPriority(b, priority)
149	171	}
150	172
151	173	// BarCount returns bars count

159	181	}
160	182	}
161	183
162		// Wait first waits for user provided *sync.WaitGroup, if any, then
163		// waits far all bars to complete and finally shutdowns master goroutine.
	184	// Wait waits far all bars to complete and finally shutdowns container.
164	185	// After this method has been called, there is no way to reuse *Progress
165	186	// instance.
166	187	func (p *Progress) Wait() {
167	188	if p.uwg != nil {
	189	// wait for user wg
168	190	p.uwg.Wait()
169	191	}
170	192
171		p.wg.Wait()
172
173		select {
174		case p.operateState <- func(s *pState) { s.zeroWait = true }:
175		<-p.done
176		case <-p.done:
177		}
	193	// wait for bars to quit, if any
	194	p.bwg.Wait()
	195
	196	p.once.Do(p.shutdown)
	197
	198	// wait for container to quit
	199	p.cwg.Wait()
	200	}
	201
	202	func (p *Progress) shutdown() {
	203	close(p.done)
	204	}
	205
	206	func (p Progress) serve(s pState, cw *cwriter.Writer) {
	207	defer p.cwg.Done()
	208
	209	p.refreshCh = s.newTicker(p.done)
	210
	211	for {
	212	select {
	213	case op := <-p.operateState:
	214	op(s)
	215	case <-p.refreshCh:
	216	if err := s.render(cw); err != nil {
	217	go p.dlogger.Println(err)
	218	}
	219	case <-s.shutdownNotifier:
	220	return
	221	}
	222	}
	223	}
	224
	225	func (s pState) render(cw cwriter.Writer) error {
	226	if s.heapUpdated {
	227	s.updateSyncMatrix()
	228	s.heapUpdated = false
	229	}
	230	syncWidth(s.pMatrix)
	231	syncWidth(s.aMatrix)
	232
	233	tw, err := cw.GetWidth()
	234	if err != nil {
	235	tw = s.width
	236	}
	237	for i := 0; i < s.bHeap.Len(); i++ {
	238	bar := s.bHeap[i]
	239	go bar.render(tw)
	240	}
	241
	242	return s.flush(cw)
	243	}
	244
	245	func (s pState) flush(cw cwriter.Writer) error {
	246	var lineCount int
	247	bm := make(map[*Bar]struct{}, s.bHeap.Len())
	248	for s.bHeap.Len() > 0 {
	249	b := heap.Pop(&s.bHeap).(*Bar)
	250	cw.ReadFrom(<-b.frameCh)
	251	if b.toShutdown {
	252	// shutdown at next flush
	253	// this ensures no bar ends up with less than 100% rendered
	254	defer func() {
	255	s.barShutdownQueue = append(s.barShutdownQueue, b)
	256	}()
	257	}
	258	lineCount += b.extendedLines + 1
	259	bm[b] = struct{}{}
	260	}
	261
	262	for _, b := range s.barShutdownQueue {
	263	if parkedBar := s.parkedBars[b]; parkedBar != nil {
	264	parkedBar.priority = b.priority
	265	heap.Push(&s.bHeap, parkedBar)
	266	delete(s.parkedBars, b)
	267	b.toDrop = true
	268	}
	269	if b.toDrop {
	270	delete(bm, b)
	271	s.heapUpdated = true
	272	} else if s.popCompleted {
	273	if b := b; !b.noPop {
	274	defer func() {
	275	s.barPopQueue = append(s.barPopQueue, b)
	276	}()
	277	}
	278	}
	279	b.cancel()
	280	}
	281	s.barShutdownQueue = s.barShutdownQueue[0:0]
	282
	283	for _, b := range s.barPopQueue {
	284	delete(bm, b)
	285	s.heapUpdated = true
	286	lineCount -= b.extendedLines + 1
	287	}
	288	s.barPopQueue = s.barPopQueue[0:0]
	289
	290	for b := range bm {
	291	heap.Push(&s.bHeap, b)
	292	}
	293
	294	return cw.Flush(lineCount)
	295	}
	296
	297	func (s *pState) newTicker(done <-chan struct{}) chan time.Time {
	298	ch := make(chan time.Time)
	299	if s.shutdownNotifier == nil {
	300	s.shutdownNotifier = make(chan struct{})
	301	}
	302	go func() {
	303	if s.renderDelay != nil {
	304	<-s.renderDelay
	305	}
	306	if s.refreshSrc == nil {
	307	ticker := time.NewTicker(s.rr)
	308	defer ticker.Stop()
	309	s.refreshSrc = ticker.C
	310	}
	311	for {
	312	select {
	313	case tick := <-s.refreshSrc:
	314	ch <- tick
	315	case <-done:
	316	close(s.shutdownNotifier)
	317	return
	318	}
	319	}
	320	}()
	321	return ch
178	322	}
179	323
180	324	func (s *pState) updateSyncMatrix() {
181	325	s.pMatrix = make(map[int][]chan int)
182	326	s.aMatrix = make(map[int][]chan int)
183	327	for i := 0; i < s.bHeap.Len(); i++ {
184		bar := (*s.bHeap)[i]
	328	bar := s.bHeap[i]
185	329	table := bar.wSyncTable()
186	330	pRow, aRow := table[0], table[1]
187	331

195	339	}
196	340	}
197	341
198		func (s *pState) render(tw int) {
199		if s.heapUpdated {
200		s.updateSyncMatrix()
201		s.heapUpdated = false
202		}
203		syncWidth(s.pMatrix)
204		syncWidth(s.aMatrix)
205
206		for i := 0; i < s.bHeap.Len(); i++ {
207		bar := (*s.bHeap)[i]
208		go bar.render(s.debugOut, tw)
209		}
210
211		if err := s.flush(s.bHeap.Len()); err != nil {
212		fmt.Fprintf(s.debugOut, "%s %s %v\n", "[mpb]", time.Now(), err)
213		}
214		}
215
216		func (s *pState) flush(lineCount int) error {
217		for s.bHeap.Len() > 0 {
218		bar := heap.Pop(s.bHeap).(*Bar)
219		frameReader := <-bar.frameReaderCh
220		defer func() {
221		if frameReader.toShutdown {
222		// shutdown at next flush, in other words decrement underlying WaitGroup
223		// only after the bar with completed state has been flushed. this
224		// ensures no bar ends up with less than 100% rendered.
225		s.shutdownPending = append(s.shutdownPending, bar)
226		if replacementBar, ok := s.waitBars[bar]; ok {
227		heap.Push(s.bHeap, replacementBar)
228		s.heapUpdated = true
229		delete(s.waitBars, bar)
230		}
231		if frameReader.removeOnComplete {
232		s.heapUpdated = true
233		return
234		}
235		}
236		heap.Push(s.bHeap, bar)
237		}()
238		s.cw.ReadFrom(frameReader)
239		lineCount += frameReader.extendedLines
240		}
241
242		for i := len(s.shutdownPending) - 1; i >= 0; i-- {
243		close(s.shutdownPending[i].shutdown)
244		s.shutdownPending = s.shutdownPending[:i]
245		}
246
247		return s.cw.Flush(lineCount)
	342	func (s pState) makeBarState(total int64, filler BarFiller, options ...BarOption) bState {
	343	bs := &bState{
	344	total: total,
	345	baseF: extractBaseFiller(filler),
	346	filler: filler,
	347	priority: s.idCount,
	348	id: s.idCount,
	349	width: s.width,
	350	debugOut: s.debugOut,
	351	extender: func(r io.Reader, _ int, _ *decor.Statistics) (io.Reader, int) {
	352	return r, 0
	353	},
	354	}
	355
	356	for _, opt := range options {
	357	if opt != nil {
	358	opt(bs)
	359	}
	360	}
	361
	362	if s.popCompleted && !bs.noPop {
	363	bs.priority = -1
	364	}
	365
	366	bs.bufP = bytes.NewBuffer(make([]byte, 0, bs.width))
	367	bs.bufB = bytes.NewBuffer(make([]byte, 0, bs.width))
	368	bs.bufA = bytes.NewBuffer(make([]byte, 0, bs.width))
	369
	370	return bs
248	371	}
249	372
250	373	func syncWidth(matrix map[int][]chan int) {

253	376	go func() {
254	377	var maxWidth int
255	378	for _, ch := range column {
256		w := <-ch
257		if w > maxWidth {
	379	if w := <-ch; w > maxWidth {
258	380	maxWidth = w
259	381	}
260	382	}

264	386	}()
265	387	}
266	388	}
	389
	390	func extractBaseFiller(f BarFiller) BarFiller {
	391	type wrapper interface {
	392	Base() BarFiller
	393	}
	394	if f, ok := f.(wrapper); ok {
	395	return extractBaseFiller(f.Base())
	396	}
	397	return f
	398	}

+0

-70

~~progress_posix.go~~ less more

0		// +build !windows
1
2		package mpb
3
4		import (
5		"os"
6		"os/signal"
7		"syscall"
8		"time"
9		)
10
11		func (p Progress) serve(s pState) {
12
13		var ticker *time.Ticker
14		var refreshCh <-chan time.Time
15		var winch chan os.Signal
16		var resumeTimer *time.Timer
17		var resumeEvent <-chan time.Time
18		winchIdleDur := s.rr * 2
19
20		if s.manualRefreshCh == nil {
21		ticker = time.NewTicker(s.rr)
22		refreshCh = ticker.C
23		winch = make(chan os.Signal, 2)
24		signal.Notify(winch, syscall.SIGWINCH)
25		} else {
26		refreshCh = s.manualRefreshCh
27		}
28
29		for {
30		select {
31		case op := <-p.operateState:
32		op(s)
33		case <-refreshCh:
34		if s.zeroWait {
35		if s.manualRefreshCh == nil {
36		signal.Stop(winch)
37		ticker.Stop()
38		}
39		if s.shutdownNotifier != nil {
40		close(s.shutdownNotifier)
41		}
42		close(p.done)
43		return
44		}
45		tw, err := s.cw.GetWidth()
46		if err != nil {
47		tw = s.width
48		}
49		s.render(tw)
50		case <-winch:
51		tw, err := s.cw.GetWidth()
52		if err != nil {
53		tw = s.width
54		}
55		s.render(tw - tw/8)
56		if resumeTimer != nil && resumeTimer.Reset(winchIdleDur) {
57		break
58		}
59		ticker.Stop()
60		resumeTimer = time.NewTimer(winchIdleDur)
61		resumeEvent = resumeTimer.C
62		case <-resumeEvent:
63		ticker = time.NewTicker(s.rr)
64		refreshCh = ticker.C
65		resumeEvent = nil
66		resumeTimer = nil
67		}
68		}
69		}

+12

-23

progress_test.go less more

2	2	import (
3	3	"bytes"
4	4	"context"
5		"fmt"
6	5	"io/ioutil"
7	6	"math/rand"
8	7	"sync"
9	8	"testing"
10	9	"time"
11	10
12		"github.com/vbauerster/mpb"
13		. "github.com/vbauerster/mpb"
14		"github.com/vbauerster/mpb/cwriter"
15		)
16
17		var (
18		cursorUp = fmt.Sprintf("%c[%dA", cwriter.ESC, 1)
19		clearLine = fmt.Sprintf("%c[2K\r", cwriter.ESC)
20		clearCursorAndLine = cursorUp + clearLine
	11	"github.com/vbauerster/mpb/v5"
21	12	)
22	13
23	14	func init() {

25	16	}
26	17
27	18	func TestBarCount(t *testing.T) {
28		p := New(WithOutput(ioutil.Discard))
	19	p := mpb.New(mpb.WithOutput(ioutil.Discard))
29	20
30	21	var wg sync.WaitGroup
31	22	wg.Add(1)

46	37	t.Errorf("BarCount want: %q, got: %q\n", 1, count)
47	38	}
48	39
49		p.Abort(b, true)
	40	b.Abort(true)
50	41	p.Wait()
51	42	}
52	43
53	44	func TestBarAbort(t *testing.T) {
54		p := New(WithOutput(ioutil.Discard))
	45	p := mpb.New(mpb.WithOutput(ioutil.Discard))
55	46
56	47	var wg sync.WaitGroup
57	48	wg.Add(1)
58		bars := make([]*Bar, 3)
	49	bars := make([]*mpb.Bar, 3)
59	50	for i := 0; i < 3; i++ {
60	51	b := p.AddBar(100)
61	52	bars[i] = b
62	53	go func(n int) {
63		for i := 0; i < 100; i++ {
64		if n == 0 && i == 33 {
65		p.Abort(b, true)
	54	for i := 0; !b.Completed(); i++ {
	55	if n == 0 && i >= 33 {
	56	b.Abort(true)
66	57	wg.Done()
67	58	}
68	59	b.Increment()

76	67	if count != 2 {
77	68	t.Errorf("BarCount want: %q, got: %q\n", 2, count)
78	69	}
79		p.Abort(bars[1], true)
80		p.Abort(bars[2], true)
	70	bars[1].Abort(true)
	71	bars[2].Abort(true)
81	72	p.Wait()
82	73	}
83	74
84	75	func TestWithContext(t *testing.T) {
85	76	ctx, cancel := context.WithCancel(context.Background())
86	77	shutdown := make(chan struct{})
87		p := mpb.New(
	78	p := mpb.NewWithContext(ctx,
88	79	mpb.WithOutput(ioutil.Discard),
89		mpb.WithContext(ctx),
90	80	mpb.WithRefreshRate(50*time.Millisecond),
91	81	mpb.WithShutdownNotifier(shutdown),
92	82	)

118	108
119	109	func getLastLine(bb []byte) []byte {
120	110	split := bytes.Split(bb, []byte("\n"))
121		lastLine := split[len(split)-2]
122		return lastLine[len(clearCursorAndLine):]
	111	return split[len(split)-2]
123	112	}
124	113
125	114	func randomDuration(max time.Duration) time.Duration {

+0

-43

~~progress_windows.go~~ less more

0		// +build windows
1
2		package mpb
3
4		import (
5		"time"
6		)
7
8		func (p Progress) serve(s pState) {
9
10		var ticker *time.Ticker
11		var refreshCh <-chan time.Time
12
13		if s.manualRefreshCh == nil {
14		ticker = time.NewTicker(s.rr)
15		refreshCh = ticker.C
16		} else {
17		refreshCh = s.manualRefreshCh
18		}
19
20		for {
21		select {
22		case op := <-p.operateState:
23		op(s)
24		case <-refreshCh:
25		if s.zeroWait {
26		if s.manualRefreshCh == nil {
27		ticker.Stop()
28		}
29		if s.shutdownNotifier != nil {
30		close(s.shutdownNotifier)
31		}
32		close(p.done)
33		return
34		}
35		tw, err := s.cw.GetWidth()
36		if err != nil {
37		tw = s.width
38		}
39		s.render(tw)
40		}
41		}
42		}

+75

-7

proxyreader.go less more

1	1
2	2	import (
3	3	"io"
	4	"io/ioutil"
4	5	"time"
5	6	)
6	7
7		// proxyReader is io.Reader wrapper, for proxy read bytes
8	8	type proxyReader struct {
9	9	io.ReadCloser
10	10	bar *Bar
11		iT time.Time
12	11	}
13	12
14		func (pr *proxyReader) Read(p []byte) (n int, err error) {
15		n, err = pr.ReadCloser.Read(p)
	13	func (x *proxyReader) Read(p []byte) (int, error) {
	14	n, err := x.ReadCloser.Read(p)
	15	x.bar.IncrBy(n)
	16	if err == io.EOF {
	17	go x.bar.SetTotal(0, true)
	18	}
	19	return n, err
	20	}
	21
	22	type proxyWriterTo struct {
	23	io.ReadCloser // *proxyReader
	24	wt io.WriterTo
	25	bar *Bar
	26	}
	27
	28	func (x *proxyWriterTo) WriteTo(w io.Writer) (int64, error) {
	29	n, err := x.wt.WriteTo(w)
	30	x.bar.IncrInt64(n)
	31	if err == io.EOF {
	32	go x.bar.SetTotal(0, true)
	33	}
	34	return n, err
	35	}
	36
	37	type ewmaProxyReader struct {
	38	io.ReadCloser // *proxyReader
	39	bar *Bar
	40	iT time.Time
	41	}
	42
	43	func (x *ewmaProxyReader) Read(p []byte) (int, error) {
	44	n, err := x.ReadCloser.Read(p)
16	45	if n > 0 {
17		pr.bar.IncrBy(n, time.Since(pr.iT))
18		pr.iT = time.Now()
	46	x.bar.DecoratorEwmaUpdate(time.Since(x.iT))
	47	x.iT = time.Now()
19	48	}
20		return
	49	return n, err
21	50	}
	51
	52	type ewmaProxyWriterTo struct {
	53	io.ReadCloser // *ewmaProxyReader
	54	wt io.WriterTo // *proxyWriterTo
	55	bar *Bar
	56	iT time.Time
	57	}
	58
	59	func (x *ewmaProxyWriterTo) WriteTo(w io.Writer) (int64, error) {
	60	n, err := x.wt.WriteTo(w)
	61	if n > 0 {
	62	x.bar.DecoratorEwmaUpdate(time.Since(x.iT))
	63	x.iT = time.Now()
	64	}
	65	return n, err
	66	}
	67
	68	func newProxyReader(r io.Reader, bar *Bar) io.ReadCloser {
	69	rc := toReadCloser(r)
	70	rc = &proxyReader{rc, bar}
	71
	72	if wt, isWriterTo := r.(io.WriterTo); bar.hasEwmaDecorators {
	73	now := time.Now()
	74	rc = &ewmaProxyReader{rc, bar, now}
	75	if isWriterTo {
	76	rc = &ewmaProxyWriterTo{rc, wt, bar, now}
	77	}
	78	} else if isWriterTo {
	79	rc = &proxyWriterTo{rc, wt, bar}
	80	}
	81	return rc
	82	}
	83
	84	func toReadCloser(r io.Reader) io.ReadCloser {
	85	if rc, ok := r.(io.ReadCloser); ok {
	86	return rc
	87	}
	88	return ioutil.NopCloser(r)
	89	}

+46

-9

proxyreader_test.go less more

0	0	package mpb_test
1	1
2	2	import (
	3	"bytes"
3	4	"io"
4	5	"io/ioutil"
5	6	"strings"
6	7	"testing"
7	8
8		"github.com/vbauerster/mpb"
	9	"github.com/vbauerster/mpb/v5"
9	10	)
10	11
11	12	const content = `Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do

27	28	}
28	29
29	30	func TestProxyReader(t *testing.T) {
30
31	31	p := mpb.New(mpb.WithOutput(ioutil.Discard))
32	32
33		reader := &testReader{Reader: strings.NewReader(content)}
	33	tReader := &testReader{strings.NewReader(content), false}
34	34
35		total := len(content)
36		bar := p.AddBar(100, mpb.TrimSpace())
	35	bar := p.AddBar(int64(len(content)), mpb.TrimSpace())
37	36
38		written, err := io.Copy(ioutil.Discard, bar.ProxyReader(reader))
	37	var buf bytes.Buffer
	38	_, err := io.Copy(&buf, bar.ProxyReader(tReader))
39	39	if err != nil {
40	40	t.Errorf("Error copying from reader: %+v\n", err)
41	41	}
42	42
43	43	p.Wait()
44	44
45		if !reader.called {
	45	if !tReader.called {
46	46	t.Error("Read not called")
47	47	}
48	48
49		if written != int64(total) {
50		t.Errorf("Expected written: %d, got: %d\n", total, written)
	49	if got := buf.String(); got != content {
	50	t.Errorf("Expected content: %s, got: %s\n", content, got)
51	51	}
52	52	}
	53
	54	type testWriterTo struct {
	55	io.Reader
	56	wt io.WriterTo
	57	called bool
	58	}
	59
	60	func (wt *testWriterTo) WriteTo(w io.Writer) (n int64, err error) {
	61	wt.called = true
	62	return wt.wt.WriteTo(w)
	63	}
	64
	65	func TestProxyWriterTo(t *testing.T) {
	66	p := mpb.New(mpb.WithOutput(ioutil.Discard))
	67
	68	var reader io.Reader = strings.NewReader(content)
	69	wt := reader.(io.WriterTo)
	70	tReader := &testWriterTo{reader, wt, false}
	71
	72	bar := p.AddBar(int64(len(content)), mpb.TrimSpace())
	73
	74	var buf bytes.Buffer
	75	_, err := io.Copy(&buf, bar.ProxyReader(tReader))
	76	if err != nil {
	77	t.Errorf("Error copying from reader: %+v\n", err)
	78	}
	79
	80	p.Wait()
	81
	82	if !tReader.called {
	83	t.Error("WriteTo not called")
	84	}
	85
	86	if got := buf.String(); got != content {
	87	t.Errorf("Expected content: %s, got: %s\n", content, got)
	88	}
	89	}

+15

-2

spinner_filler.go less more

4	4	"strings"
5	5	"unicode/utf8"
6	6
7		"github.com/vbauerster/mpb/decor"
	7	"github.com/vbauerster/mpb/v5/decor"
8	8	)
9	9
10	10	// SpinnerAlignment enum.

17	17	SpinnerOnRight
18	18	)
19	19
20		var defaultSpinnerStyle = []string{"⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"}
	20	// DefaultSpinnerStyle is a slice of strings, which makes a spinner.
	21	var DefaultSpinnerStyle = []string{"⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"}
21	22
22	23	type spinnerFiller struct {
23	24	frames []string
24	25	count uint
25	26	alignment SpinnerAlignment
	27	}
	28
	29	// NewSpinnerFiller constucts mpb.BarFiller, to be used with Progress.Add(...) Bar method.
	30	func NewSpinnerFiller(style []string, alignment SpinnerAlignment) BarFiller {
	31	if len(style) == 0 {
	32	style = DefaultSpinnerStyle
	33	}
	34	filler := &spinnerFiller{
	35	frames: style,
	36	alignment: alignment,
	37	}
	38	return filler
26	39	}
27	40
28	41	func (s spinnerFiller) Fill(w io.Writer, width int, stat decor.Statistics) {