Are you happy with your logging solution? Would you help us out by taking a 30-second survey? Click here


A fast, extensible progress bar for Python and CLI

Subscribe to updates I use tqdm

Statistics on tqdm

Number of watchers on Github 5272
Number of open issues 128
Average time to close an issue 12 days
Main language Python
Average time to merge a PR 6 days
Open pull requests 75+
Closed pull requests 34+
Last commit almost 2 years ago
Repo Created over 4 years ago
Repo Last Updated almost 2 years ago
Size 3.16 MB
Homepage https://pypi.pyth...
Organization / Authortqdm
Latest Releasev4.19.6
Page Updated
Do you use tqdm? Leave a review!
View open issues (128)
View tqdm activity
View on github
Fresh, new opensource launches 🚀🚀🚀
Trendy new open source projects in your inbox! View examples

Subscribe to our mailing list

Evaluating tqdm for your project? Score Explanation
Commits Score (?)
Issues & PR Score (?)



|PyPI-Status| |PyPI-Versions| |Conda-Forge-Status|

|Build-Status| |Coverage-Status| |Branch-Coverage-Status| |Codacy-Grade|

|DOI-URI| |LICENCE| |OpenHub-Status|

tqdm means progress in Arabic (taqadum, ) and an abbreviation for I love you so much in Spanish (te quiero demasiado).

Instantly make your loops show a smart progress meter - just wrap any iterable with tqdm(iterable), and you're done!

.. code:: python

from tqdm import tqdm
for i in tqdm(range(10000)):

76%| | 7568/10000 [00:33<00:10, 229.00it/s]

trange(N) can be also used as a convenient shortcut for tqdm(xrange(N)).

|Screenshot| REPL: ptpython <>__

It can also be executed as a module with pipes:

.. code:: sh

$ seq 9999999 | tqdm --unit_scale | wc -l
10.0Mit [00:02, 3.58Mit/s]
$ 7z a -bd -r backup.7z docs/ | grep Compressing | \
    tqdm --total $(find docs/ -type f | wc -l) --unit files >> backup.log
100%|| 8014/8014 [01:37<00:00, 82.29files/s]

Overhead is low -- about 60ns per iteration (80ns with tqdm_gui), and is unit tested against performance regression. By comparison, the well-established ProgressBar <>__ has an 800ns/iter overhead.

In addition to its low overhead, tqdm uses smart algorithms to predict the remaining time and to skip unnecessary iteration displays, which allows for a negligible overhead in most cases.

tqdm works on any platform (Linux, Windows, Mac, FreeBSD, NetBSD, Solaris/SunOS), in any console or in a GUI, and is also friendly with IPython/Jupyter notebooks.

tqdm does not require any dependencies (not even curses!), just Python and an environment supporting carriage return \r and line feed \n control characters.

.. contents:: Table of contents :backlinks: top :local:


Latest PyPI stable release


.. code:: sh

    pip install tqdm

Latest development release on GitHub

|GitHub-Status| |GitHub-Stars| |GitHub-Commits| |GitHub-Forks|

Pull and install in the current directory:

.. code:: sh

pip install -e git+

Latest Conda release


.. code:: sh

    conda install -c conda-forge tqdm


The list of all changes is available either on GitHub's Releases:
|GitHub-Status| or on crawlers such as
` <>`_.


``tqdm`` is very versatile and can be used in a number of ways.
The three main ones are given below.


Wrap tqdm() around any iterable:

.. code:: python

text = ""
for char in tqdm(["a", "b", "c", "d"]):
    text = text + char

trange(i) is a special optimised instance of tqdm(range(i)):

.. code:: python

for i in trange(100):

Instantiation outside of the loop allows for manual control over tqdm():

.. code:: python

pbar = tqdm(["a", "b", "c", "d"])
for char in pbar:
    pbar.set_description("Processing %s" % char)


Manual control on ``tqdm()`` updates by using a ``with`` statement:

.. code:: python

    with tqdm(total=100) as pbar:
        for i in range(10):

If the optional variable ``total`` (or an iterable with ``len()``) is
provided, predictive stats are displayed.

``with`` is also optional (you can just assign ``tqdm()`` to a variable,
but in this case don't forget to ``del`` or ``close()`` at the end:

.. code:: python

    pbar = tqdm(total=100)
    for i in range(10):


Perhaps the most wonderful use of tqdm is in a script or on the command line. Simply inserting tqdm (or python -m tqdm) between pipes will pass through all stdin to stdout while printing progress to stderr.

The example below demonstrated counting the number of lines in all Python files in the current directory, with timing information included.

.. code:: sh

$ time find . -name '*.py' -exec cat \{} \; | wc -l

real    0m3.458s
user    0m0.274s
sys     0m3.325s

$ time find . -name '*.py' -exec cat \{} \; | tqdm | wc -l
857366it [00:03, 246471.31it/s]

real    0m3.585s
user    0m0.862s
sys     0m3.358s

Note that the usual arguments for tqdm can also be specified.

.. code:: sh

$ find . -name '*.py' -exec cat \{} \; |
    tqdm --unit loc --unit_scale --total 857366 >> /dev/null
100%|| 857K/857K [00:04<00:00, 246Kloc/s]

Backing up a large directory?

.. code:: sh

$ 7z a -bd -r backup.7z docs/ | grep Compressing |
    tqdm --total $(find docs/ -type f | wc -l) --unit files >> backup.log
100%|| 8014/8014 [01:37<00:00, 82.29files/s]

FAQ and Known Issues


The most common issues relate to excessive output on multiple lines, instead of a neat one-line progress bar.

  • Consoles in general: require support for carriage return (CR, \r).
  • Nested progress bars:
    • Consoles in general: require support for moving cursors up to the previous line. For example, IDLE <>, ConEmu <> and PyCharm <>__ (also here <>__ and here <>__) lack full support.
    • Windows: additionally may require the Python module colorama to ensure nested bars stay within their respective lines.
  • Wrapping enumerated iterables: use enumerate(tqdm(...)) instead of tqdm(enumerate(...)). The same applies to numpy.ndenumerate. This is because enumerate functions tend to hide the length of iterables. tqdm does not.
  • Wrapping zipped iterables has similar issues due to internal optimisations. tqdm(zip(a, b)) should be replaced with zip(tqdm(a), b) or even zip(tqdm(a), tqdm(b)).

If you come across any other difficulties, browse and file |GitHub-Issues|.


|PyPI-Versions| |README-Hits| (Since 19 May 2016)

.. code:: python

class tqdm(object):
  Decorate an iterable object, returning an iterator which acts exactly
  like the original iterable, but prints a dynamically updating
  progressbar every time a value is requested.

  def __init__(self, iterable=None, desc=None, total=None, leave=True,
               file=None, ncols=None, mininterval=0.1,
               maxinterval=10.0, miniters=None, ascii=None, disable=False,
               unit='it', unit_scale=False, dynamic_ncols=False,
               smoothing=0.3, bar_format=None, initial=0, position=None,


* iterable  : iterable, optional  
    Iterable to decorate with a progressbar.
    Leave blank to manually manage the updates.
* desc  : str, optional  
    Prefix for the progressbar.
* total  : int, optional  
    The number of expected iterations. If (default: None),
    len(iterable) is used if possible. As a last resort, only basic
    progress statistics are displayed (no ETA, no progressbar).
    If ``gui`` is True and this parameter needs subsequent updating,
    specify an initial arbitrary large positive integer,
    e.g. int(9e9).
* leave  : bool, optional  
    If [default: True], keeps all traces of the progressbar
    upon termination of iteration.
* file  : ``io.TextIOWrapper`` or ``io.StringIO``, optional  
    Specifies where to output the progress messages
    (default: sys.stderr). Uses ``file.write(str)`` and ``file.flush()``
* ncols  : int, optional  
    The width of the entire output message. If specified,
    dynamically resizes the progressbar to stay within this bound.
    If unspecified, attempts to use environment width. The
    fallback is a meter width of 10 and no limit for the counter and
    statistics. If 0, will not print any meter (only stats).
* mininterval  : float, optional  
    Minimum progress display update interval, in seconds [default: 0.1].
* maxinterval  : float, optional  
    Maximum progress display update interval, in seconds [default: 10].
    Automatically adjusts ``miniters`` to correspond to ``mininterval``
    after long display update lag. Only works if ``dynamic_miniters``
    or monitor thread is enabled.
* miniters  : int, optional  
    Minimum progress display update interval, in iterations.
    If 0 and ``dynamic_miniters``, will automatically adjust to equal
    ``mininterval`` (more CPU efficient, good for tight loops).
    If > 0, will skip display of specified number of iterations.
    Tweak this and ``mininterval`` to get very efficient loops.
    If your progress is erratic with both fast and slow iterations
    (network, skipping items, etc) you should set miniters=1.
* ascii  : bool, optional  
    If unspecified or False, use unicode (smooth blocks) to fill
    the meter. The fallback is to use ASCII characters ``1-9 #``.
* disable  : bool, optional  
    Whether to disable the entire progressbar wrapper
    [default: False].
* unit  : str, optional  
    String that will be used to define the unit of each iteration
    [default: it].
* unit_scale  : bool or int or float, optional  
    If 1 or True, the number of iterations will be reduced/scaled
    automatically and a metric prefix following the
    International System of Units standard will be added
    (kilo, mega, etc.) [default: False]. If any other non-zero
    number, will scale `total` and `n`.
* dynamic_ncols  : bool, optional  
    If set, constantly alters ``ncols`` to the environment (allowing
    for window resizes) [default: False].
* smoothing  : float, optional  
    Exponential moving average smoothing factor for speed estimates
    (ignored in GUI mode). Ranges from 0 (average speed) to 1
    (current/instantaneous speed) [default: 0.3].
* bar_format  : str, optional  
    Specify a custom bar string formatting. May impact performance.
    [default: '{l_bar}{bar}{r_bar}'], where
    l_bar='{desc}: {percentage:3.0f}%|' and
    r_bar='| {n_fmt}/{total_fmt} [{elapsed}<{remaining}, '
    Possible vars: l_bar, bar, r_bar, n, n_fmt, total, total_fmt,
    percentage, rate, rate_fmt, rate_noinv, rate_noinv_fmt,
    rate_inv, rate_inv_fmt, elapsed, remaining, desc, postfix.
    Note that a trailing ": " is automatically removed after {desc}
    if the latter is empty.
* initial  : int, optional  
    The initial counter value. Useful when restarting a progress
    bar [default: 0].
* position  : int, optional  
    Specify the line offset to print this bar (starting from 0)
    Automatic if unspecified.
    Useful to manage multiple bars at once (eg, from threads).
* postfix  : dict, optional  
    Specify additional stats to display at the end of the bar.
    Note: postfix is a dict ({'key': value} pairs) for this method,
    not a string.
* unit_divisor  : float, optional  
    [default: 1000], ignored unless `unit_scale` is True.

Extra CLI Options
  • delim : chr, optional
    Delimiting character [default: '\n']. Use '\0' for null. N.B.: on Windows systems, Python converts '\n' to '\r\n'.
  • buf_size : int, optional
    String buffer size in bytes [default: 256] used when delim is specified.
  • bytes : bool, optional
    If true, will count bytes and ignore delim.


* out  : decorated iterator.

.. code:: python

      def update(self, n=1):
          Manually update the progress bar, useful for streams
          such as reading files.
          >>> t = tqdm(total=filesize) # Initialise
          >>> for current_buffer in stream:
          ...    ...
          ...    t.update(len(current_buffer))
          >>> t.close()
          The last line is highly recommended, but possibly not necessary if
          ``t.update()`` will be called in such a way that ``filesize`` will be
          exactly reached and printed.

          n  : int, optional
              Increment to add to the internal counter of iterations
              [default: 1].

      def close(self):
          Cleanup and (if leave=False) close the progressbar.

      def unpause(self):
          Restart tqdm timer from last print time.

      def clear(self, nomove=False):
          Clear current bar display

      def refresh(self):
          Force refresh the display of this bar

      def write(cls, s, file=sys.stdout, end="\n"):
          Print a message via tqdm (without overlap with bars)

      def set_description(self, desc=None, refresh=True):
          Set/modify description of the progress bar.

          desc  : str, optional
          refresh  : bool, optional
              Forces refresh [default: True].

      def set_postfix(self, ordered_dict=None, refresh=True, **kwargs):
          Set/modify postfix (additional stats)
          with automatic formatting based on datatype.

          refresh  : bool, optional
              Forces refresh [default: True].

    def trange(*args, **kwargs):
        A shortcut for tqdm(xrange(*args), **kwargs).
        On Python3+ range is used instead of xrange.

    class tqdm_gui(tqdm):
        Experimental GUI version of tqdm!

    def tgrange(*args, **kwargs):
        Experimental GUI version of trange!

    class tqdm_notebook(tqdm):
        Experimental IPython/Jupyter Notebook widget using tqdm!

    def tnrange(*args, **kwargs):
        Experimental IPython/Jupyter Notebook widget using tqdm!

Examples and Advanced Usage

- See the `examples <>`__
- import the module and run ``help()``, or
- consult the `wiki <>`__.
    - this has an
      `excellent article <>`__
      on how to make a **great** progressbar.

Description and additional stats

Custom information can be displayed and updated dynamically on tqdm bars with the desc and postfix arguments:

.. code:: python

from tqdm import trange
from random import random, randint
from time import sleep

t = trange(100)
for i in t:
    # Description will be displayed on the left
    t.set_description('GEN %i' % i)
    # Postfix will be displayed on the right, and will format automatically
    # based on argument's datatype
    t.set_postfix(loss=random(), gen=randint(1,999), str='h', lst=[1, 2])

Nested progress bars

``tqdm`` supports nested progress bars. Here's an example:

.. code:: python

    from tqdm import trange
    from time import sleep

    for i in trange(10, desc='1st loop'):
        for j in trange(5, desc='2nd loop', leave=False):
            for k in trange(100, desc='3nd loop'):

On Windows `colorama <>`__ will be used if
available to keep nested bars on their respective lines.

For manual control over positioning (e.g. for multi-threaded use),
you may specify ``position=n`` where ``n=0`` for the outermost bar,
``n=1`` for the next, and so on:

.. code:: python

    from time import sleep
    from tqdm import trange
    from multiprocessing import Pool, freeze_support, RLock

    L = list(range(9))

    def progresser(n):
        interval = 0.001 / (n + 2)
        total = 5000
        text = "#{}, est. {:<04.2}s".format(n, interval * total)
        for i in trange(total, desc=text, position=n):

    if __name__ == '__main__':
        freeze_support()  # for Windows support
        p = Pool(len(L),
                 # again, for Windows support
                 initializer=tqdm.set_lock, initargs=(RLock(),)), L)
        print("\n" * (len(L) - 2))

Hooks and callbacks

tqdm can easily support callbacks/hooks and manual updates. Here's an example with urllib:

urllib.urlretrieve documentation

| [...]
| If present, the hook function will be called once
| on establishment of the network connection and once after each block read
| thereafter. The hook will be passed three arguments; a count of blocks
| transferred so far, a block size in bytes, and the total size of the file.
| [...]

.. code:: python

import urllib, os
from tqdm import tqdm

class TqdmUpTo(tqdm):
    """Provides `update_to(n)` which uses `tqdm.update(delta_n)`."""
    def update_to(self, b=1, bsize=1, tsize=None):
        b  : int, optional
            Number of blocks transferred so far [default: 1].
        bsize  : int, optional
            Size of each block (in tqdm units) [default: 1].
        tsize  : int, optional
            Total size (in tqdm units). If [default: None] remains unchanged.
        if tsize is not None:
   = tsize
        self.update(b * bsize - self.n)  # will also set self.n = b * bsize

eg_link = ""
with TqdmUpTo(unit='B', unit_scale=True, miniters=1,
              desc=eg_link.split('/')[-1]) as t:  # all optional kwargs
    urllib.urlretrieve(eg_link, filename=os.devnull,
                       reporthook=t.update_to, data=None)

Inspired by twine#242 <>. Functional alternative in examples/ <>.

It is recommend to use miniters=1 whenever there is potentially large differences in iteration speed (e.g. downloading a file over a patchy connection).

Pandas Integration

Due to popular demand we've added support for ``pandas`` -- here's an example
for ``DataFrame.progress_apply`` and ``DataFrameGroupBy.progress_apply``:

.. code:: python

    import pandas as pd
    import numpy as np
    from tqdm import tqdm

    df = pd.DataFrame(np.random.randint(0, 100, (100000, 6)))

    # Register `pandas.progress_apply` and `pandas.Series.map_apply` with `tqdm`
    # (can use `tqdm_gui`, `tqdm_notebook`, optional kwargs, etc.)
    tqdm.pandas(desc="my bar!")

    # Now you can use `progress_apply` instead of `apply`
    # and `progress_map` instead of `map`
    df.progress_apply(lambda x: x**2)
    # can also groupby:
    # df.groupby(0).progress_apply(lambda x: x**2)

In case you're interested in how this works (and how to modify it for your
own callbacks), see the
`examples <>`__
folder or import the module and run ``help()``.

IPython/Jupyter Integration

IPython/Jupyter is supported via the tqdm_notebook submodule:

.. code:: python

from tqdm import tnrange, tqdm_notebook
from time import sleep

for i in tnrange(10, desc='1st loop'):
    for j in tqdm_notebook(xrange(100), desc='2nd loop'):

In addition to tqdm features, the submodule provides a native Jupyter widget (compatible with IPython v1-v4 and Jupyter), fully working nested bars and color hints (blue: normal, green: completed, red: error/interrupt, light blue: no ETA); as demonstrated below.

|Screenshot-Jupyter1| |Screenshot-Jupyter2| |Screenshot-Jupyter3|

Writing messages

Since ``tqdm`` uses a simple printing mechanism to display progress bars,
you should not write any message in the terminal using ``print()`` while
a progressbar is open.

To write messages in the terminal without any collision with ``tqdm`` bar
display, a ``.write()`` method is provided:

.. code:: python

    from tqdm import tqdm, trange
    from time import sleep

    bar = trange(10)
    for i in bar:
        # Print using tqdm class method .write()
        if not (i % 3):
            tqdm.write("Done task %i" % i)
        # Can also use bar.write()

By default, this will print to standard output ``sys.stdout``. but you can
specify any file-like object using the ``file`` argument. For example, this
can be used to redirect the messages writing to a log file or class.

Redirecting writing

If using a library that can print messages to the console, editing the library by replacing print() with tqdm.write() may not be desirable. In that case, redirecting sys.stdout to tqdm.write() is an option.

To redirect sys.stdout, create a file-like class that will write any input string to tqdm.write(), and supply the arguments file=sys.stdout, dynamic_ncols=True.

A reusable canonical example is given below:

.. code:: python

from time import sleep
import contextlib
import sys
from tqdm import tqdm

class DummyTqdmFile(object):
    """Dummy file-like that will write to tqdm"""
    file = None
    def __init__(self, file):
        self.file = file

    def write(self, x):
        # Avoid print() second call (useless \n)
        if len(x.rstrip()) > 0:
            tqdm.write(x, file=self.file)

    def flush(self):
        return getattr(self.file, "flush", lambda: None)()

def std_out_err_redirect_tqdm():
    orig_out_err = sys.stdout, sys.stderr
        sys.stdout, sys.stderr = map(DummyTqdmFile, orig_out_err)
        yield orig_out_err[0]
    # Relay exceptions
    except Exception as exc:
        raise exc
    # Always restore sys.stdout/err if necessary
        sys.stdout, sys.stderr = orig_out_err

def some_fun(i):
    print("Fee, fi, fo,".split()[i])

# Redirect stdout to tqdm.write() (don't forget the `as save_stdout`)
with std_out_err_redirect_tqdm() as orig_stdout:
    # tqdm needs the original stdout
    # and dynamic_ncols=True to autodetect console width
    for i in tqdm(range(3), file=orig_stdout, dynamic_ncols=True):

# After the `with`, printing is restored

Monitoring thread, intervals and miniters

``tqdm`` implements a few tricks to to increase efficiency and reduce overhead.

- Avoid unnecessary frequent bar refreshing: ``mininterval`` defines how long
  to wait between each refresh. ``tqdm`` always gets updated in the background,
  but it will diplay only every ``mininterval``.
- Reduce number of calls to check system clock/time.
- ``mininterval`` is more intuitive to configure than ``miniters``.
  A clever adjustment system ``dynamic_miniters`` will automatically adjust
  ``miniters`` to the amount of iterations that fit into time ``mininterval``.
  Essentially, ``tqdm`` will check if it's time to print without actually
  checking time. This behaviour can be still be bypassed by manually setting

However, consider a case with a combination of fast and slow iterations.
After a few fast iterations, ``dynamic_miniters`` will set ``miniters`` to a
large number. When iteration rate subsequently slows, ``miniters`` will
remain large and thus reduce display update frequency. To address this:

- ``maxinterval`` defines the maximum time between display refreshes.
  A concurrent monitoring thread checks for overdue updates and forces one
  where necessary.

The monitoring thread should not have a noticeable overhead, and guarantees
updates at least every 10 seconds by default.
This value can be directly changed by setting the ``monitor_interval`` of
any ``tqdm`` instance (i.e. ``t = tqdm.tqdm(...); t.monitor_interval = 2``).
The monitor thread may be disabled application-wide by setting
``tqdm.tqdm.monitor_interval = 0`` before instantiatiation of any ``tqdm`` bar.


|GitHub-Commits| |GitHub-Issues| |GitHub-PRs| |OpenHub-Status|

All source code is hosted on `GitHub <>`__.
Contributions are welcome.

See the
file for more information.


Open Source (OSI approved): |LICENCE|

Citation information: |DOI-URI|


The main developers, ranked by surviving lines of code, are:

- Casper da Costa-Luis (`casperdcl <>`__, ~2/3, |Gift-Casper|)
- Stephen Larroque (`lrq3000 <>`__, ~1/3)
- Noam Yorav-Raphael (`noamraph <>`__, ~1%, original author)
- Hadrien Mary (`hadim <>`__, ~1%)
- Mikhail Korobov (`kmike <>`__, ~1%)

There are also many |GitHub-Contributions| which we are grateful for.

|README-Hits| (Since 19 May 2016)

.. |Logo| image::
.. |Screenshot| image::
.. |Build-Status| image::
.. |Coverage-Status| image::
.. |Branch-Coverage-Status| image::
.. |Codacy-Grade| image::
.. |GitHub-Status| image::
.. |GitHub-Forks| image::
.. |GitHub-Stars| image::
.. |GitHub-Commits| image::
.. |GitHub-Issues| image::
.. |GitHub-PRs| image::
.. |GitHub-Contributions| image::
.. |Gift-Casper| image::
.. |PyPI-Status| image::
.. |PyPI-Downloads| image::
.. |PyPI-Versions| image::
.. |Conda-Forge-Status| image::
.. |OpenHub-Status| image::
.. |LICENCE| image::
.. |DOI-URI| image::
.. |Screenshot-Jupyter1| image::
.. |Screenshot-Jupyter2| image::
.. |Screenshot-Jupyter3| image::
.. |README-Hits| image::
tqdm open issues Ask a question     (View All Issues)
  • over 3 years progress bar indicates how many iterations are complete, or which iteration is being worked on?
  • over 3 years Tracking process of decompression with tqdm
  • over 3 years gui toolkit-specific progress bar?
  • over 3 years Could tqdm default to redirecting std{out,err} to tqdm.write?
  • over 3 years Additional control over the "rate"
  • over 3 years Modularize pyMakefile
  • over 3 years Progress bars jump around with multiprocessing when using the position kwarg
  • over 3 years Allow bar_format without total
  • over 3 years Dask support
  • over 3 years Specify `tqdm_notebook` bar width
  • over 3 years Use file=None not file=sys.stderr in the constructor
  • over 3 years Recommended recipe for using tqdm with compressed file?
  • over 3 years Fix coverage of pandas on Travis
  • over 3 years Support custom metrics in progress bar format
  • over 3 years Optional type hinting stub
  • over 3 years Unexpected spaces when ascii = False on MacOSX (Unicode East Asian Ambiguous characters are wide)
  • over 3 years Zip makes tqdm buggy
  • over 3 years Add .pxd cython file
  • over 3 years Proposal for smooth rolling releases
  • over 3 years recognition
  • over 3 years Add link to evolving tqdm.cpp project and wiki port list
  • over 3 years tqdm wrapper on requests library
  • over 3 years Old progressbars stay visible after reconnecting to notebook kernel
  • over 3 years Code Climate
  • over 3 years tqdm for other languages
  • over 3 years tqdm_auto to auto detect submodule to use depending on frontend
  • over 3 years Unit test for imported modules using tqdm
  • over 3 years Completed nested/parallel bars printing when leave=True
  • over 3 years Better way of showing indeterminate progress
  • over 3 years tqdm on SO open source advertising
tqdm open pull requests (View All Pulls)
  • License
  • Print message
  • Web-friendly tqdm
  • Add ipython/jupyter notebook support (rebased)
  • Async coroutine support
  • Add bytecode opcode test perf
  • Multi tqdm
  • Print message
  • Fix bar_format breaking console display
  • Add no rate inversion option in bar_format
  • Implementation of pessimistic progress rate
  • Add callbacks to tqdm.close()
  • Add callable support for bar_format argument
  • Fix tqdm_pandas(tqdm_notebook) by delaying instanciation in tqdm_pandas
  • IPython aliased imports fix
  • CLI pipes
  • Pythonic submodules architecture
  • Copyediting for README
  • Bars
  • Removed commented-out code
  • Custom bar symbols formatting
  • Monitoring thread to prevent tqdm taking too much time for display
  • Fix maxinterval to adjust miniters to mininterval + Update readme and docstring
  • Polynomial regression to predict time (tqdm_regress, tsrange)
  • Fix total computation for pandas apply
  • fixed refresh() and clear() if disabled
  • Allow bar_format without total or len(iterable)
  • disable automatically on non-TTY
  • Create progress bar wrapper to use with dask
  • Add stepsize + autodetection of initial, total and stepsize in trange()
  • Modularize tqdm.pandas -> tqdm_pandas
  • Add set_postfix
  • Add tqdm_bare and tbrange as minimal example for ports developers
  • Fix `file` default value (ease redirection)
  • Add ncols to specify tqdm_notebook bar width
  • Fix parallel bars printing race issue by using locks
  • CLI --bytes
  • minor optimistaion
  • uncompression (compressed archive extraction)
  • Update GIFs
  • Reorder Travis dependencies install to fix numpy install
  • Basic Tk GUI
  • Remove support for *args in pandas wrappers
  • force encoding, flake8
  • Better GitHub contributing integrations
  • RuntimeError: Set changed size during iteration
  • Fix flush() in clean() and refresh()
  • Fix security issue in __version__ extra calculation (fix #328)
  • Parallelism safety (thread, multiprocessing)
  • sys.setcheckinterval (deprecated) changed to sys.setswitchinterval
  • Fix edge case in issue #320
  • add numeric support for unit_scale
  • set_description() and set_postfix() call update(0)
  • Progress bar not disappering issue in jupyter notebook is solved
  • Add unit option to bar_format
  • fix navigation for windows command shell
  • cleanup doc re: postfix
  • unit_divisor, allowing e.g. 1024
  • Minor tidy 2
  • fix manually positioned nested bars clearing
  • some changes
  • Drop support for EOL Python 2.6 and 3.3
  • Fixed an error when running the code in Nested progress bar in the Examples and Advanced Usage section
  • Fix broken import of os.environ.get
  • Add missing import in example
  • Avoid manipulating uninitialized instances on monitoring thread.
  • Fix AttributeError: 'tqdm' object has no attribute 'disable'
  • Fix overlap of nested progressbar
  • Clarify pandas and tqdm_notebook notation
  • Fix `tqdm_notebook` fails with non-integer update (#456).
  • [Feature] microstep
  • Fix print_status when using widechars in desc
  • getattr
  • add appveyor.yml
  • Fix for aarch64 Android which lacks a functioning sem_open implementation
tqdm list of languages used
tqdm latest release notes
v4.19.6 tqdm v4.19.6 stable
  • CLI improvements
    • --bytes implies --unit B --unit_scale --unit_divisor 1024 (#503)
    • allow hyphens in CLI arguments (#511)
  • synchronisation: fix for sem_open on aarch64 (#513)
  • framework update
    • CI/tests, year 2018, py37, badges, documentation
v4.19.5 tqdm v4.19.5 stable
  • multiprocess/lock fixes (#457)
  • set_description in notebook (#345 -> #475)
  • minor tidy (#476)
  • documentation updates
v4.19.4 tqdm v4.19.4 stable
  • fix Lock:NotImplementedError on certain systems (#466 -> #468)
  • use recursive locks (#469 -> #468)
    • fix deadlocks
  • tidy (#448)
  • flush() on moveto() (#398 -> #399, #420, #467)
  • update tests and benchmarks
Other projects in Python