HEX

File: //usr/local/lib/python3.10/dist-packages/tqdm/__pycache__/std.cpython-310.pyc
o

���gu��@svdZddlZddlmZmZddlmZddlmZmZm	Z	ddl
mZddlmZddl
mZdd	lmZd
dlmZd
dlmZmZmZmZmZmZmZmZmZmZmZmZd
Z gd�Z!Gdd�de"�Z#Gdd�de$�Z%Gdd�de&�Z'Gdd�de'e(�Z)Gdd�de'e*�Z+Gdd�de'e,�Z-dd�Z.Gdd�de/�Z0Gdd �d e/�Z1Gd!d"�d"e/�Z2Gd#d$�d$e�Z3d%d&�Z4dS)'z�
Customisable progressbar decorator for iterators.
Includes a default `range` iterator printing to `stderr`.

Usage:
>>> from tqdm import trange, tqdm
>>> for i in trange(10):
...     ...
�N)�OrderedDict�defaultdict)�contextmanager)�datetime�	timedelta�timezone)�Number)�time)�warn)�WeakSet�)�TMonitor)�CallbackIOWrapper�
Comparable�DisableOnWriteError�
FormatReplace�SimpleTextIOWrapper�	_is_ascii�_screen_shape_wrapper�_supports_unicode�
_term_move_up�disp_len�	disp_trim�envwrapz*https://github.com/tqdm/tqdm#contributions)�tqdm�trange�
TqdmTypeError�TqdmKeyError�TqdmWarning�TqdmExperimentalWarning�TqdmDeprecationWarning�TqdmMonitorWarningc@�eZdZdS)rN��__name__�
__module__�__qualname__�r'r'�3/usr/local/lib/python3.10/dist-packages/tqdm/std.pyr �rc@r")rNr#r'r'r'r(r$r)rcs"eZdZdZd�fdd�	Z�ZS)rzqbase class for all tqdm warnings.

    Used for non-external-code-breaking errors, such as garbled printing.
    NcsN|dur|d|jjdt|���d�dSt�j|g|�Ri|��dS)N�
�: )�	__class__r$�str�rstrip�super�__init__)�self�msg�fp_write�a�k�r,r'r(r0-s(zTqdmWarning.__init__�N)r$r%r&�__doc__r0�
__classcell__r'r'r6r(r(src@�eZdZdZdS)rz(beta feature, unstable API and behaviourN�r$r%r&r8r'r'r'r(r4�rc@r")r Nr#r'r'r'r(r 9sr c@r:)r!z>tqdm monitor errors which do not affect external functionalityNr;r'r'r'r(r!>r<r!c	Os6zddlm}||i|��WSttfyYdSw)zthreading RLockr��RLockN)�	threadingr>�ImportError�OSError)�args�kwargsr>r'r'r(�TRLockCs�rDc@sVeZdZdZe�Zdd�Zdd�Zdd�Zdd	�Z	d
d�Z
edd
��Zedd��Z
dS)�TqdmDefaultWriteLocka�
    Provide a default write lock for thread and multiprocessing safety.
    Works only on platforms supporting `fork` (so Windows is excluded).
    You must initialise a `tqdm` or `TqdmDefaultWriteLock` instance
    before forking in order for the write lock to work.
    On Windows, you need to supply the lock from the parent to the children as
    an argument to joblib or the parallelism lib you use.
    cCsVt|�}|j}|dur|��|��dd�|j|jfD�|_|dur)|��dSdS)NcSsg|]}|dur|�qSr7r')�.0�lkr'r'r(�
<listcomp>bsz1TqdmDefaultWriteLock.__init__.<locals>.<listcomp>)�type�th_lock�acquire�create_mp_lock�mp_lock�locks�release)r1�cls�	root_lockr'r'r(r0Zs�zTqdmDefaultWriteLock.__init__cOs |jD]
}|j|i|��qdSr7)rNrK)r1r4r5�lockr'r'r(rKfs
�zTqdmDefaultWriteLock.acquirecCs"|jddd�D]}|��qdS)N���)rNrO)r1rRr'r'r(rOjs
�zTqdmDefaultWriteLock.releasecC�|��dSr7)rK�r1r'r'r(�	__enter__n�zTqdmDefaultWriteLock.__enter__cGrTr7)rO)r1�excr'r'r(�__exit__qrWzTqdmDefaultWriteLock.__exit__c	CsHt|d�s"z
ddlm}|�|_WdSttfy!d|_YdSwdS)NrMrr=)�hasattr�multiprocessingr>rMr@rA)rPr>r'r'r(rLts
��z#TqdmDefaultWriteLock.create_mp_lockcCs t|d�sJ�tdtdd�dS)NrJz!create_th_lock not needed anymore���
stacklevel)rZr
r �rPr'r'r(�create_th_lock}sz#TqdmDefaultWriteLock.create_th_lockN)r$r%r&r8rDrJr0rKrOrVrY�classmethodrLr`r'r'r'r(rELs
rEc	@s�eZdZdZdZdd�eeeddd���Z	dZ
d	Zd
Zddd
dddddd�Z
de	dfdd�Zedd��Zejdd��Zdd�ZdS)�Bara�
    `str.format`-able bar with format specifiers: `[width][type]`

    - `width`
      + unspecified (default): use `self.default_len`
      + `int >= 0`: overrides `self.default_len`
      + `int < 0`: subtract from `self.default_len`
    - `type`
      + `a`: ascii (`charset=self.ASCII` override)
      + `u`: unicode (`charset=self.UTF` override)
      + `b`: blank (`charset="  "` override)
    z 123456789#� �i�%i�%rSz  z[0mz[38;2;%d;%d;%dmz[30mz[31mz[32mz[33mz[34mz[35mz[36mz[37m)�BLACK�RED�GREEN�YELLOW�BLUE�MAGENTA�CYAN�WHITE�
NcCs\d|kr
dksntdtdd�tdtd|��}|dks J�||_||_||_||_dS)Nrrzclamping frac to range [0, 1]r\r])r
r�max�min�frac�default_len�charset�colour)r1rprqrrrsr'r'r(r0�s
zBar.__init__cC�|jSr7)�_colourrUr'r'r(rs�sz
Bar.colourc	Cs�|sd|_dSz?|��|jvr|j|��|_WdS|ddkrEt|�dkrE|jtdd�|dd�|dd�|dd�fD��|_WdSt�ttfydtd	|d
�	|j�ft
dd�d|_YdSw)
Nr�#�css�|]}t|d�VqdS)�N)�int)rF�ir'r'r(�	<genexpr>�s�

�zBar.colour.<locals>.<genexpr>r��z7Unknown colour (%s); valid choices: [hex (#00ff00), %s]�, r\r])ru�upper�COLOURS�len�
COLOUR_RGB�tuple�KeyError�AttributeErrorr
�joinr)r1�valuer'r'r(rs�s& ����c	Cs�|r<|d��}z
|j|j|jd�|}Wnty!|j}Ynw|dd�}|r8t|�}|dkr7||j7}n
|j}n|j}|j}t|�d}t	t|j
||�|�\}}|d|}||krp||||d||d}|jr{|j||jS|S)NrS)r4�u�brr)
�lower�ASCII�UTF�BLANKr�rrryrqr��divmodrprs�COLOUR_RESET)	r1�format_spec�_typerr�N_BARS�nsyms�
bar_length�frac_bar_length�resr'r'r(�
__format__�s,
�
� zBar.__format__)r$r%r&r8r�r��map�chr�ranger�r�r�r�r�r0�propertyrs�setterr�r'r'r'r(rb�s"�


rbc@s$eZdZdZddd�Zd	dd�ZdS)
�EMAa[
    Exponential moving average: smoothing to give progressively lower
    weights to older values.

    Parameters
    ----------
    smoothing  : float, optional
        Smoothing factor in range [0, 1], [default: 0.3].
        Increase to give more weight to recent values.
        Ranges from 0 (yields old value) to 1 (yields new value).
    �333333�?cCs||_d|_d|_dS)Nr��alpha�last�calls)r1�	smoothingr'r'r(r0�s
zEMA.__init__NcCsVd|j}|dur|j|||j|_|jd7_|jr(|jd||jS|jS)zk
        Parameters
        ----------
        x  : float
            New value to include in EMA.
        rNr�)r1�x�betar'r'r(�__call__�s

 zEMA.__call__)r�r7)r$r%r&r8r0r�r'r'r'r(r��s
r�c	@s�eZdZdZdZdZe�Zedadd��Z	edd	��Z
ed
d��Zedd
��Ze			dbdd��Z
dd�Zedcdd��Zedd��Zedddd��Zeededd���Zedd��Zed d!��Zed"d#��Zed$d%eeeeed&�d'�						dfd,d-��Zd.d/�Zd0d1�Zd2d3�Zd4d5�Zd6d7�Z d8d9�Z!d:d;�Z"d<d=�Z#e$d>d?��Z%d@dA�Z&dBdC�Z'dgdEdF�Z(dGdH�Z)dhdIdJ�Z*didKdL�Z+dMdN�Z,dcdOdP�Z-djdQdR�Z.djdSdT�Z/djdUdV�Z0dkdWdX�Z1dYdZ�Z2e$d[d\��Z3dld]d^�Z4eedjd_d`���Z5dS)mrad
    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.

    Parameters
    ----------
    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 or float, optional
        The 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).
        If `gui` is True and this parameter needs subsequent updating,
        specify an initial arbitrary large positive number,
        e.g. 9e9.
    leave  : bool, optional
        If [default: True], keeps all traces of the progressbar
        upon termination of iteration.
        If `None`, will leave only if `position` is `0`.
    file  : `io.TextIOWrapper` or `io.StringIO`, optional
        Specifies where to output the progress messages
        (default: sys.stderr). Uses `file.write(str)` and `file.flush()`
        methods.  For encoding, see `write_bytes`.
    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 [default: 0.1] seconds.
    maxinterval  : float, optional
        Maximum progress display update interval [default: 10] seconds.
        Automatically adjusts `miniters` to correspond to `mininterval`
        after long display update lag. Only works if `dynamic_miniters`
        or monitor thread is enabled.
    miniters  : int or float, 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 or str, optional
        If unspecified or False, use unicode (smooth blocks) to fill
        the meter. The fallback is to use ASCII characters " 123456789#".
    disable  : bool, optional
        Whether to disable the entire progressbar wrapper
        [default: False]. If set to None, disable on non-TTY.
    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` and `nrows` 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}, '
            '{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.
    initial  : int or float, optional
        The initial counter value. Useful when restarting a progress
        bar [default: 0]. If using float, consider specifying `{n:.3f}`
        or similar in `bar_format`, or specifying `unit_scale`.
    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 or *, optional
        Specify additional stats to display at the end of the bar.
        Calls `set_postfix(**postfix)` if possible (dict).
    unit_divisor  : float, optional
        [default: 1000], ignored unless `unit_scale` is True.
    write_bytes  : bool, optional
        Whether to write bytes. If (default: False) will write unicode.
    lock_args  : tuple, optional
        Passed to `refresh` for intermediate output
        (initialisation, iterating, and updating).
    nrows  : int, optional
        The screen height. If specified, hides nested bars outside this
        bound. If unspecified, attempts to use environment height.
        The fallback is 20.
    colour  : str, optional
        Bar colour (e.g. 'green', '#00ff00').
    delay  : float, optional
        Don't display until [default: 0] seconds have elapsed.
    gui  : bool, optional
        WARNING: internal parameter - do not use.
        Use tqdm.gui.tqdm(...) instead. If set, will attempt to use
        matplotlib animations for a graphical output [default: False].

    Returns
    -------
    out  : decorated iterator.
    rmNrd��cCs�dD]9}t|�dkr7t|�dkr,t|�dkr!|d�|�|��S|d�|�|��S|d�|�|��S||}q|d�d	|��S)
a�
        Formats a number (greater than unity) with SI Order of Magnitude
        prefixes.

        Parameters
        ----------
        num  : float
            Number ( >= 1) to format.
        suffix  : str, optional
            Post-postfix [default: ''].
        divisor  : float, optional
            Divisor between prefixes [default: 1000].

        Returns
        -------
        out  : str
            Number with Order of Magnitude SI unit postfix.
        )rdr5�M�G�T�P�E�Zg<�@g�����X@g=
ףp�#@z1.2fz2.1f�3.0fz3.1f�Y)�abs)�num�suffix�divisor�unitr'r'r(�
format_sizeofrs
ztqdm.format_sizeofcCsPtt|�d�\}}t|d�\}}|r|d�d|d�d|d��S|d�d|d��S)z�
        Formats a number of seconds as a clock time, [H:]MM:SS

        Parameters
        ----------
        t  : int
            Number of seconds.

        Returns
        -------
        out  : str
            [H:]MM:SS
        �<�d�:�02d)r�ry)�t�mins�s�h�mr'r'r(�format_interval�s0ztqdm.format_intervalcCs8|d��dd��dd�}t|�}t|�t|�kr|S|S)z�
        Intelligent scientific notation (.3g).

        Parameters
        ----------
        n  : int or float or Numeric
            A Number.

        Returns
        -------
        out  : str
            Formatted number.
        z.3gze+0ze+ze-0ze-)�replacer-r�)�n�fr'r'r(�
format_num�sztqdm.format_numcsr|�t�ddd����tjtjfvr&ttjddd���ttjddd�����fdd��dg���fd	d
�}|S)z�
        Manage the printing and in-place updating of a line of characters.
        Note that if the string is longer than a line, then in-place
        updating may not work (it will print a new line at each refresh).
        �flushcS�dSr7r'r'r'r'r(�<lambda>��z%tqdm.status_printer.<locals>.<lambda>cSr�r7r'r'r'r'r(r��r�cSr�r7r'r'r'r'r(r��r�cs��t|����dSr7)�writer-�r�)�fp�fp_flushr'r(r3�s
z%tqdm.status_printer.<locals>.fp_writercs6t|�}�d|dt�d|d��|�d<dS)N�
rcr)rrn)r��len_s)r3�last_lenr'r(�print_status�s"z)tqdm.status_printer.<locals>.print_status)�getattr�sys�stderr�stdout)�filer�r')r�r�r3r�r(�status_printer�sztqdm.status_printerF�itrc#Ks�|r
||dkr
d}|r"|dvr"|r||9}||9}|r ||9}d}t�|�}|dur3|r3|||}|r9d|nd}tj}|rJ|rF||�n|d�nd|d}|r\|rX||�n|d�ndd	|}|rj|dkrj|n|}|r�|||d
�}|dur~|||d
�nd}nt|�}|dur�t|�nd}z
|
r�d|
nd}
Wn	ty�Ynw|r�|r�|||nd
}|r�t�|�nd}z|r�|r�t��t|d�nt�d
t	j
�}Wnty�tj}Ynw|r�|dd�dk}|r�|n|d}nd}d|�d|�d|�d|�d|�|
�d�}id|�d|�d|�d|�d|�d|�d|�d|�pd�d|�d|�r.|dk�r.|n|�d |�d!|�d"|�d#|�d$|�d%|
�d&|�|
|||||d'��|�}|�r�||}|d(}||d)�d*�7}|d
k�ru|dd+�|dd�S|j
|d,�|	�r�|j
|d-�|�s�|	�d.d�}	nd/}	t�} |	jd6d0| i|��}!| j�s�|!St||�r�td|t|!��nd1|d2u�r�tjn|�p�tj|
d3�} t| j��s�t|	��r�t|	�}	|	jd6d0| i|��}"|�r�t|"|�S|"S|	�r0|d47}|j
|d
d5�t�} |	jd6d0| i|��}!| j�s|!Std
|�rtd|t|!��nd1tj|
d3�} |	jd6d0| i|��}"|�r.t|"|�S|"S|�r7|dnd�|�|�d|�d|�|
�d�	S)7a�
        Return a string-based progress bar given some parameters

        Parameters
        ----------
        n  : int or float
            Number of finished iterations.
        total  : int or float
            The expected total number of iterations. If meaningless (None),
            only basic progress statistics are displayed (no ETA).
        elapsed  : float
            Number of seconds passed since start.
        ncols  : int, optional
            The width of the entire output message. If specified,
            dynamically resizes `{bar}` to stay within this bound
            [default: None]. If `0`, will not print any bar (only stats).
            The fallback is `{bar:10}`.
        prefix  : str, optional
            Prefix message (included in total width) [default: ''].
            Use as {desc} in bar_format string.
        ascii  : bool, optional or str, optional
            If not set, use unicode (smooth blocks) to fill the meter
            [default: False]. The fallback is to use ASCII characters
            " 123456789#".
        unit  : str, optional
            The iteration unit [default: 'it'].
        unit_scale  : bool or int or float, optional
            If 1 or True, the number of iterations will be printed with an
            appropriate SI metric prefix (k = 10^3, M = 10^6, etc.)
            [default: False]. If any other non-zero number, will scale
            `total` and `n`.
        rate  : float, optional
            Manual override for iteration rate.
            If [default: None], uses n/elapsed.
        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}, '
              '{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.
        postfix  : *, optional
            Similar to `prefix`, but placed at the end
            (e.g. for additional stats).
            Note: postfix is usually a string (not a dict) for this method,
            and will if possible be set to postfix = ', ' + postfix.
            However other types are supported (#382).
        unit_divisor  : float, optional
            [default: 1000], ignored unless `unit_scale` is True.
        initial  : int or float, optional
            The initial counter value [default: 0].
        colour  : str, optional
            Bar colour (e.g. 'green', '#00ff00').

        Returns
        -------
        out  : Formatted meter and stats, ready to display.
        g�?N)TrFrz5.2f�?z/szs/)r�r~rdr)�seconds���r+z| �/z [�<�]r��n_fmt�total�	total_fmt�elapsed�	elapsed_s�ncols�descr��rate�rate_fmt�
rate_noinv�rate_noinv_fmt�rate_inv�rate_inv_fmt�postfix�unit_divisor)rs�	remaining�remaining_s�l_bar�r_bar�eta�dr�z%|rS)r�)�
percentagez{desc}: z{l_bar}{bar}{r_bar}�barrmT)rrrs�|)r�r�r')rr�r�r-�	TypeErrorr�nowr�
fromtimestampr�utc�
OverflowErrorrn�updater�r�format�
format_calledrbrr�r�rrrrr�)#r�r�r�r��prefix�asciir��
unit_scaler��
bar_formatr�r��initialrs�extra_kwargs�elapsed_str�inv_rater�r�r�r�r�r�r��
remaining_str�eta_dt�bool_prefix_colon_alreadyr�r��format_dictrpr��full_bar�nobarr�r'r'r(�format_meter�s"F
����������
�(�������
��������	�	�
��
��������ztqdm.format_metercOs�t�|�}|���^|j�|�|jrG|jdus|j��sOz	t||j�|_Wn0t	yF}zt
dt|�tdd�d|_WYd}~nd}~wwWd�|SWd�|SWd�|SWd�|S1sjwY|S)Nz>tqdm:disabling monitor support (monitor_interval = 0) due to:
r\r]r)
�object�__new__�get_lock�
_instances�add�monitor_interval�monitor�reportr
�	Exceptionr
r-r!)rP�_�__�instance�er'r'r(r
�s>

������
��
��
��
��ztqdm.__new__cs2�fdd�|jD�}tttt|�d���|��S)zSkips specified instance.cs(h|]}|�urt|d�rt|j��qS��pos)rZr�r)rF�inst�rr'r(�	<setcomp>�s�z%tqdm._get_free_pos.<locals>.<setcomp>r)rro�setr�r��
difference)rPr�	positionsr'rr(�
_get_free_pos�sztqdm._get_free_posc	s�|j�Wz|j�|�Wn	tyYnw|jsJ|jpdd�tt�fdd�|j��}|rRt|dd�d�}|j	dd�t
|j�|_Wd	�d	SWd	�d	SWd	�d	S1s]wYd	S)
a5
        Remove from list and reposition another unfixed bar
        to fill the new gap.

        This means that by default (where all nested bars are unfixed),
        order is not maintained but screen flicker/blank space is minimised.
        (tqdm<=4.44.1 moved ALL subsequent unfixed bars up.)
        �rcst|d�o	�|jkS)Nr)rZr�rz�r�r'r(r��sz&tqdm._decr_instances.<locals>.<lambda>cSrtr7rr#r'r'r(r��s)�keyT��nolockN)�_lockr�remover��gui�nrows�list�filterro�clearr�r)rPr�	instancesrr'r$r(�_decr_instances�s*
�
���"�ztqdm._decr_instancesr*cCsZ|dur|ntj}|j||d��|�|�|�|�Wd�dS1s&wYdS)z5Print a message via tqdm (without overlap with bars).N)r�r')r�r��external_write_moder�)rPr�r��endr'r�r'r'r(r��s

"�z
tqdm.writeccs��|dur|ntj}zN|s|����g}t|dg�D]#}t|d�r>|j|ks3tdd�||jfD��r>|jdd�|�	|�qdV|D]}|j
dd�qDW|sW|j��dSdS|sa|j��ww)z�
        Disable tqdm within context and refresh tqdm when exits.
        Useful when writing to standard output stream
        Nr�start_tcss �|]}|tjtjfvVqdSr7)r�r�r�)rFr�r'r'r(r{�s�
�z+tqdm.external_write_mode.<locals>.<genexpr>Tr&)
r�r�rrKr�rZr��allr.�append�refreshr(rO)rPr�r'r��inst_clearedrr'r'r(r1�s,��
����ztqdm.external_write_modecCs
||_dS)zSet the global lock.N)r()rPrRr'r'r(�set_lock�s
z
tqdm.set_lockcCst|d�s	t�|_|jS)z7Get the global lock. Construct it if it does not exist.r()rZrEr(r_r'r'r(r�s
z
tqdm.get_lockc
s�ddlm}m}ddlm}ddlm�z!|��|dtd�ddlm	}Wd�n1s/wYWnt
y@d}Ynwd	\}}zdd
lm�Wn9t
y�zdd
l
m�Wn't
y�zddlm}ddlm}||f�Wnt
y�d�YnwYnwYnwzdd
lm}ddlm}	Wn%t
y�z
ddlm}	m}Wnt
y�ddlm}	m}YnwYnwzddlm}
Wnt
y�ddlm}
Ynwzddlm}Wnt
y�zddlm}Wnt
y�d}YnwYnw������dd�g�d�����fdd�	}|��_|�|_|d��_|d�|_|�|_|�|	_|d�|_|d�|_|d�|	_|du�rA|�|_|du�rJ|�|_|�|
_|d�|
_|d�|
_|du�rl|du�rl|�|_|�|_dS�du�rw|��_dSdS)ae
        Registers the current `tqdm` class with
            pandas.core.
            ( frame.DataFrame
            | series.Series
            | groupby.(generic.)DataFrameGroupBy
            | groupby.(generic.)SeriesGroupBy
            ).progress_apply

        A new instance will be created every time `progress_apply` is called,
        and each instance will automatically `close()` upon completion.

        Parameters
        ----------
        tqdm_kwargs  : arguments for the tqdm instance

        Examples
        --------
        >>> import pandas as pd
        >>> import numpy as np
        >>> from tqdm import tqdm
        >>> from tqdm.gui import tqdm as tqdm_gui
        >>>
        >>> df = pd.DataFrame(np.random.randint(0, 100, (100000, 6)))
        >>> tqdm.pandas(ncols=50)  # can use tqdm_gui, optional kwargs, etc
        >>> # Now you can use `progress_apply` instead of `apply`
        >>> df.groupby(0).progress_apply(lambda x: x**2)

        References
        ----------
        <https://stackoverflow.com/questions/18603270/        progress-indicator-during-pandas-operations-python>
        r)�catch_warnings�simplefilter)�	DataFrame)�Series�ignore)�category)�PanelN�NN)�_Rolling_and_Expanding)�	Expanding)�Rolling)�
SeriesGroupBy)�DataFrameGroupBy)rErD)�GroupBy)�PanelGroupBy�deprecated_t�applycs������fdd�}|S)Ncsb��dt|dd��}|durD�dkr|j}n.t|��r t|�}n$�dus)t|��sD|�dd�}|dkr6d}n|dkr<d	}|j|j|}�ddurS�d�d�d<n	�dd|i����t|�dkrotd
t�jdt	j
j�d�zdd
lm
}Wnty�|j}Ynwz|���Wn	ty�Ynw��fdd�}zt|��|fi|��W���S���w)aT
                Parameters
                ----------
                df  : (DataFrame|Series)[GroupBy]
                    Data (may be grouped).
                func  : function
                    To be applied on the (grouped) data.
                **kwargs  : optional
                    Transmitted to `df.apply()`.
                r��ngroupsN�applymap�axisr�index�columnsrz�Except func, normal arguments are intentionally not supported by `(DataFrame|Series|GroupBy).progress_apply`. Use keyword arguments instead.r��r3)�is_builtin_funccs0�j�jr�j�jkr
dndd��|i|��S)Nrr)r�)r�r�r��rBrC��funcr�r'r(�wrapper�s"zDtqdm.pandas.<locals>.inner_generator.<locals>.inner.<locals>.wrapperr')�popr��size�
isinstancer��get�shaper r�r�r�r��pandas.core.commonrPr@�_is_builtin_funcr��close)�dfrSrBrCr�rLrPrT)r<rArPrH�df_function�tqdm_kwargsrRr(�innerRsL


�
�
��
z3tqdm.pandas.<locals>.inner_generator.<locals>.innerr')r^r`�r<rArPrHr_)r^r(�inner_generatorQsGz$tqdm.pandas.<locals>.inner_generatorr�rK�	aggregate�	transform)rI)�warningsr9r:�pandas.core.framer;�pandas.core.seriesr<�
FutureWarning�pandasr?r@�pandas.core.window.rollingrA�pandas.core.window�pandas.core.window.expandingrBrC�pandas.core.groupby.genericrDrE�pandas.core.groupby.groupby�pandas.core.groupbyrFrG�copyrU�progress_apply�progress_map�progress_applymap�progress_aggregate�progress_transform)
rPr_r9r:r;r?rCrBrDrErFrGrbr'rar(ri�s�#��������
�������L









�ztqdm.pandas�TQDM_T)r�r��miniters�positionr+)�	is_method�types皙�����?�$@r��c 	Ks�|durtj}|rt|t|dd�pdd�}t||d�}|dur*t|d�r*|��s*d}|durF|durFzt|�}Wn
tt	fyEd}Ynw|t
d�krNd}|r�||_||_|j
�|�|�|_|j�|�Wd�n1spwY||_||_||_dS|r�d|_|j
�|�|�|_|j�|�Wd�n1s�wYd	|vr�td
t|dtjj�d��td
t|���|dus�|dur�|tjtjfvs�|r�|r�t�}|r�||�\}}nt�}|r�||�\}}|dur�|}|dur�|}|	dur�d}	d}nd}|du�rd}|du�rd}|
du�rt|�}
|�r'|
du�r't|
��s't|�}|du�r.d}||_|�p5d|_||_||_||_||_||_ ||_!||_"|	|_#||_$|
|_%||_||_&|
|_'||_(||_)||_*||_+||_,||_-||_.t/|�|_0t/|�|_1t/|�|_2||_3d|_4||_5t6|_7|�r�z|j8dddi|��Wn
t�y�||_4Ynw||_9||_|j
�|du�r�|�|�n||_Wd�n	1�s�wY|�s�|�:|j�|_;|dk�r�|j<|j*d�|�7�|_=|j=|_>dS)zsee tqdm.tqdm for argumentsN�encodingzutf-8)r~)�
tqdm_instance�isattyT�inf�nestedzQ`nested` is deprecated and automated.
Use `position` instead for manual control.
r�rOzUnknown argument(s): rFrdr6��	lock_argsr')?r�r�rr�rrZr�r�r�r��float�iterable�disabler(r!rrr)r�r��leaver r�rr-r�rrrr�r�r�r+�mininterval�maxintervalrw�dynamic_minitersr�r�r�r�rr��delayr*�
dynamic_ncolsr�r��_ema_dn�_ema_dt�
_ema_minitersrr�rsr	�_time�set_postfix�last_print_nr��spr6�last_print_tr3) r1r�r�r�r�r�r�r�r�rwr�r�r�r�r�r�rrrxr�r��write_bytesr�r+rsr�r*rC�_dynamic_ncols�_ncols�_nrowsr�r'r'r(r0�s�
�������� 
��








��

z
tqdm.__init__cCs0|jdur
|jdkS|jdurtd��t|j�S)Nrz/bool() undefined when iterable == total == None)r�r�r��boolrUr'r'r(�__bool__Qs




z
tqdm.__bool__cCs`|jdur|jSt|jd�r|jjdSt|jd�rt|j�St|jd�r*|j��St|dd�S)NrYr�__len__�__length_hint__r�)r�r�rZrYr�r�r�rUr'r'r(r�Xs����
�ztqdm.__len__cCsHzz|j}Wntytd��wt|j�|_|��W||_S||_w)Nz'tqdm' object is not reversible)r�r�r��reversed�__iter__)r1�origr'r'r(�__reversed__`s
�ztqdm.__reversed__cCs*t|jdd�}|dur||�S||��vS)N�__contains__)r�r�r�)r1�item�containsr'r'r(r�ksztqdm.__contains__cCs|Sr7r'rUr'r'r(rVosztqdm.__enter__cCsBz|��WdSty |||fdkr�tdtdd�YdSw)N)NNNzAttributeError ignoredr\r])r\r�r
r)r1�exc_type�	exc_value�	tracebackr'r'r(rYrs�z
tqdm.__exit__cCrTr7)r\rUr'r'r(�__del__{rWztqdm.__del__cCs|jdi|j��S)Nr')rrrUr'r'r(�__str__~sztqdm.__str__cCstt|dd��S)Nrl)r�r�rUr'r'r(�_comparable�sztqdm._comparablecCst|�Sr7)�idrUr'r'r(�__hash__�sz
tqdm.__hash__ccs��|j}|jr|D]}|Vq	dS|j}|j}|j}|j|j}|j}|j}z9|D],}|V|d7}|||j	krU|�}	|	|}
|
|krU|	|krU|�
||�|j}|j}q)W||_|��dS||_|��w)z6Backward-compatibility to use: for x in tqdm(iterable)Nr)r�r�r�r�r�r3r�r�r�rwr�r\)r1r��objr�r�r��min_start_tr�r	�cur_t�dtr'r'r(r��s:����
z
tqdm.__iter__rcCs6|jrdS|dkr|j|7_|j|7_|j|j|jkr�|��}||j}||jkr�||j|jkr�|��}|j|j}|j	rQ|rQ|rQ|�
|�|�|�|j|j
d�|jr�|jro||jkro||jpi|j||_n|j	r�|�||jr|r|j|nd�|_nt|j|�|_|j|_||_dSdSdSdS)ag
        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.
        Nrr�rT)r�r�r�rwr�r�r�r3r�r�r�r�r6r�r�r�r�rn)r1r�r�r��dnr'r'r(r��s<


���ztqdm.updatec
sN�jrdSd�_t�j�}�����j�j�jkrdSt�dd�dur'dS�fdd�}z|d�WntyM}zdt	|�vrHWYd}~dS�d}~ww�j
durW|dkn�j
}�j�@|rpd	d
��_�j
dd�|d�n�j
d|d
�r�|s�|d�Wd�dSWd�dSWd�dSWd�dS1s�wYdS)z3Cleanup and (if leave=False) close the progressbar.NTr�cs�j�t|��dSr7)r�r�r-r�rUr'r(r3sztqdm.close.<locals>.fp_writerd�closedrcSr�r7r'r'r'r'r(r�r�ztqdm.close.<locals>.<lambda>rr*)r2rr�)r�r�rr0r�r3r�r��
ValueErrorr-r�r(r��display)r1rr3rr�r'rUr(r\�sB

��


���"�z
tqdm.closecCsr|jrdS|s|j��t|j�}||jpdkr.|�|�|�d�|j�	d�|�|�|s7|j�
�dSdS)zClear current bar display.Nr"rdr�)r�r(rKr�rr+�movetor�r�r�rO)r1r'rr'r'r(r.s



�z
tqdm.clearcCsH|jrdS|s|r|jj|�sdSn|j��|��|s"|j��dS)a�
        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`.
        NFT)r�r(rKr�rO)r1r'r�r'r'r(r6-s
�

ztqdm.refreshcCs0|jrdS|��}|j||j7_||_dS)z(Restart tqdm timer from last print time.N)r�r�r3r�)r1r�r'r'r(�unpauseHs

ztqdm.unpausecCsdd|_|dur
||_|jrdSd|_|��|_|_t|j�|_	t|j�|_
t|j�|_|��dS)z�
        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.
        rN)
r�r�r�r�r�r�r3r�r�r�r�r�r6)r1r�r'r'r(�resetPs
z
tqdm.resetcCs&|r|dnd|_|r|��dSdS)z�
        Set/modify description of the progress bar.

        Parameters
        ----------
        desc  : str, optional
        refresh  : bool, optional
            Forces refresh [default: True].
        r+rdN�r�r6�r1r�r6r'r'r(�set_descriptionfs
�ztqdm.set_descriptioncCs|pd|_|r
|��dSdS)z-Set/modify description without ': ' appended.rdNr�r�r'r'r(�set_description_strts
�ztqdm.set_description_strcs�t|durgn|��t|���D]}||�|<q���D]"}t�|t�r0|��|��|<qt�|t�s?t�|��|<qd��fdd����D��|_|rW|�	�dSdS)a8
        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
        Nr~c3s$�|]
}|d�|��VqdS)�=N)�strip)rFr%�r�r'r(r{�s��z#tqdm.set_postfix.<locals>.<genexpr>)
r�sorted�keysrWrr�r-r�r�r6)r1�ordered_dictr6rCr%r'r�r(r�zs
�
��ztqdm.set_postfixcCst|�|_|r
|��dSdS)zS
        Postfix without dictionary expansion, similar to prefix handling.
        N)r-r�r6)r1r�r6r'r'r(�set_postfix_str�s
�ztqdm.set_postfix_strcCs4|j�d|t�|�t|jddd���dS)Nr*r�cSr�r7r'r'r'r'r(r��r�ztqdm.moveto.<locals>.<lambda>)r�r�rr�)r1r�r'r'r(r��sztqdm.movetocCs�|jrt|d�stdd�|j|jddd��S|jr#|�|j�\|_|_|j|jt|d�r3|�	�|j
nd|j|j|j|j|j
|j|��rL|��|��nd|j|j|j|j|jd	�S)
z'Public API for read-only member access.r�cSr�r7r'r'r'r'r(r��r�z"tqdm.format_dict.<locals>.<lambda>rr�)r�r�r�r�r3N)r�r�r�r�r+r�r�r�r�r�rr�r�rrs)r�rZrr�r�r�r�r�r+r�r3r�r�r�r�r�r�rr�r�rrsrUr'r'r(r�s��ztqdm.format_dictcCs�|dur	t|j�}|jp
d}||dkr"||krdS|s |dur"d}t|d�s4tdt|jdtjj	�d	��|r;|�
|�|�|durE|��n|�|rP|�
|�d
S)a�
        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)`).
        Nr"rFz ... (more hidden) ...r�zAPlease use `tqdm.gui.tqdm(...)` instead of `tqdm(..., gui=True)`
r�rOT)
r�rr+rZr r�r�r�r�r�r�r�r�)r1r2rr+r'r'r(r��s&


�
ztqdm.displaycks`�|dd|i|���}|rd|_d|_d|_t|j||�VWd�dS1s)wYdS)a�
        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
        r��BTiNr')r�r�r�rr�)rP�stream�methodr��bytesr_r�r'r'r(�wrapattr�s�"�z
tqdm.wrapattr)rdr�)NrdFr�FNNNr�rNr7)Nr*F)NF)NNNTNNr{r|NNFr�FFr�NrNNr�FNNNr}F)r)F)FN)NT)rdTr@)6r$r%r&r8rrrr�staticmethodr�r�r�r�rr
rar!r0r�rr1r8rrirr�ryr0r�r�r�r�rVrYr�r�r�r�r�r�r�r\r.r6r�r�r�r�r�r�r�rr�r�r'r'r'r(r�s�x


�G



9��	

&C
,







$rcOstt|�fi|��S)z*Shortcut for tqdm(range(*args), **kwargs).)rr�rQr'r'r(r�sr)5r8r��collectionsrr�
contextlibrrrr�numbersrr	rer
�weakrefr�_monitorr
�utilsrrrrrrrrrrrr�
__author__�__all__r�rr�r�Warningrrhr�DeprecationWarningr �RuntimeWarningr!rDrrErbr�rrr'r'r'r(�<module>sF	8	7S