Package: tqdm
tqdmtqdmderives from the Arabic wordtaqaddum(تقدّم) which can mean “progress,”
and is 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 withtqdm(iterable), and you’re done!fromtqdmimporttqdmforiintqdm(range(10000)):...76%|████████████████████████| 7568/10000 [00:33<00:10, 229.00it/s]trange(N)can be also used as a convenient shortcut fortqdm(range(N)).It can also be executed as a module with pipes:$seq9999999|tqdm--bytes|wc-l75.2MB[00:00,217MB/s]9999999$tar-zcf-docs/|tqdm--bytes--total`du-sbdocs/|cut-f1`\>backup.tgz32%|██████████▍|8.89G/27.9G[00:42<01:31,223MB/s]Overhead is low – about 60ns per iteration (80ns withtqdm.gui), and is
unit tested against performance regression.
By comparison, the well-establishedProgressBarhas
an 800ns/iter overhead.In addition to its low overhead,tqdmuses smart algorithms to predict
the remaining time and to skip unnecessary iteration displays, which allows
for a negligible overhead in most cases.tqdmworks 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.tqdmdoes not require any dependencies (not evencurses!), just
Python and an environment supportingcarriage return \randline feed \ncontrol characters.Table of contentsInstallationLatest PyPI stable releaseLatest development release on GitHubLatest Conda releaseLatest Snapcraft releaseLatest Docker releaseOtherChangelogUsageIterable-basedManualModuleFAQ and Known IssuesDocumentationParametersExtra CLI OptionsReturnsConvenience FunctionsSubmodulescontribExamples and Advanced UsageDescription and additional statsNested progress barsHooks and callbacksasyncioPandas IntegrationKeras IntegrationDask IntegrationIPython/Jupyter IntegrationCustom IntegrationDynamic Monitor/MeterWriting messagesRedirecting writingRedirectingloggingMonitoring thread, intervals and minitersMerchContributionsPorts to Other LanguagesLICENCEInstallationLatest PyPI stable releasepipinstalltqdmLatest development release on GitHubPull and install pre-releasedevelbranch:pipinstall"git+https://github.com/tqdm/tqdm.git@devel#egg=tqdm"Latest Conda releasecondainstall-cconda-forgetqdmLatest Snapcraft releaseThere are 3 channels to choose from:snapinstalltqdm# implies --stable, i.e. latest tagged releasesnapinstalltqdm--candidate# master branchsnapinstalltqdm--edge# devel branchNote thatsnapbinaries are purely for CLI use (notimport-able), and
automatically set upbashtab-completion.Latest Docker releasedockerpulltqdm/tqdmdockerrun-i--rmtqdm/tqdm--helpOtherThere are other (unofficial) places wheretqdmmay be downloaded, particularly for CLI use:ChangelogThe list of all changes is available either on GitHub’s Releases:, on thewiki, or on thewebsite.Usagetqdmis very versatile and can be used in a number of ways.
The three main ones are given below.Iterable-basedWraptqdm()around any iterable:fromtqdmimporttqdmfromtimeimportsleeptext=""forcharintqdm(["a","b","c","d"]):sleep(0.25)text=text+chartrange(i)is a special optimised instance oftqdm(range(i)):fromtqdmimporttrangeforiintrange(100):sleep(0.01)Instantiation outside of the loop allows for manual control overtqdm():pbar=tqdm(["a","b","c","d"])forcharinpbar:sleep(0.25)pbar.set_description("Processing%s"%char)ManualManual control oftqdm()updates using awithstatement:withtqdm(total=100)aspbar:foriinrange(10):sleep(0.1)pbar.update(10)If the optional variabletotal(or an iterable withlen()) is
provided, predictive stats are displayed.withis also optional (you can just assigntqdm()to a variable,
but in this case don’t forget todelorclose()at the end:pbar=tqdm(total=100)foriinrange(10):sleep(0.1)pbar.update(10)pbar.close()ModulePerhaps the most wonderful use oftqdmis in a script or on the command
line. Simply insertingtqdm(orpython-mtqdm) between pipes will pass
through allstdintostdoutwhile printing progress tostderr.The example below demonstrate counting the number of lines in all Python files
in the current directory, with timing information included.$timefind.-name'*.py'-typef-execcat\{}\;|wc-l857365real0m3.458suser0m0.274ssys0m3.325s$timefind.-name'*.py'-typef-execcat\{}\;|tqdm|wc-l857366it[00:03,246471.31it/s]857365real0m3.585suser0m0.862ssys0m3.358sNote that the usual arguments fortqdmcan also be specified.$find.-name'*.py'-typef-execcat\{}\;|tqdm--unitloc--unit_scale--total857366>>/dev/null100%|█████████████████████████████████|857K/857K[00:04<00:00,246Kloc/s]Backing up a large directory?$tar-zcf-docs/|tqdm--bytes--total`du-sbdocs/|cut-f1`\>backup.tgz44%|██████████████▊|153M/352M[00:14<00:18,11.0MB/s]This can be beautified further:$BYTES=$(du-sbdocs/|cut-f1)$tar-cf-docs/\|tqdm--bytes--total"$BYTES"--descProcessing|gzip\|tqdm--bytes--total"$BYTES"--descCompressed--position1\>~/backup.tgzProcessing:100%|██████████████████████|352M/352M[00:14<00:00,30.2MB/s]Compressed:42%|█████████▎|148M/352M[00:14<00:19,10.9MB/s]Or done on a file level using 7-zip:$7za-bd-rbackup.7zdocs/|grepCompressing\|tqdm--total$(finddocs/-typef|wc-l)--unitfiles\|grep-vCompressing100%|██████████████████████████▉|15327/15327[01:00<00:00,712.96files/s]Pre-existing CLI programs already outputting basic progress information will
benefit fromtqdm’s--updateand--update_toflags:$seq30.15|tqdm--total5--update_to--null100%|████████████████████████████████████|5.0/5[00:00<00:00,9673.21it/s]$seq10|tqdm--update--null# 1 + 2 + ... + 10 = 55 iterations55it[00:00,90006.52it/s]FAQ and Known IssuesThe 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).Some cloud logging consoles which don’t support\rproperly
(cloudwatch,K8s) may benefit fromexportTQDM_POSITION=-1.Nested progress bars:Consoles in general: require support for moving cursors up to the
previous line. For example,IDLE,ConEmuandPyCharm(alsohere,here, andhere)
lack full support.Windows: additionally may require the Python modulecoloramato ensure nested bars stay within their respective lines.Unicode:Environments which report that they support unicode will have solid smooth
progressbars. The fallback is anascii-only bar.Windows consoles often only partially support unicode and thusoften require explicit ascii=True(alsohere). This is due to
either normal-width unicode characters being incorrectly displayed as
“wide”, or some unicode characters not rendering.Wrapping generators:Generator wrapper functions tend to hide the length of iterables.tqdmdoes not.Replacetqdm(enumerate(...))withenumerate(tqdm(...))ortqdm(enumerate(x), total=len(x),...).
The same applies tonumpy.ndenumerate.Replacetqdm(zip(a, b))withzip(tqdm(a), b)or evenzip(tqdm(a), tqdm(b)).The same applies toitertools.Some useful convenience functions can be found undertqdm.contrib.No intermediate output in docker-compose:
usedocker-composeruninstead ofdocker-composeupandtty: true.Overriding defaults via environment variables:
e.g. in CI/cloud jobs,export TQDM_MININTERVAL=5to avoid log spam.
This override logic is handled by thetqdm.utils.envwrapdecorator
(useful independent oftqdm).If you come across any other difficulties, browse and file.Documentation(Since 19 May 2016)classtqdm():"""
  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.
  """@envwrap("TQDM_")# override defaults via env varsdef__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,postfix=None,unit_divisor=1000,write_bytes=False,lock_args=None,nrows=None,colour=None,delay=0):Parametersiterableiterable, optionalIterable to decorate with a progressbar.
Leave blank to manually manage the updates.descstr, optionalPrefix for the progressbar.totalint or float, optionalThe number of expected iterations. If unspecified,
len(iterable) is used if possible. If float(“inf”) or as a last
resort, only basic progress statistics are displayed
(no ETA, no progressbar).
Ifguiis True and this parameter needs subsequent updating,
specify an initial arbitrary large positive number,
e.g. 9e9.leavebool, optionalIf [default: True], keeps all traces of the progressbar
upon termination of iteration.
IfNone, will leave only ifpositionis0.fileio.TextIOWrapperorio.StringIO, optionalSpecifies where to output the progress messages
(default: sys.stderr). Usesfile.write(str)andfile.flush()methods.  For encoding, seewrite_bytes.ncolsint, optionalThe 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).minintervalfloat, optionalMinimum progress display update interval [default: 0.1] seconds.maxintervalfloat, optionalMaximum progress display update interval [default: 10] seconds.
Automatically adjustsminitersto correspond tominintervalafter long display update lag. Only works ifdynamic_minitersor monitor thread is enabled.minitersint or float, optionalMinimum progress display update interval, in iterations.
If 0 anddynamic_miniters, will automatically adjust to equalmininterval(more CPU efficient, good for tight loops).
If > 0, will skip display of specified number of iterations.
Tweak this andminintervalto get very efficient loops.
If your progress is erratic with both fast and slow iterations
(network, skipping items, etc) you should set miniters=1.asciibool or str, optionalIf unspecified or False, use unicode (smooth blocks) to fill
the meter. The fallback is to use ASCII characters “ 123456789#”.disablebool, optionalWhether to disable the entire progressbar wrapper
[default: False]. If set to None, disable on non-TTY.unitstr, optionalString that will be used to define the unit of each iteration
[default: it].unit_scalebool or int or float, optionalIf 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 scaletotalandn.dynamic_ncolsbool, optionalIf set, constantly altersncolsandnrowsto the
environment (allowing for window resizes) [default: False].smoothingfloat, optionalExponential 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_formatstr, optionalSpecify 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}, ‘
‘{rate_fmt}{postfix}]’
Possible vars: l_bar, bar, r_bar, n, n_fmt, total, total_fmt,
percentage, elapsed, elapsed_s, ncols, nrows, desc, unit,
rate, rate_fmt, rate_noinv, rate_noinv_fmt,
rate_inv, rate_inv_fmt, postfix, unit_divisor,
remaining, remaining_s, eta.
Note that a trailing “: “ is automatically removed after {desc}
if the latter is empty.initialint or float, optionalThe initial counter value. Useful when restarting a progress
bar [default: 0]. If using float, consider specifying{n:.3f}or similar inbar_format, or specifyingunit_scale.positionint, optionalSpecify the line offset to print this bar (starting from 0)
Automatic if unspecified.
Useful to manage multiple bars at once (eg, from threads).postfixdict or*, optionalSpecify additional stats to display at the end of the bar.
Callsset_postfix(**postfix)if possible (dict).unit_divisorfloat, optional[default: 1000], ignored unlessunit_scaleis True.write_bytesbool, optionalWhether to write bytes. If (default: False) will write unicode.lock_argstuple, optionalPassed torefreshfor intermediate output
(initialisation, iterating, and updating).nrowsint, optionalThe screen height. If specified, hides nested bars outside this
bound. If unspecified, attempts to use environment height.
The fallback is 20.colourstr, optionalBar colour (e.g. ‘green’, ‘#00ff00’).delayfloat, optionalDon’t display until [default: 0] seconds have elapsed.Extra CLI Optionsdelimchr, optionalDelimiting character [default: ‘n’]. Use ‘0’ for null.
N.B.: on Windows systems, Python converts ‘n’ to ‘rn’.buf_sizeint, optionalString buffer size in bytes [default: 256]
used whendelimis specified.bytesbool, optionalIf true, will count bytes, ignoredelim, and defaultunit_scaleto True,unit_divisorto 1024, andunitto ‘B’.teebool, optionalIf true, passesstdinto bothstderrandstdout.updatebool, optionalIf true, will treat input as newly elapsed iterations,
i.e. numbers to pass toupdate(). Note that this is slow
(~2e5 it/s) since every input must be decoded as a number.update_tobool, optionalIf true, will treat input as total elapsed iterations,
i.e. numbers to assign toself.n. Note that this is slow
(~2e5 it/s) since every input must be decoded as a number.nullbool, optionalIf true, will discard input (no stdout).manpathstr, optionalDirectory in which to install tqdm man pages.comppathstr, optionalDirectory in which to place tqdm completion.logstr, optionalCRITICAL|FATAL|ERROR|WARN(ING)|[default: ‘INFO’]|DEBUG|NOTSET.Returnsout  : decorated iterator.classtqdm():defupdate(self,n=1):"""
      Manually update the progress bar, useful for streams
      such as reading files.
      E.g.:
      >>> 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.

      Parameters
      ----------
      n  : int or float, optional
          Increment to add to the internal counter of iterations
          [default: 1]. If using float, consider specifying ``{n:.3f}``
          or similar in ``bar_format``, or specifying ``unit_scale``.

      Returns
      -------
      out  : bool or None
          True if a ``display()`` was triggered.
      """defclose(self):"""Cleanup and (if leave=False) close the progressbar."""defclear(self,nomove=False):"""Clear current bar display."""defrefresh(self):"""
      Force refresh the display of this bar.

      Parameters
      ----------
      nolock  : bool, optional
          If ``True``, does not lock.
          If [default: ``False``]: calls ``acquire()`` on internal lock.
      lock_args  : tuple, optional
          Passed to internal lock's ``acquire()``.
          If specified, will only ``display()`` if ``acquire()`` returns ``True``.
      """defunpause(self):"""Restart tqdm timer from last print time."""defreset(self,total=None):"""
      Resets to 0 iterations for repeated use.

      Consider combining with ``leave=True``.

      Parameters
      ----------
      total  : int or float, optional. Total to use for the new bar.
      """defset_description(self,desc=None,refresh=True):"""
      Set/modify description of the progress bar.

      Parameters
      ----------
      desc  : str, optional
      refresh  : bool, optional
          Forces refresh [default: True].
      """defset_postfix(self,ordered_dict=None,refresh=True,**tqdm_kwargs):"""
      Set/modify postfix (additional stats)
      with automatic formatting based on datatype.

      Parameters
      ----------
      ordered_dict  : dict or OrderedDict, optional
      refresh  : bool, optional
          Forces refresh [default: True].
      kwargs  : dict, optional
      """@classmethoddefwrite(cls,s,file=sys.stdout,end="\n"):"""Print a message via tqdm (without overlap with bars)."""@propertydefformat_dict(self):"""Public API for read-only member access."""defdisplay(self,msg=None,pos=None):"""
      Use ``self.sp`` to display ``msg`` in the specified ``pos``.

      Consider overloading this function when inheriting to use e.g.:
      ``self.some_frontend(**self.format_dict)`` instead of ``self.sp``.

      Parameters
      ----------
      msg  : str, optional. What to display (default: ``repr(self)``).
      pos  : int, optional. Position to ``moveto``
        (default: ``abs(self.pos)``).
      """@classmethod@contextmanagerdefwrapattr(cls,stream,method,total=None,bytes=True,**tqdm_kwargs):"""
      stream  : file-like object.
      method  : str, "read" or "write". The result of ``read()`` and
          the first argument of ``write()`` should have a ``len()``.

      >>> with tqdm.wrapattr(file_obj, "read", total=file_obj.size) as fobj:
      ...     while True:
      ...         chunk = fobj.read(chunk_size)
      ...         if not chunk:
      ...             break
      """@classmethoddefpandas(cls,*targs,**tqdm_kwargs):"""Registers the current `tqdm` class with `pandas`."""deftrange(*args,**tqdm_kwargs):"""Shortcut for `tqdm(range(*args), **tqdm_kwargs)`."""Convenience Functionsdeftqdm.contrib.tenumerate(iterable,start=0,total=None,tqdm_class=tqdm.auto.tqdm,**tqdm_kwargs):"""Equivalent of `numpy.ndenumerate` or builtin `enumerate`."""deftqdm.contrib.tzip(iter1,*iter2plus,**tqdm_kwargs):"""Equivalent of builtin `zip`."""deftqdm.contrib.tmap(function,*sequences,**tqdm_kwargs):"""Equivalent of builtin `map`."""Submodulesclasstqdm.notebook.tqdm(tqdm.tqdm):"""IPython/Jupyter Notebook widget."""classtqdm.auto.tqdm(tqdm.tqdm):"""Automatically chooses beween `tqdm.notebook` and `tqdm.tqdm`."""classtqdm.asyncio.tqdm(tqdm.tqdm):"""Asynchronous version."""@classmethoddefas_completed(cls,fs,*,loop=None,timeout=None,total=None,**tqdm_kwargs):"""Wrapper for `asyncio.as_completed`."""classtqdm.gui.tqdm(tqdm.tqdm):"""Matplotlib GUI version."""classtqdm.tk.tqdm(tqdm.tqdm):"""Tkinter GUI version."""classtqdm.rich.tqdm(tqdm.tqdm):"""`rich.progress` version."""classtqdm.keras.TqdmCallback(keras.callbacks.Callback):"""Keras callback for epoch and batch progress."""classtqdm.dask.TqdmCallback(dask.callbacks.Callback):"""Dask callback for task progress."""contribThetqdm.contribpackage also contains experimental modules:tqdm.contrib.itertools: Thin wrappers arounditertoolstqdm.contrib.concurrent: Thin wrappers aroundconcurrent.futurestqdm.contrib.slack: Posts toSlackbotstqdm.contrib.discord: Posts toDiscordbotstqdm.contrib.telegram: Posts toTelegrambotstqdm.contrib.bells: Automagically enables all optional featuresauto,pandas,slack,discord,telegramExamples and Advanced UsageSee theexamplesfolder;import the module and runhelp();consult thewiki;this has anexcellent articleon how to make agreatprogressbar;check out theslides from PyData London, orrun the.Description and additional statsCustom information can be displayed and updated dynamically ontqdmbars
with thedescandpostfixarguments:fromtqdmimporttqdm,trangefromrandomimportrandom,randintfromtimeimportsleepwithtrange(10)ast:foriint:# Description will be displayed on the leftt.set_description('GEN%i'%i)# Postfix will be displayed on the right,# formatted automatically based on argument's datatypet.set_postfix(loss=random(),gen=randint(1,999),str='h',lst=[1,2])sleep(0.1)withtqdm(total=10,bar_format="{postfix[0]}{postfix[1][value]:>8.2g}",postfix=["Batch",{"value":0}])ast:foriinrange(10):sleep(0.1)t.postfix[1]["value"]=i/2t.update()Points to remember when using{postfix[...]}in thebar_formatstring:postfixalso needs to be passed as an initial argument in a compatible
format, andpostfixwill be auto-converted to a string if it is adict-like
object. To prevent this behaviour, insert an extra item into the dictionary
where the key is not a string.Additionalbar_formatparameters may also be defined by overridingformat_dict, and the bar itself may be modified usingascii:fromtqdmimporttqdmclassTqdmExtraFormat(tqdm):"""Provides a `total_time` format parameter"""@propertydefformat_dict(self):d=super(TqdmExtraFormat,self).format_dicttotal_time=d["elapsed"]*(d["total"]or0)/max(d["n"],1)d.update(total_time=self.format_interval(total_time)+" in total")returndforiinTqdmExtraFormat(range(9),ascii=" .oO0",bar_format="{total_time}:{percentage:.0f}%|{bar}{r_bar}"):ifi==4:break00:00 in total: 44%|0000.     | 4/9 [00:00<00:00, 962.93it/s]Note that{bar}also supports a format specifier[width][type].widthunspecified (default): automatic to fillncolsint >= 0: fixed width overridingncolslogicint < 0: subtract from the automatic defaulttypea: ascii (ascii=Trueoverride)u: unicode (ascii=Falseoverride)b: blank (ascii="  "override)This means a fixed bar with right-justified text may be created by using:bar_format="{l_bar}{bar:10}|{bar:-10b}right-justified"Nested progress barstqdmsupports nested progress bars. Here’s an example:fromtqdm.autoimporttrangefromtimeimportsleepforiintrange(4,desc='1st loop'):forjintrange(5,desc='2nd loop'):forkintrange(50,desc='3rd loop',leave=False):sleep(0.01)For manual control over positioning (e.g. for multi-processing use),
you may specifyposition=nwheren=0for the outermost bar,n=1for the next, and so on.
However, it’s best to check iftqdmcan work without manualpositionfirst.fromtimeimportsleepfromtqdmimporttrange,tqdmfrommultiprocessingimportPool,RLock,freeze_supportL=list(range(9))defprogresser(n):interval=0.001/(n+2)total=5000text=f"#{n}, est.{interval*total:<04.2}s"for_intrange(total,desc=text,position=n):sleep(interval)if__name__=='__main__':freeze_support()# for Windows supporttqdm.set_lock(RLock())# for managing output contentionp=Pool(initializer=tqdm.set_lock,initargs=(tqdm.get_lock(),))p.map(progresser,L)Note that in Python 3,tqdm.writeis thread-safe:fromtimeimportsleepfromtqdmimporttqdm,trangefromconcurrent.futuresimportThreadPoolExecutorL=list(range(9))defprogresser(n):interval=0.001/(n+2)total=5000text=f"#{n}, est.{interval*total:<04.2}s"for_intrange(total,desc=text):sleep(interval)ifn==6:tqdm.write("n == 6 completed.")tqdm.write("`tqdm.write()` is thread-safe in py3!")if__name__=='__main__':withThreadPoolExecutor()asp:p.map(progresser,L)Hooks and callbackstqdmcan easily support callbacks/hooks and manual updates.
Here’s an example withurllib:``urllib.urlretrieve`` documentation[…]If present, the hook function will be called onceon establishment of the network connection and once after each block readthereafter. The hook will be passed three arguments; a count of blockstransferred so far, a block size in bytes, and the total size of the file.[…]importurllib,osfromtqdmimporttqdmurllib=getattr(urllib,'request',urllib)classTqdmUpTo(tqdm):"""Provides `update_to(n)` which uses `tqdm.update(delta_n)`."""defupdate_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.
        """iftsizeisnotNone:self.total=tsizereturnself.update(b*bsize-self.n)# also sets self.n = b * bsizeeg_link="https://caspersci.uk.to/matryoshka.zip"withTqdmUpTo(unit='B',unit_scale=True,unit_divisor=1024,miniters=1,desc=eg_link.split('/')[-1])ast:# all optional kwargsurllib.urlretrieve(eg_link,filename=os.devnull,reporthook=t.update_to,data=None)t.total=t.nInspired bytwine#242.
Functional alternative inexamples/tqdm_wget.py.It is recommend to useminiters=1whenever there is potentially
large differences in iteration speed (e.g. downloading a file over
a patchy connection).Wrapping read/write methodsTo measure throughput through a file-like object’sreadorwritemethods, useCallbackIOWrapper:fromtqdm.autoimporttqdmfromtqdm.utilsimportCallbackIOWrapperwithtqdm(total=file_obj.size,unit='B',unit_scale=True,unit_divisor=1024)ast:fobj=CallbackIOWrapper(t.update,file_obj,"read")whileTrue:chunk=fobj.read(chunk_size)ifnotchunk:breakt.reset()# ... continue to use `t` for something elseAlternatively, use the even simplerwrapattrconvenience function,
which would condense both theurllibandCallbackIOWrapperexamples
down to:importurllib,osfromtqdmimporttqdmeg_link="https://caspersci.uk.to/matryoshka.zip"response=getattr(urllib,'request',urllib).urlopen(eg_link)withtqdm.wrapattr(open(os.devnull,"wb"),"write",miniters=1,desc=eg_link.split('/')[-1],total=getattr(response,'length',None))asfout:forchunkinresponse:fout.write(chunk)Therequestsequivalent is nearly identical:importrequests,osfromtqdmimporttqdmeg_link="https://caspersci.uk.to/matryoshka.zip"response=requests.get(eg_link,stream=True)withtqdm.wrapattr(open(os.devnull,"wb"),"write",miniters=1,desc=eg_link.split('/')[-1],total=int(response.headers.get('content-length',0)))asfout:forchunkinresponse.iter_content(chunk_size=4096):fout.write(chunk)Custom callbacktqdmis known for intelligently skipping unnecessary displays. To make a
custom callback take advantage of this, simply use the return value ofupdate(). This is set toTrueif adisplay()was triggered.fromtqdm.autoimporttqdmasstd_tqdmdefexternal_callback(*args,**kwargs):...classTqdmExt(std_tqdm):defupdate(self,n=1):displayed=super(TqdmExt,self).update(n)ifdisplayed:external_callback(**self.format_dict)returndisplayedasyncioNote thatbreakisn’t currently caught by asynchronous iterators.
This means thattqdmcannot clean up after itself in this case:fromtqdm.asyncioimporttqdmasyncforiintqdm(range(9)):ifi==2:breakInstead, either callpbar.close()manually or use the context manager syntax:fromtqdm.asyncioimporttqdmwithtqdm(range(9))aspbar:asyncforiinpbar:ifi==2:breakPandas IntegrationDue to popular demand we’ve added support forpandas– here’s an example
forDataFrame.progress_applyandDataFrameGroupBy.progress_apply:importpandasaspdimportnumpyasnpfromtqdmimporttqdmdf=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`, `tqdm.notebook.tqdm`, 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(lambdax: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 theexamplesfolder or import the module and runhelp().Keras IntegrationAkerascallback is also available:fromtqdm.kerasimportTqdmCallback...model.fit(...,verbose=0,callbacks=[TqdmCallback()])Dask IntegrationAdaskcallback is also available:fromtqdm.daskimportTqdmCallbackwithTqdmCallback(desc="compute"):...arr.compute()# or use callback globallycb=TqdmCallback(desc="global")cb.register()arr.compute()IPython/Jupyter IntegrationIPython/Jupyter is supported via thetqdm.notebooksubmodule:fromtqdm.notebookimporttrange,tqdmfromtimeimportsleepforiintrange(3,desc='1st loop'):forjintqdm(range(100),desc='2nd loop'):sleep(0.01)In addition totqdmfeatures, the submodule provides a native Jupyter
widget (compatible with IPython v1-v4 and Jupyter), fully working nested bars
and colour hints (blue: normal, green: completed, red: error/interrupt,
light blue: no ETA); as demonstrated below.Thenotebookversion supports percentage or pixels for overall width
(e.g.:ncols='100%'orncols='480px').It is also possible to lettqdmautomatically choose between
console or notebook versions by using theautonotebooksubmodule:fromtqdm.autonotebookimporttqdmtqdm.pandas()Note that this will issue aTqdmExperimentalWarningif run in a notebook
since it is not meant to be possible to distinguish betweenjupyter notebookandjupyter console. Useautoinstead ofautonotebookto suppress
this warning.Note that notebooks will display the bar in the cell where it was created.
This may be a different cell from the one where it is used.
If this is not desired, eitherdelay the creation of the bar to the cell where it must be displayed, orcreate the bar withdisplay=False, and in a later cell calldisplay(bar.container):fromtqdm.notebookimporttqdmpbar=tqdm(...,display=False)# different celldisplay(pbar.container)Thekerascallback has adisplay()method which can be used likewise:fromtqdm.kerasimportTqdmCallbackcbk=TqdmCallback(display=False)# different cellcbk.display()model.fit(...,verbose=0,callbacks=[cbk])Another possibility is to have a single bar (near the top of the notebook)
which is constantly re-used (usingreset()rather thanclose()).
For this reason, the notebook version (unlike the CLI version) does not
automatically callclose()uponException.fromtqdm.notebookimporttqdmpbar=tqdm()# different celliterable=range(100)pbar.reset(total=len(iterable))# initialise with new `total`foriiniterable:pbar.update()pbar.refresh()# force print final status but don't `close()`Custom IntegrationTo change the default arguments (such as makingdynamic_ncols=True),
simply use built-in Python magic:fromfunctoolsimportpartialfromtqdmimporttqdmasstd_tqdmtqdm=partial(std_tqdm,dynamic_ncols=True)For further customisation,tqdmmay be inherited from to create custom callbacks (as with theTqdmUpToexampleabove) or for custom frontends
(e.g. GUIs such as notebook or plotting packages). In the latter case:def __init__()to callsuper().__init__(...,gui=True)to disable
terminalstatus_printercreation.Redefine:close(),clear(),display().Consider overloadingdisplay()to use e.g.self.frontend(**self.format_dict)instead ofself.sp(repr(self)).Some submodule examples of inheritance:tqdm/notebook.pytqdm/gui.pytqdm/tk.pytqdm/contrib/slack.pytqdm/contrib/discord.pytqdm/contrib/telegram.pyDynamic Monitor/MeterYou can use atqdmas a meter which is not monotonically increasing.
This could be becausendecreases (e.g. a CPU usage monitor) ortotalchanges.One example would be recursively searching for files. Thetotalis the
number of objects found so far, whilenis the number of those objects which
are files (rather than folders):fromtqdmimporttqdmimportos.pathdeffind_files_recursively(path,show_progress=True):files=[]# total=1 assumes `path` is a filet=tqdm(total=1,unit="file",disable=notshow_progress)ifnotos.path.exists(path):raiseIOError("Cannot find:"+path)defappend_found_file(f):files.append(f)t.update()deflist_found_dir(path):"""returns os.listdir(path) assuming os.path.isdir(path)"""listing=os.listdir(path)# subtract 1 since a "file" we found was actually this directoryt.total+=len(listing)-1# fancy way to give info without forcing a refresht.set_postfix(dir=path[-10:],refresh=False)t.update(0)# may trigger a refreshreturnlistingdefrecursively_search(path):ifos.path.isdir(path):forfinlist_found_dir(path):recursively_search(os.path.join(path,f))else:append_found_file(path)recursively_search(path)t.set_postfix(dir=path)t.close()returnfilesUsingupdate(0)is a handy way to lettqdmdecide when to trigger a
display refresh to avoid console spamming.Writing messagesThis is a work in progress (see#737).Sincetqdmuses a simple printing mechanism to display progress bars,
you should not write any message in the terminal usingprint()while
a progressbar is open.To write messages in the terminal without any collision withtqdmbar
display, a.write()method is provided:fromtqdm.autoimporttqdm,trangefromtimeimportsleepbar=trange(10)foriinbar:# Print using tqdm class method .write()sleep(0.1)ifnot(i%3):tqdm.write("Done task%i"%i)# Can also use bar.write()By default, this will print to standard outputsys.stdout. but you can
specify any file-like object using thefileargument. For example, this
can be used to redirect the messages writing to a log file or class.Redirecting writingIf using a library that can print messages to the console, editing the library
by  replacingprint()withtqdm.write()may not be desirable.
In that case, redirectingsys.stdouttotqdm.write()is an option.To redirectsys.stdout, create a file-like class that will write
any input string totqdm.write(), and supply the argumentsfile=sys.stdout, dynamic_ncols=True.A reusable canonical example is given below:fromtimeimportsleepimportcontextlibimportsysfromtqdmimporttqdmfromtqdm.contribimportDummyTqdmFile@contextlib.contextmanagerdefstd_out_err_redirect_tqdm():orig_out_err=sys.stdout,sys.stderrtry:sys.stdout,sys.stderr=map(DummyTqdmFile,orig_out_err)yieldorig_out_err[0]# Relay exceptionsexceptExceptionasexc:raiseexc# Always restore sys.stdout/err if necessaryfinally:sys.stdout,sys.stderr=orig_out_errdefsome_fun(i):print("Fee, fi, fo,".split()[i])# Redirect stdout to tqdm.write() (don't forget the `as save_stdout`)withstd_out_err_redirect_tqdm()asorig_stdout:# tqdm needs the original stdout# and dynamic_ncols=True to autodetect console widthforiintqdm(range(3),file=orig_stdout,dynamic_ncols=True):sleep(.5)some_fun(i)# After the `with`, printing is restoredprint("Done!")RedirectingloggingSimilar tosys.stdout/sys.stderras detailed above, consoleloggingmay also be redirected totqdm.write().Warning: if also redirectingsys.stdout/sys.stderr, make sure to
redirectloggingfirst if needed.Helper methods are available intqdm.contrib.logging. For example:importloggingfromtqdmimporttrangefromtqdm.contrib.loggingimportlogging_redirect_tqdmLOG=logging.getLogger(__name__)if__name__=='__main__':logging.basicConfig(level=logging.INFO)withlogging_redirect_tqdm():foriintrange(9):ifi==4:LOG.info("console logging redirected to `tqdm.write()`")# logging restoredMonitoring thread, intervals and miniterstqdmimplements a few tricks to increase efficiency and reduce overhead.Avoid unnecessary frequent bar refreshing:minintervaldefines how long
to wait between each refresh.tqdmalways gets updated in the background,
but it will display only everymininterval.Reduce number of calls to check system clock/time.minintervalis more intuitive to configure thanminiters.
A clever adjustment systemdynamic_miniterswill automatically adjustminitersto the amount of iterations that fit into timemininterval.
Essentially,tqdmwill check if it’s time to print without actually
checking time. This behaviour can be still be bypassed by manually settingminiters.However, consider a case with a combination of fast and slow iterations.
After a few fast iterations,dynamic_miniterswill setminitersto a
large number. When iteration rate subsequently slows,miniterswill
remain large and thus reduce display update frequency. To address this:maxintervaldefines 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 themonitor_intervalof
anytqdminstance (i.e.t =tqdm.tqdm(...);t.monitor_interval = 2).
The monitor thread may be disabled application-wide by settingtqdm.tqdm.monitor_interval = 0before instantiation of anytqdmbar.MerchYou can buytqdm branded merchnow!ContributionsAll source code is hosted onGitHub.
Contributions are welcome.See theCONTRIBUTINGfile for more information.Developers who have made significant contributions, ranked bySLoC(surviving lines of code,git fame-wMC--excl'\.(png|gif|jpg)$'),
are:NameIDSLoCNotesCasper da Costa-Luiscasperdcl~80%primary maintainerStephen Larroquelrq3000~9%team memberMartin Zugnonimartinzugnoni~3%Daniel Ecerde-code~2%Richard Sheridanrichardsheridan~1%Guangshuo Chenchengs~1%Helio Machado0x2b3bfa0~1%Kyle Altendorfaltendky<1%Noam Yorav-Raphaelnoamraph<1%original authorMatthew Stevensmjstevens777<1%Hadrien Maryhadim<1%team memberMikhail Korobovkmike<1%team memberPorts to Other LanguagesA list is available onthis wiki page.LICENCEOpen Source (OSI approved):Citation information:(Since 19 May 2016)