Indicatif

https://docs.rs/indicatif/latest/
Admin
Indicatif is a Rust library for building command-line interfaces that report progress to users,...
Tokens:247,710
Snippets:2,137
Trust Score:9.7
Update:1 week ago
Show doc for...
Tokens:
Raw
### DecimalBytes formatting examples

Source: https://docs.rs/indicatif/latest/src/indicatif/format.rs.html?search=

Rust doctest examples showing how DecimalBytes formats byte counts with SI prefixes (kB, MB, GB, TB, PB).

```rust
# use indicatif::DecimalBytes;
assert_eq!("15 B",    format!("{}", DecimalBytes(15)));
assert_eq!("1.50 kB", format!("{}", DecimalBytes(1_500)));
assert_eq!("1.50 MB", format!("{}", DecimalBytes(1_500_000)));
assert_eq!("1.50 GB", format!("{}", DecimalBytes(1_500_000_000)));
assert_eq!("1.50 TB", format!("{}", DecimalBytes(1_500_000_000_000)));
assert_eq!("1.50 PB", format!("{}", DecimalBytes(1_500_000_000_000_000)));
```

--------------------------------

### Example Configuration

Source: https://docs.rs/indicatif/latest/indicatif?search=std%3A%3Avec

Shows how to set a custom template using ProgressStyle::with_template and progress_chars.

```APIDOC
## Example Configuration

### Description
Demonstrates setting a custom progress bar template with a style and custom progress characters.

### Code
```rust
bar.set_style(ProgressStyle::with_template("[{elapsed_precise}] {bar:40.cyan/blue} {pos:>7}/{len:7} {msg}")
    .unwrap()
    .progress_chars("##-"));
```
```

--------------------------------

### Human Readable Formatting Example

Source: https://docs.rs/indicatif/latest/index.html

Shows usage of HumanBytes, HumanDuration, HumanCount, and HumanFloatCount to format values for human display. Requires importing these types from indicatif. The example asserts expected string outputs for each formatter.

```rust
use indicatif::{HumanBytes, HumanCount, HumanDuration, HumanFloatCount};

assert_eq!("3.00 MiB", HumanBytes(3*1024*1024).to_string());
assert_eq!("8 seconds", HumanDuration(Duration::from_secs(8)).to_string());
assert_eq!("33,857,009", HumanCount(33857009).to_string());
assert_eq!("33,857,009.1235", HumanFloatCount(33857009.123456).to_string());
```

--------------------------------

### HumanBytes formatting examples

Source: https://docs.rs/indicatif/latest/indicatif/struct.HumanBytes.html?search=

Shows how HumanBytes formats various byte values into human-readable strings with binary prefixes (KiB, MiB, GiB, TiB, PiB).

```rust
assert_eq!("15 B",     format!("{}", HumanBytes(15)));
assert_eq!("1.46 KiB", format!("{}", HumanBytes(1_500)));
assert_eq!("1.43 MiB", format!("{}", HumanBytes(1_500_000)));
assert_eq!("1.40 GiB", format!("{}", HumanBytes(1_500_000_000)));
assert_eq!("1.36 TiB", format!("{}", HumanBytes(1_500_000_000_000)));
assert_eq!("1.33 PiB", format!("{}", HumanBytes(1_500_000_000_000_000)));
```

--------------------------------

### BinaryBytes formatting examples

Source: https://docs.rs/indicatif/latest/indicatif/struct.BinaryBytes.html

Shows how to format various byte counts using the Display implementation, producing strings with binary prefixes like KiB, MiB, GiB, TiB, and PiB.

```rust
assert_eq!("15 B",     format!("{}", BinaryBytes(15)));
assert_eq!("1.46 KiB", format!("{}", BinaryBytes(1_500)));
assert_eq!("1.43 MiB", format!("{}", BinaryBytes(1_500_000)));
assert_eq!("1.40 GiB", format!("{}", BinaryBytes(1_500_000_000)));
assert_eq!("1.36 TiB", format!("{}", BinaryBytes(1_500_000_000_000)));
assert_eq!("1.33 PiB", format!("{}", BinaryBytes(1_500_000_000_000_000)));
```

--------------------------------

### DecimalBytes Display formatting examples

Source: https://docs.rs/indicatif/latest/indicatif/struct.DecimalBytes.html

Shows the expected output of formatting DecimalBytes with the Display trait for various byte values, using SI prefixes with two decimal places.

```rust
assert_eq!("15 B",    format!("{}", DecimalBytes(15)));
assert_eq!("1.50 kB", format!("{}", DecimalBytes(1_500)));
assert_eq!("1.50 MB", format!("{}", DecimalBytes(1_500_000)));
assert_eq!("1.50 GB", format!("{}", DecimalBytes(1_500_000_000)));
assert_eq!("1.50 TB", format!("{}", DecimalBytes(1_500_000_000_000)));
assert_eq!("1.50 PB", format!("{}", DecimalBytes(1_500_000_000_000_000)));
```

--------------------------------

### Configure ProgressStyle with template

Source: https://docs.rs/indicatif/latest/index.html

Sets a progress bar style using `ProgressStyle::with_template` with the example template and custom progress characters `##-`. The `unwrap` indicates the template must be valid.

```rust
bar.set_style(ProgressStyle::with_template("[{elapsed_precise}] {bar:40.cyan/blue} {pos:>7}/{len:7} {msg}")
    .unwrap()
    .progress_chars("##-"));
```

--------------------------------

### Top alignment example

Source: https://docs.rs/indicatif/latest/indicatif/enum.MultiProgressAlignment.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Shows how bars are aligned when a middle bar is removed with Top alignment (default). The remaining bars shift up to fill the gap.

```text
[0/100] progress bar 1        [0/100] progress bar 1
[0/100] progress bar 2   =>   [0/100] progress bar 3
[0/100] progress bar 3
```

--------------------------------

### Bottom alignment example

Source: https://docs.rs/indicatif/latest/indicatif/enum.MultiProgressAlignment.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Shows how bars are aligned when a middle bar is removed with Bottom alignment. The remaining bars stay at the bottom, leaving a gap at the top.

```text
[0/100] progress bar 1
[0/100] progress bar 2   =>   [0/100] progress bar 1
[0/100] progress bar 3        [0/100] progress bar 3
```

--------------------------------

### fn step_by(self, step: usize) -> StepBy<Self>

Source: https://docs.rs/indicatif/latest/indicatif/struct.ProgressBarIter.html

Creates an iterator starting at the same point, but stepping by the given amount at each iteration.

```APIDOC
## fn step_by(self, step: usize) -> StepBy<Self>

### Description
Creates an iterator starting at the same point, but stepping by the given amount at each iteration.

### Method
fn step_by

### Parameters
- **step** (usize) - Required - The step size.

### Return Value
- **StepBy<Self>** - An iterator that steps by the given amount.

```

--------------------------------

### Wrap tokio AsyncWrite with ProgressBar

Source: https://docs.rs/indicatif/latest/indicatif/struct.ProgressBar.html

Wraps a tokio::io::AsyncWrite with the progress bar. Requires the 'tokio' crate feature. The example opens source and target files, creates a progress bar with the source length, and copies data using io::copy.

```rust
let mut source = File::open("work.txt").await?;
let mut target = File::open("done.txt").await?;
let pb = ProgressBar::new(source.metadata().await?.len());
io::copy(&mut source, &mut pb.wrap_async_write(target)).await?;
```

--------------------------------

### Example progress bar template

Source: https://docs.rs/indicatif/latest/index.html

A template that renders elapsed time, a 40-character progress bar with cyan primary and blue alternative styles, position and length fields, and a message. The alternative style is used only for progress bars.

```text
[{elapsed_precise}] {bar:40.cyan/blue} {pos:>7}/{len:7} {msg}
```

--------------------------------

### ProgressBar style and builder methods

Source: https://docs.rs/indicatif/latest/src/indicatif/progress_bar.rs.html?search=std%3A%3Avec

Provides methods to get the current style and builder-like methods that set style, tab width, prefix, message, and position. The prefix and message require corresponding placeholders in the style template to be visible.

```rust
pub fn style(&self) -> ProgressStyle {
    self.state().style.clone()
}
```

```rust
pub fn with_style(self, style: ProgressStyle) -> Self {
    self.set_style(style);
    self
}
```

```rust
pub fn with_tab_width(self, tab_width: usize) -> Self {
    self.state().set_tab_width(tab_width);
    self
}
```

```rust
pub fn with_prefix(self, prefix: impl Into<Cow<'static, str>>) -> Self {
    let mut state = self.state();
    state.state.prefix = TabExpandedString::new(prefix.into(), state.tab_width);
    drop(state);
    self
}
```

```rust
pub fn with_message(self, message: impl Into<Cow<'static, str>>) -> Self {
    let mut state = self.state();
    state.state.message = TabExpandedString::new(message.into(), state.tab_width);
    drop(state);
    self
}
```

```rust
pub fn with_position(self, pos: u64) -> Self {
    self.state().state.set_pos(pos);
    self
}
```

--------------------------------

### Wrap tokio AsyncRead with ProgressBar

Source: https://docs.rs/indicatif/latest/indicatif/struct.ProgressBar.html

Wraps a tokio::io::AsyncRead with the progress bar. Requires the 'tokio' crate feature. The example opens source and target files, creates a progress bar with the source length, and copies data using io::copy.

```rust
let mut source = File::open("work.txt").await?;
let mut target = File::open("done.txt").await?;
let pb = ProgressBar::new(source.metadata().await?.len());
io::copy(&mut pb.wrap_async_read(source), &mut target).await?;
```

--------------------------------

### wrap_async_read: Wrap a tokio AsyncRead with progress bar

Source: https://docs.rs/indicatif/latest/src/indicatif/progress_bar.rs.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Wraps a tokio AsyncRead with the progress bar. The example opens a source file, opens a target file, and copies data using tokio::io::copy, tracking progress on the source reader.

```rust
/// ```rust,no_run
/// # use tokio::fs::File;
/// # use tokio::io;
/// # use indicatif::ProgressBar;
/// # async fn test() -> io::Result<()> {
/// let mut source = File::open("work.txt").await?;
/// let mut target = File::open("done.txt").await?;
/// let pb = ProgressBar::new(source.metadata().await?.len());
/// io::copy(&mut pb.wrap_async_read(source), &mut target).await?;
/// # Ok(())
/// # }
/// ```
```

--------------------------------

### Helper: Create a BarState started at a given time

Source: https://docs.rs/indicatif/latest/src/indicatif/state.rs.html?search=u32+-%3E+bool

Constructs a BarState with a hidden draw target, default style, and an Estimator initialized at the provided start time. Used by the duration tests.

```Rust
fn state_started_at(started: Instant) -> BarState {
        BarState {
            draw_target: ProgressDrawTarget::hidden(),
            on_finish: ProgressFinish::default(),
            style: ProgressStyle::default_bar(),
            state: {
                ProgressState {
                    pos: Arc::new(AtomicPosition::new()),
                    len: None,
                    tick: 0,
                    status: Status::InProgress,
                    started,
                    est: Estimator::new(started),
                    message: TabExpandedString::NoTabs("".into()),
                    prefix: TabExpandedString::NoTabs("".into()),
                }
            },
            tab_width: DEFAULT_TAB_WIDTH,
        }
    }
```

--------------------------------

### Read::take

Source: https://docs.rs/indicatif/latest/indicatif/struct.ProgressBarIter.html?search=

Creates an adapter which will read at most limit bytes from it.

```APIDOC
## take(self, limit: u64) -> Take<Self>

### Description
Creates an adapter which will read at most `limit` bytes from it.

### Method
take

### Signature
```rust
fn take(self, limit: u64) -> Take<Self>
where
    Self: Sized,
```

### Parameters
- **limit** (u64) - Required - The maximum number of bytes to read.

### Return Value
- **Take<Self>** - An adapter that limits the number of bytes read.
```

--------------------------------

### Helper function to create BarState for tests

Source: https://docs.rs/indicatif/latest/src/indicatif/state.rs.html?search=

Constructs a BarState with a hidden draw target, default finish style, default bar style, and a ProgressState initialized with the given start time. Used by tests to create states with a specific start time.

```rust
fn state_started_at(started: Instant) -> BarState {
    BarState {
        draw_target: ProgressDrawTarget::hidden(),
        on_finish: ProgressFinish::default(),
        style: ProgressStyle::default_bar(),
        state: {
            ProgressState {
                pos: Arc::new(AtomicPosition::new()),
                len: None,
                tick: 0,
                status: Status::InProgress,
                started,
                est: Estimator::new(started),
                message: TabExpandedString::NoTabs("".into()),
                prefix: TabExpandedString::NoTabs("".into()),
            }
        },
        tab_width: DEFAULT_TAB_WIDTH,
    }
}
```

--------------------------------

### Premature drops example: job bars dropped too soon

Source: https://docs.rs/indicatif/latest/indicatif/struct.MultiProgress.html

Full example showing a MultiProgress with a total bar and per-job bars. The job bars are dropped at the end of each loop iteration, causing the 'DONE!' message to be lost. Uses MultiProgress::suspend to print extra messages.

```rust
use indicatif::{MultiProgress, ProgressBar, ProgressFinish, ProgressStyle};
use std::borrow::Cow;

fn main() {
    let m = MultiProgress::new();
    let sty = ProgressStyle::with_template(
        "{prefix:<10} [{elapsed}] {bar:20.red/blue} {pos:>7}/{len:7} {msg}",
    )
    .unwrap()
    .progress_chars("##-");

    let total = m.add(ProgressBar::new(10));
    total.set_style(sty.clone());
    total.set_prefix("total");
    for i in 0..5 {
        let name = format!("Job #{i}");
        let pb = m.insert_before(
            &total,
            ProgressBar::new(3).with_finish(ProgressFinish::WithMessage(Cow::Borrowed("DONE!"))),
        );

        pb.set_style(sty.clone());
        pb.set_prefix(name);
        for _ in 0..3 {
            // Temporarily clear the screen so we can print a message to the terminal
            m.suspend(|| {
                eprintln!("from job #{i}...");
            });

            pb.inc(1);
        }
        pb.finish_using_style();
        total.inc(1);
    }

    total.finish();
}
```

--------------------------------

### ProgressBar::style

Source: https://docs.rs/indicatif/latest/indicatif/struct.ProgressBar.html

Get a clone of the current progress bar style.

```APIDOC
## ProgressBar::style

### Description
Get a clone of the current progress bar style.

### Method
style

### Parameters
None

### Returns
- **ProgressStyle** - A clone of the current style.

```

--------------------------------

### elapsed

Source: https://docs.rs/indicatif/latest/indicatif/struct.ProgressBar.html

Returns the current elapsed time since the progress bar started.

```APIDOC
## elapsed

### Description
Returns the current elapsed time since the progress bar started.

### Method
elapsed

### Signature
`pub fn elapsed(&self) -> Duration`

### Returns
`Duration` - The current elapsed time.
```

--------------------------------

### Wrap io::Write with ProgressBar using wrap_write

Source: https://docs.rs/indicatif/latest/src/indicatif/progress_bar.rs.html?search=std%3A%3Avec

Shows how to wrap a synchronous io::Write (e.g., a File) with a ProgressBar so that io::copy reports progress. Requires std::fs::File and std::io. The example opens source and target files, creates a ProgressBar with the source length, and copies data through pb.wrap_write(target).

```rust
# use std::fs::File;
# use std::io;
# use indicatif::ProgressBar;
# fn test () -> io::Result<()> {
let mut source = File::open("work.txt")?;
let target = File::create("done.txt")?;
let pb = ProgressBar::new(source.metadata()?.len());
io::copy(&mut source, &mut pb.wrap_write(target));
# Ok(())
# }

```

--------------------------------

### AsyncSeekExt::stream_position

Source: https://docs.rs/indicatif/latest/indicatif/struct.ProgressBarIter.html?search=

Creates a future which will return the current seek position from the start of the stream.

```APIDOC
## AsyncSeekExt::stream_position

### Description
Creates a future which will return the current seek position from the start of the stream.

### Method
stream_position

### Signature
fn stream_position(&mut self) -> Seek<'_, Self> where Self: Unpin

### Parameters
- **self** (&mut Self) - The IO object to query.

### Returns
- **Seek<'_, Self>** - A future that resolves to the current position.
```

--------------------------------

### AsyncReadExt::take

Source: https://docs.rs/indicatif/latest/indicatif/struct.ProgressBarIter.html?search=

Creates an adaptor which reads at most `limit` bytes from it.

```APIDOC
## AsyncReadExt::take

### Description
Creates an adaptor which reads at most `limit` bytes from it.

### Method
take

### Signature
fn take(self, limit: u64) -> Take<Self> where Self: Sized

### Parameters
- **self** (Self) - The reader to adapt.
- **limit** (u64) - The maximum number of bytes to read.

### Returns
- **Take<Self>** - An adaptor that limits the number of bytes read.
```

--------------------------------

### with_elapsed

Source: https://docs.rs/indicatif/latest/src/indicatif/progress_bar.rs.html?search=std%3A%3Avec

Sets the elapsed time of the progress bar to the given duration, adjusting the start time accordingly.

```APIDOC
## with_elapsed

### Description
Sets the elapsed time of the progress bar to the given duration, adjusting the start time accordingly.

### Method
with_elapsed

### Signature
pub fn with_elapsed(self, elapsed: Duration) -> Self

### Parameters
- **elapsed** (Duration) - Required - The elapsed duration to set.

### Returns
Self - The progress bar with the updated elapsed time.
```

--------------------------------

### write_ansi_range

Source: https://docs.rs/indicatif/latest/indicatif/style/index.html

Function that writes the visible text between start and end, leaving ANSI escape sequences unchanged.

```APIDOC
## write_ansi_range

### Description
Function that writes the visible text between start and end, leaving ANSI escape sequences unchanged.

### Type
Function

### Usage
Used internally to handle ANSI escape sequences when rendering progress bars.

```

--------------------------------

### fn take(self, n: usize) -> Take<Self>

Source: https://docs.rs/indicatif/latest/indicatif/struct.ProgressBarIter.html?search=

Creates an iterator that yields the first `n` elements.

```APIDOC
## fn take(self, n: usize) -> Take<Self>

### Description
Creates an iterator that yields the first `n` elements.

### Method
fn take

### Signature
```rust
fn take(self, n: usize) -> Take<Self>
```

### Parameters
- **self** - The iterator to take from.
- **n** (usize) - The number of elements to take.

### Return Type
- **Take<Self>** - An iterator that yields the first `n` elements.
```

--------------------------------

### write_ansi_range

Source: https://docs.rs/indicatif/latest/indicatif/style/fn.write_ansi_range.html?search=u32+-%3E+bool

Writes the visible text between start and end indices. ANSI escape sequences are written unchanged.

```APIDOC
## write_ansi_range

### Description
Writes the visible text between start and end indices. ANSI escape sequences are written unchanged.

### Function Signature
```rust
pub fn write_ansi_range(
    formatter: &mut Formatter<'_>,
    text: &str,
    start: usize,
    end: usize,
) -> Result
```

### Parameters
- **formatter** (`&mut Formatter<'_>`) - The formatter to write to.
- **text** (`&str`) - The input text containing ANSI escape sequences.
- **start** (`usize`) - The start index of the visible text range.
- **end** (`usize`) - The end index of the visible text range.

### Return Value
- **Result** - The result of the write operation.

```

--------------------------------

### fn take(self, n: usize) -> Take<Self>

Source: https://docs.rs/indicatif/latest/indicatif/struct.ProgressBarIter.html

Creates an iterator that yields the first `n` elements.

```APIDOC
## fn take(self, n: usize) -> Take<Self>

### Description
Creates an iterator that yields the first `n` elements.

### Method
take

### Signature
```rust
fn take(self, n: usize) -> Take<Self>
```

### Parameters
- `n` (usize) - Required - The number of elements to take.

### Return Value
- `Take<Self>` - An iterator that yields the first `n` elements.
```

--------------------------------

### pub fn prefix(&self) -> String

Source: https://docs.rs/indicatif/latest/indicatif/struct.ProgressBar.html?search=std%3A%3Avec

Returns the current prefix.

```APIDOC
## pub fn prefix(&self) -> String

### Description
Returns the current prefix.

### Method
prefix

### Signature
pub fn prefix(&self) -> String

### Return Value
- **String** - The current prefix.
```

--------------------------------

### write_ansi_range

Source: https://docs.rs/indicatif/latest/indicatif/style/fn.write_ansi_range.html?search=std%3A%3Avec

Writes the visible text between start and end indices. ANSI escape sequences are written unchanged.

```APIDOC
## Function write_ansi_range

### Description
Writes the visible text between `start` and `end` indices. ANSI escape sequences are written unchanged.

### Signature
```rust
pub fn write_ansi_range(
    formatter: &mut Formatter<'_>,
    text: &str,
    start: usize,
    end: usize,
) -> Result
```

### Parameters
- **formatter** (`&mut Formatter<'_>`) - The formatter to write to.
- **text** (`&str`) - The input text containing ANSI escape sequences.
- **start** (`usize`) - The starting index of the visible text to write.
- **end** (`usize`) - The ending index of the visible text to write.

### Return Value
- `Result` - The result of the write operation.

```

--------------------------------

### write_ansi_range

Source: https://docs.rs/indicatif/latest/indicatif/style/fn.write_ansi_range.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Writes the visible text between start and end indices, leaving ANSI escape sequences unchanged.

```APIDOC
## write_ansi_range

### Description
Writes the visible text between start and end indices. ANSI escape sequences are written unchanged.

### Function Signature
```rust
pub fn write_ansi_range(
    formatter: &mut Formatter<'_>,
    text: &str,
    start: usize,
    end: usize,
) -> Result
```

### Parameters
- **formatter** (`&mut Formatter<'_>`) - The formatter to write to.
- **text** (`&str`) - The input text containing ANSI escape sequences.
- **start** (`usize`) - The start index of the visible text range.
- **end** (`usize`) - The end index of the visible text range.

### Return Value
- **Result** - The result of the write operation.
```

--------------------------------

### write_ansi_range

Source: https://docs.rs/indicatif/latest/indicatif/style/fn.write_ansi_range.html

Writes the visible text between the given start and end indices, preserving ANSI escape sequences.

```APIDOC
## Function write_ansi_range

### Description
Writes the visible text between the given start and end indices. ANSI escape sequences are written unchanged.

### Signature
```rust
pub fn write_ansi_range(
    formatter: &mut Formatter<'_>,
    text: &str,
    start: usize,
    end: usize,
) -> Result
```

### Parameters
- **formatter** (`&mut Formatter<'_>`) - The formatter to write to.
- **text** (`&str`) - The text to write.
- **start** (`usize`) - The start index of the visible text.
- **end** (`usize`) - The end index of the visible text.

### Return Value
- `Result` - The result of the write operation.
```

--------------------------------

### Template Format Syntax

Source: https://docs.rs/indicatif/latest/indicatif?search=std%3A%3Avec

Explains the general format for placeholders in progress bar templates, including alignment, width, truncation, and style options.

```APIDOC
## Template Format Syntax

### Description
Placeholders in progress bar templates follow the format `{key:options}`. The options part is optional and can include alignment, width, truncation, and style specifications.

### Format
```
<^>             for an optional alignment specification (left, center and right respectively)
WIDTH           an optional width as positive integer
!               an optional exclamation mark to enable truncation
.STYLE          an optional dot separated style string
/STYLE          an optional dot separated alternative style string
```

### Notes
- For style details, see `Style::from_dotted_str`.
- Indicatif uses the `console` crate for colorization and formatting.

### Example
```
[{elapsed_precise}] {bar:40.cyan/blue} {pos:>7}/{len:7} {msg}
```
This creates a progress bar 40 characters wide with cyan as primary color and blue as alternative color.
```

--------------------------------

### Wrap an iterator with progress bar

Source: https://docs.rs/indicatif/latest/indicatif/struct.ProgressBar.html

Wraps an iterator with the progress bar to automatically advance it. The example iterates over a vector.

```rust
let v = vec![1, 2, 3];
let pb = ProgressBar::new(3);
for item in pb.wrap_iter(v.iter()) {
    // ...
}
```

--------------------------------

### fn step_by(self, step: usize) -> StepBy<Self>

Source: https://docs.rs/indicatif/latest/indicatif/struct.ProgressBarIter.html?search=

Creates an iterator that steps by the given amount.

```APIDOC
## fn step_by(self, step: usize) -> StepBy<Self>

### Description
Creates an iterator that steps by the given amount.

### Method
fn step_by

### Signature
```rust
fn step_by(self, step: usize) -> StepBy<Self>
```

### Parameters
- **self** - The iterator to step.
- **step** (usize) - The step size.

### Return Type
- **StepBy<Self>** - An iterator that yields every `step`-th element.
```

--------------------------------

### HumanCount

Source: https://docs.rs/indicatif/latest/indicatif?search=

Formats counts for human readability using commas. Example: HumanCount(33857009).to_string() returns "33,857,009".

```APIDOC
## HumanCount

### Description
Formats counts for human readability using commas.

### Usage
```rust
use indicatif::HumanCount;
assert_eq!("33,857,009", HumanCount(33857009).to_string());
```
```

--------------------------------

### fn step_by(self, step: usize) -> StepBy<Self>

Source: https://docs.rs/indicatif/latest/indicatif/struct.ProgressBarIter.html

Creates an iterator that steps by the given amount.

```APIDOC
## fn step_by(self, step: usize) -> StepBy<Self>

### Description
Creates an iterator that steps by the given amount.

### Method
step_by

### Signature
```rust
fn step_by(self, step: usize) -> StepBy<Self>
```

### Parameters
- `step` (usize) - Required - The step amount.

### Return Value
- `StepBy<Self>` - An iterator that steps by the given amount.
```

--------------------------------

### step_by

Source: https://docs.rs/indicatif/latest/indicatif/struct.ProgressBarIter.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Creates an iterator that steps by the given amount.

```APIDOC
## step_by

### Description
Creates an iterator that steps by the given amount.

### Method
fn step_by(self, step: usize) -> StepBy<Self>

### Parameters
- **step** (usize) - Required - The step size.

### Returns
- **StepBy<Self>** - An iterator that steps by the given amount.
```

--------------------------------

### HumanFloatCount

Source: https://docs.rs/indicatif/latest/indicatif?search=

Formats counts for human readability using commas for floats. Example: HumanFloatCount(33857009.123456).to_string() returns "33,857,009.1235".

```APIDOC
## HumanFloatCount

### Description
Formats counts for human readability using commas for floats.

### Usage
```rust
use indicatif::HumanFloatCount;
assert_eq!("33,857,009.1235", HumanFloatCount(33857009.123456).to_string());
```
```

--------------------------------

### pub fn wrap_async_write<W: AsyncWrite + Unpin>(&self, write: W) -> ProgressBarIter<W>

Source: https://docs.rs/indicatif/latest/indicatif/struct.ProgressBar.html?search=std%3A%3Avec

Wraps a tokio AsyncWrite with the progress bar. Available on crate feature 'tokio' only.

```APIDOC
## pub fn wrap_async_write<W: AsyncWrite + Unpin>(&self, write: W) -> ProgressBarIter<W>

### Description
Wraps a `tokio::io::AsyncWrite` with the progress bar. Available on crate feature `tokio` only.

### Method
wrap_async_write

### Signature
pub fn wrap_async_write<W: AsyncWrite + Unpin>(&self, write: W) -> ProgressBarIter<W>

### Parameters
- **write** (W) - Required - The async writer to wrap.

### Return Value
- **ProgressBarIter<W>** - A progress bar iterator wrapping the async writer.

### Example
```rust
let mut source = File::open("work.txt").await?;
let mut target = File::open("done.txt").await?;
let pb = ProgressBar::new(source.metadata().await?.len());
io::copy(&mut source, &mut pb.wrap_async_write(target)).await?;
```
```

--------------------------------

### insert_from_back

Source: https://docs.rs/indicatif/latest/indicatif/struct.MultiProgress.html

Inserts a progress bar from the back at a specified index. If the index is out of bounds, the bar is added to the start. Inserting an existing bar has no effect.

```APIDOC
## insert_from_back

### Description
Inserts a progress bar from the back. The progress bar inserted at position `MultiProgressState::objects.len() - index` will have the draw target changed to a remote draw target that is intercepted by the multi progress object overriding custom ProgressDrawTarget settings. If `index >= MultiProgressState::objects.len()`, the progress bar is added to the start of the list. Inserting a progress bar that is already a member of the MultiProgress will have no effect.

### Method
insert_from_back

### Signature
pub fn insert_from_back(&self, index: usize, pb: ProgressBar) -> ProgressBar

### Parameters
- **index** (usize) - Required - The position from the back at which to insert the progress bar.
- **pb** (ProgressBar) - Required - The progress bar to insert.

### Returns
- **ProgressBar** - The inserted progress bar.

```

--------------------------------

### Better code: create and add ProgressBar in a single call

Source: https://docs.rs/indicatif/latest/indicatif/struct.MultiProgress.html

Recommended approach: create the ProgressBar and add it to the MultiProgress in a single call, then style or exercise it as needed.

```rust
// Better code
let m = MultiProgress::new();
let pb = m.add(ProgressBar::new(100));
// Then style/exercise it as you please:
// e.g. pb.set_style()
```

--------------------------------

### BinaryBytes::new

Source: https://docs.rs/indicatif/latest/indicatif/struct.BinaryBytes.html?search=std%3A%3Avec

Constructs a BinaryBytes instance from a u64 byte count. This is the primary way to create a BinaryBytes value for formatting.

```APIDOC
## BinaryBytes::new

### Description
Creates a new `BinaryBytes` instance from a raw byte count.

### Signature
```rust
pub fn new(bytes: u64) -> BinaryBytes
```

### Parameters
- **bytes** (u64) - The number of bytes to format.

### Returns
- **BinaryBytes** - A new instance wrapping the given byte count.

### Example
```rust
let size = BinaryBytes::new(1_500);
assert_eq!("1.46 KiB", format!("{}", size));
```
```

--------------------------------

### write_ansi_range

Source: https://docs.rs/indicatif/latest/indicatif/style/index.html?search=

Writes the visible text between start and end, leaving ANSI escape sequences unchanged. This function is used internally for rendering styled progress bars.

```APIDOC
## write_ansi_range

### Description
Writes the visible text between start and end. The ANSI escape sequences are written unchanged.

### Function Signature
`write_ansi_range(start: usize, end: usize)`

### Parameters
- **start** (usize) - Required - The starting index of the visible text range.
- **end** (usize) - Required - The ending index of the visible text range.

### Return Value
No return value (unit type).
```
Tokens:
Raw