HEX
Server: LiteSpeed
System: Linux osault1.hostarmada.net 4.18.0-553.123.2.lve.el8.x86_64 #1 SMP Thu May 7 23:17:13 UTC 2026 x86_64
User: tucom (1048)
PHP: 8.4.24
Disabled: NONE
$ pwd: /usr/local/lib/python3.6/site-packages/tqdm/__pycache__/
Upload Files
File: //usr/local/lib/python3.6/site-packages/tqdm/__pycache__/std.cpython-36.pyc
3

	LBj���@s�dZddlmZmZddlZddlmZmZddlm	Z	ddl
m
Z
mZddlm
Z
ddlmZdd	lmZdd
lmZddlmZdd
lmZmZmZmZmZmZmZmZmZmZm Z m!Z!m"Z"m#Z#m$Z$dZ%ddddddddgZ&Gdd�de'�Z(Gdd�de)�Z*Gdd�de+�Z,Gdd�de,e-�Z.Gdd�de,e/�Z0Gdd�de,e1�Z2dd�Z3Gdd �d e4�Z5Gd!d"�d"e4�Z6Gd#d$�d$e4�Z7Gd%d�de�Z8d&d�Z9dS)'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):
...     ...
�)�absolute_import�divisionN)�OrderedDict�defaultdict)�contextmanager)�datetime�	timedelta)�Number)�time)�warn)�WeakSet�)�TMonitor)�CallbackIOWrapper�
Comparable�DisableOnWriteError�
FormatReplace�SimpleTextIOWrapper�_basestring�	_is_ascii�_range�_screen_shape_wrapper�_supports_unicode�
_term_move_up�_unich�_unicode�disp_len�	disp_trimz*https://github.com/tqdm/tqdm#contributions�tqdm�trange�
TqdmTypeError�TqdmKeyError�TqdmWarning�TqdmExperimentalWarning�TqdmDeprecationWarning�TqdmMonitorWarningc@seZdZdS)r N)�__name__�
__module__�__qualname__�r)r)�(/tmp/pip-build-44150kxb/tqdm/tqdm/std.pyr "sc@seZdZdS)r!N)r&r'r(r)r)r)r*r!&scs"eZdZdZd�fdd�	Z�ZS)r"zqbase class for all tqdm warnings.

    Used for non-external-code-breaking errors, such as garbled printing.
    NcsJ|dk	r.|d|jjdt|�j�d�ntt|�j|f|�|�dS)N�
z: )�	__class__r&�str�rstrip�superr"�__init__)�self�msg�fp_write�a�k)r,r)r*r0/s&zTqdmWarning.__init__)N)r&r'r(�__doc__r0�
__classcell__r)r))r,r*r"*sc@seZdZdZdS)r#z(beta feature, unstable API and behaviourN)r&r'r(r6r)r)r)r*r#6sc@seZdZdS)r$N)r&r'r(r)r)r)r*r$;sc@seZdZdZdS)r%z>tqdm monitor errors which do not affect external functionalityN)r&r'r(r6r)r)r)r*r%@scOs4yddlm}|||�Sttfk
r.YnXdS)zthreading RLockr)�RLockN)�	threadingr8�ImportError�OSError)�args�kwargsr8r)r)r*�TRLockEs

r>c@sVeZdZdZe�Zdd�Zdd�Zdd�Zdd	�Z	d
d�Z
edd
��Zedd��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.
    cCsRt|�}|j}|dk	r|j�|j�dd�|j|jgD�|_|dk	rN|j�dS)NcSsg|]}|dk	r|�qS)Nr))�.0Zlkr)r)r*�
<listcomp>dsz1TqdmDefaultWriteLock.__init__.<locals>.<listcomp>)�type�th_lock�acquire�create_mp_lock�mp_lock�locks�release)r1�clsZ	root_lockr)r)r*r0\szTqdmDefaultWriteLock.__init__cOs x|jD]}|j||�qWdS)N)rGrD)r1r4r5�lockr)r)r*rDhszTqdmDefaultWriteLock.acquirecCs&x |jddd�D]}|j�qWdS)Nr
���)rGrH)r1rJr)r)r*rHlszTqdmDefaultWriteLock.releasecCs|j�dS)N)rD)r1r)r)r*�	__enter__pszTqdmDefaultWriteLock.__enter__cGs|j�dS)N)rH)r1�excr)r)r*�__exit__sszTqdmDefaultWriteLock.__exit__cCsFt|d�sByddlm}|�|_Wnttfk
r@d|_YnXdS)NrFr)r8)�hasattr�multiprocessingr8rFr:r;)rIr8r)r)r*rEvs
z#TqdmDefaultWriteLock.create_mp_lockcCs t|d�st�tdtdd�dS)NrCz!create_th_lock not needed anymore�)�
stacklevel)rO�AssertionErrorrr$)rIr)r)r*�create_th_locksz#TqdmDefaultWriteLock.create_th_lockN)r&r'r(r6r>rCr0rDrHrLrN�classmethodrErTr)r)r)r*r?Ns	r?c	@s�eZdZdZdZddjeeeddd���Z	dZ
d	Zd
Zddd
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�%r
z  zz[38;2;%d;%d;%dmzzzzzzzz)�BLACK�RED�GREEN�YELLOW�BLUE�MAGENTA�CYAN�WHITE�
NcCs^d|kodkns6tdtdd�tdtd|��}|dksBt�||_||_||_||_dS)Nrr
zclamping frac to range [0, 1]rQ)rR)	rr"�max�minrS�frac�default_len�charset�colour)r1rdrerfrgr)r)r*r0�szBar.__init__cCs|jS)N)�_colour)r1r)r)r*rg�sz
Bar.colourcCs�|sd|_dSyz|j�|jkr0|j|j�|_nV|ddkr�t|�dkr�|jtdd�|dd�|dd�|dd�fD��|_nt�Wn<ttfk
r�td	|d
j	|j�ft
dd�d|_YnXdS)
Nr�#�css|]}t|d�VqdS)�N)�int)r@�ir)r)r*�	<genexpr>�szBar.colour.<locals>.<genexpr>r
��z7Unknown colour (%s); valid choices: [hex (#00ff00), %s]z, rQ)rR)rh�upper�COLOURS�len�
COLOUR_RGB�tuple�KeyError�AttributeErrorr�joinr")r1�valuer)r)r*rg�s4
c	Cs�|rz|dj�}y|j|j|jd�|}Wntk
rD|j}YnX|dd�}|rrt|�}|dkrx||j7}q�|j}n|j}|j}t|�d}t	t|j
||�|�\}}|d|}||kr�||||d||d}|jr�|j||jS|S)Nr
)r4�u�brrKrKrK)
�lower�ASCII�UTF�BLANKrvrfrlrers�divmodrdrg�COLOUR_RESET)	r1�format_spec�_typerfZN_BARSZnsymsZ
bar_lengthZfrac_bar_length�resr)r)r*�
__format__�s( zBar.__format__rK)r&r'r(r6r}rx�mapr�ranger~rr�rtrrr0�propertyrg�setterr�r)r)r)r*rV�s

rVc@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�szEMA.__init__NcCsVd|j}|dk	r6|j|||j|_|jd7_|jrP|jd||jS|jS)zk
        Parameters
        ----------
        x  : float
            New value to include in EMA.
        r
N)r�r�r�)r1�x�betar)r)r*�__call__�s

zEMA.__call__)r�)N)r&r'r(r6r0r�r)r)r)r*r��s
r�c@s�eZdZdZdZdZe�Zed_dd��Z	edd	��Z
ed
d��Zedd
��Zed`dd��Z
dd�Zedadd��Zedd��Zedbdd��Zeedcdd���Zedd��Zed d!��Zed"d#��Zddd(d)�Zd*d+�Zd,d-�Zd.d/�Zd0d1�Zd2d3�Zd4d5�Zd6d7�Zd8d9�Z d:d;�Z!e"d<d=��Z#d>d?�Z$d@dA�Z%dedCdD�Z&dEdF�Z'dfdGdH�Z(dgdIdJ�Z)dKdL�Z*dhdMdN�Z+didOdP�Z,djdQdR�Z-dkdSdT�Z.dldUdV�Z/dWdX�Z0e"dYdZ��Z1dmd[d\�Z2eednd]d^���Z3dS)orz�
    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.
    raNrX��cCs~xndD]f}t|�d	krdt|�d
krRt|�dkr@dj|�||Sd
j|�||Sdj|�||S||}qWdj|�|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.
        rXr5�M�G�T�P�E�Zg<�@g�����X@g=
ףp�#@z{0:1.2f}z{0:2.1f}z{0:3.0f}z	{0:3.1f}Y)rXr5r�r�r�r�r�r�)�abs�format)�num�suffix�divisor�unitr)r)r*�
format_sizeofs
ztqdm.format_sizeofcCsBtt|�d�\}}t|d�\}}|r2dj|||�Sdj||�SdS)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
        �<z{0:d}:{1:02d}:{2:02d}z{0:02d}:{1:02d}N)r�rlr�)�tZmins�s�h�mr)r)r*�format_interval s
ztqdm.format_intervalcCs:dj|�jdd�jdd�}t|�}t|�t|�kr6|S|S)z�
        Intelligent scientific notation (.3g).

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

        Returns
        -------
        out  : str
            Formatted number.
        z{0:.3g}z+0�+z-0�-)r��replacer-rs)�n�fr)r)r*�
format_num6sztqdm.format_numcsr|�t�ddd����tjtjfkrLttjddd���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).
        �flushcSsdS)Nr)r)r)r)r*�<lambda>Qsz%tqdm.status_printer.<locals>.<lambda>cSsdS)Nr)r)r)r)r*r�SscSsdS)Nr)r)r)r)r*r�Tscs�jt|����dS)N)�writer)r�)�fp�fp_flushr)r*r3Vsz%tqdm.status_printer.<locals>.fp_writercs6t|�}�d|dt�d|d��|�d<dS)N�
rWr)rrb)r�Zlen_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_printerIsztqdm.status_printerF�itrc#*Ks�|r||dkrd}|rD|dkrD|r,||9}||9}|r@||9}d}tj|�}|dkrf|rf|||}|rrd|nd}tj}|r�|r�||�q�dj|�nd|d}|r�|r�||�q�dj|�ndd	|}|r�|dkr�|n|}|�r
|||d
�}|dk	�r|||d
�nd}nt|�}|dk	�r$t|�nd}y|
�r8d|
nd}
Wntk
�rTYnX|�rn|�rn|||nd
}|�r�tj|�nd}y,|�r�|�r�tj�t|d�ntj	d
�}Wnt
k
�r�tj}YnX|�r�|d d�dk}|�r�|n|d}nd}dj||||||
�}tf||||||||�p,d||�rB|dk�rB|n|||||||
||
|||||d�|��}|�r�||}|d}|dj|�7}|d
k�r�|dd!�|dd�S|j
|d�|	�r�|j
|d�|�s�|	jdd�}	nd}	t�} y|	jfd| i|��}!Wn2tk
�r6t|	�}	|	jfd| i|��}!YnX| j�sD|!St||�r`td|t|!��nd|dk�rrtjn
|�p|tj|
d�} t| j��r�t|	��r�t|	�}	|	jfd| i|��}"|�r�t|"|�S|"S|	�r`|d7}|j
|d
d�t�} |	jfd| i|��}!| j�s|!Std
|�r*td|t|!��ndtj|
d�} |	jfd| i|��}"|�r\t|"|�S|"Sdj|�rr|dnd|||||
�SdS)"a�
        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�?NTr
Fz{0:5.2f}�?z/szs/)r�z, rXr)�secondsrQz: z| {0}/{1} [{2}<{3}, {4}{5}])r��n_fmt�total�	total_fmt�elapsedZ	elapsed_s�ncols�descr��rate�rate_fmtZ
rate_noinv�rate_noinv_fmtZrate_inv�rate_inv_fmt�postfix�unit_divisorrg�	remainingZremaining_s�l_bar�r_bar�eta�dz
{0:3.0f}%|)r�)�
percentagez{desc}: z{l_bar}{bar}{r_bar}�barra)rfrg�|)r�r�z{0}{1}{2} [{3}, {4}{5}])Tr
���rK)rr�r�r�r-�	TypeErrorr�nowr�utcfromtimestamp�
OverflowErrorrb�dict�updater�r�UnicodeEncodeErrorrZ
format_calledrVrr}r~rrfrr)#r�r�r�r��prefix�asciir��
unit_scaler��
bar_formatr�r��initialrg�extra_kwargsZelapsed_strZinv_rater�r�r�r�r�r�r�Z
remaining_strZeta_dtZbool_prefix_colon_alreadyr�r��format_dictrdr�Zfull_barZnobarr�r)r)r*�format_metercs�F
&&,

ztqdm.format_metercOs�tj|�}|j���|jj|�|jr�|jdks<|jj�r�yt||j�|_Wn>t	k
r�}z"t
dt|�tdd�d|_WYdd}~XnXWdQRX|S)Nz>tqdm:disabling monitor support (monitor_interval = 0) due to:
rQ)rRr)
�object�__new__�get_lock�
_instances�add�monitor_interval�monitor�reportr�	Exceptionrr-r%)rI�_�__�instance�er)r)r*r�0s


"ztqdm.__new__cs2�fdd�|jD�}tttt|�d��j|��S)zSkips specified instance.cs(h|] }|�k	rt|d�rt|j��qS)�pos)rOr�r�)r@�inst)r�r)r*�	<setcomp>Csz%tqdm._get_free_pos.<locals>.<setcomp>r
)r�rc�setr�rs�
difference)rIr�Z	positionsr))r�r*�
_get_free_pos@sztqdm._get_free_poscs�|j��y|jj|�Wntk
r,YnX|js�|jp<dd�tt�fdd�|j��}|r�t|dd�d�}|j	dd�t
|j�|_Wd	QRXd	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.)
        �r
cst|d�o�|jkS)Nr�)rOr�)rm)r�r)r*r�]sz&tqdm._decr_instances.<locals>.<lambda>cSs|jS)N)r�)rmr)r)r*r�as)�keyT)�nolockN)�_lockr��removerv�gui�nrows�list�filterrc�clearr�r�)rIr�Z	instancesr�r))r�r*�_decr_instancesGs


ztqdm._decr_instancesr+c	CsD|dk	r|ntj}|j||d��|j|�|j|�WdQRXdS)z5Print a message via tqdm (without overlap with bars).N)r�r�)r�r��external_write_moder�)rIr�r��endr�r�r)r)r*r�es
z
tqdm.writeccs�|dk	r|ntj}z�|s$|j�j�g}xVt|dg�D]F}t|d�r6|j|ksftdd�||jfD��r6|jdd�|j	|�q6WdVx|D]}|j
dd�q�WWd|s�|jj�XdS)z�
        Disable tqdm within context and refresh tqdm when exits.
        Useful when writing to standard output stream
        Nr��start_tcss|]}|tjtjfkVqdS)N)r�r�r�)r@r�r)r)r*rn�sz+tqdm.external_write_mode.<locals>.<genexpr>T)r�)
r�r�r�rDr�rOr��allr��append�refreshr�rH)rIr�r�r�Zinst_clearedr�r)r)r*rns
ztqdm.external_write_modecCs
||_dS)zSet the global lock.N)r�)rIrJr)r)r*�set_lock�sz
tqdm.set_lockcCst|d�st�|_|jS)z7Get the global lock. Construct it if it does not exist.r�)rOr?r�)rIr)r)r*r��s
z
tqdm.get_lockc
Ks�ddlm}m}ddlm}ddlm�y.|��|dtd�ddlm	}WdQRXWnt
k
rnd}YnXd\}}ydd	lm�Wn|t
k
�rydd	l
m�WnTt
k
�r�y$dd
lm}ddlm}||f�Wnt
k
r�d�YnXYnXYnXyddlm}dd
lm}	WnRt
k
�rtyddlm}	m}Wn&t
k
�rnddlm}	m}YnXYnXyddlm}
Wn"t
k
�r�ddlm}
YnXyddlm}WnBt
k
�r�yddlm}Wnt
k
�r�d}YnXYnX�j���jdd�g�d�����fdd�	}|��_|�|_|d��_|d�|_|�|_|�|	_|d�|_|dk	�rz|�|_|dk	�r�|�|_|�|
_|d�|
_|d�|
_|dk	�r�|dk	�r�|�|_|�|_n�dk	�r�|��_dS)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)�_Rolling_and_Expanding)�	Expanding)�Rolling)�
SeriesGroupBy)�DataFrameGroupBy)rr)�GroupBy)�PanelGroupBy�deprecated_t�applycs������fdd�}|S)Ncsb�jdt|dd��}|dkr��dkr,|j}n^t|��r@t|�}nJ�dksTt|��r�|jdd�}|dkrnd}n|dkrzd	}|j|j|}�ddk	r��d�d�d<n�fd|i����t|�dkr�tdt�jdt	j
j�d�yddlm
}Wntk
�r|j}YnXy|���Wntk
�r0YnX��fdd�}zt|��|f|�S�j�XdS)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�ZngroupsN�applymap�axisr�index�columnsr
z/Except func, normal arguments are intentionallyz not supported byz- `(DataFrame|Series|GroupBy).progress_apply`.z Use keyword arguments instead.r�)r3)�is_builtin_funccs.�j�js�j�jkrdndd��||�S)Nr
r)r�)r�r�r�)r<r=)�funcr�r)r*�wrapper#s$zDtqdm.pandas.<locals>.inner_generator.<locals>.inner.<locals>.wrapperz@Except func, normal arguments are intentionally not supported byzmExcept func, normal arguments are intentionally not supported by `(DataFrame|Series|GroupBy).progress_apply`.z�Except func, normal arguments are intentionally not supported by `(DataFrame|Series|GroupBy).progress_apply`. Use keyword arguments instead.)�popr��size�
isinstancers�get�shaper$r�r�r�r�Zpandas.core.commonrr:Z_is_builtin_funcr��close)Zdfrr<r=r�rrr)r
rrIr�df_function�tqdm_kwargs)rr�r*�inner�sF




z3tqdm.pandas.<locals>.inner_generator.<locals>.innerr))r$r&)r
rrIrr%)r$r*�inner_generator�sGz$tqdm.pandas.<locals>.inner_generatorr�rZ	aggregateZ	transform)NN)r)�warningsrrZpandas.core.framer	Zpandas.core.seriesr
�
FutureWarning�pandasr
r:Zpandas.core.window.rollingrZpandas.core.windowZpandas.core.window.expandingrrZpandas.core.groupby.genericrrZpandas.core.groupby.groupbyZpandas.core.groupbyrr�copyrZprogress_applyZprogress_mapZprogress_applymapZprogress_aggregateZprogress_transform)
rIr%rrr	r
rrrrrrr'r))r
rrIrr%r*r*�s~#
L








ztqdm.pandasT皙�����?�$@�333333�?c (Ks�|dkr|dkotjdk}|dkr(tj}|rDt|t|dd�p>dd�}t||d�}|dkrpt|d�rp|j�rpd}|dkr�|dk	r�yt|�}Wnt	t
fk
r�d}YnX|td	�kr�d}|�r||_||_
|j�|j|�|_|jj|�WdQRX||_||_||_dS|�rtd|_
|j�|j|�|_|jj|�WdQRXd
|k�rdtdt|dtjj�d
�ntdt|���|dk�s�|dk�r�|tjtjfk�s�|�r�|�r�t�}|�r�||�\}}n4t�}|�r�||�\}}|dk�r�|}|dk�r�|}|	dk�rd}	d}nd}|dk�rd}|dk�r(d}|
dk�r<t|�}
|�r`|
dk	�r`t|
��r`t|�}|dk�rnd}||_|�p|d|_||_||_||_ ||_!||_"||_#||_$|	|_%||_&|
|_'||_
||_(|
|_)||_*||_+||_,||_-||_.||_/||_0t1|�|_2t1|�|_3t1|�|_4||_5d|_6||_7t8|_9|�rjy|j:fddi|��Wnt	k
�rh||_6YnX||_;||_|j�"|dk�r�|j|�n||_WdQRX|�s�|j<|j �|_=|dk�r�|j>|j,d�|j9�|_?|j?|_@dS)a�
        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
            If (default: None) and `file` is unspecified,
            bytes will be written in Python 2. If `True` will also write
            bytes. In all other cases will default to 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.
        Nro�encodingzutf-8)r/)Z
tqdm_instance�isattyT�inf�nestedzQ`nested` is deprecated and automated.
Use `position` instead for manual control.
r�)r3zUnknown argument(s): rFrXr)�	lock_args)ro)Ar��version_infor�rr�rrOr0rsr�rw�float�iterable�disabler�r�r�r�r�r�r��leaver$r�r!r-r�rrrrr�r�r�r��mininterval�maxinterval�miniters�dynamic_minitersr�r�r�r�r�r3�delayr��
dynamic_ncolsr�r��_ema_dn�_ema_dt�
_ema_minitersr�r�rgr
�_time�set_postfix�last_print_nr��spr�last_print_tr) r1r6r�r�r8r�r�r9r:r;r�r7r�r�r>r�r�r��positionr�r��write_bytesr3r�rgr=r�r=Z_dynamic_ncolsZ_ncolsZ_nrowsr<r)r)r*r0Ns�|
"&










&

z
tqdm.__init__cCs0|jdk	r|jdkS|jdkr&td��t|j�S)Nrz/bool() undefined when iterable == total == None)r�r6r��bool)r1r)r)r*�__bool__\s



z
tqdm.__bool__cCs|j�S)N)rJ)r1r)r)r*�__nonzero__csztqdm.__nonzero__cCs`|jdkr|jSt|jd�r(|jjdSt|jd�r>t|j�St|jd�rT|jj�St|dd�S)Nr"r�__len__�__length_hint__r�)r6r�rOr"rsrMr�)r1r)r)r*rLfs
ztqdm.__len__cCsNz@y
|j}Wntk
r(td��YnXt|j�|_|j�SWd||_XdS)Nz'tqdm' object is not reversible)r6rwr��reversed�__iter__)r1�origr)r)r*�__reversed__ns
ztqdm.__reversed__cCs*t|jdd�}|dk	r||�S||j�kS)N�__contains__)r�r6rO)r1�item�containsr)r)r*rRysztqdm.__contains__cCs|S)Nr))r1r)r)r*rL}sztqdm.__enter__cCsDy|j�Wn2tk
r>|||fdkr,�tdtdd�YnXdS)NzAttributeError ignoredrQ)rR)NNN)r#rwrr")r1�exc_type�	exc_value�	tracebackr)r)r*rN�sz
tqdm.__exit__cCs|j�dS)N)r#)r1r)r)r*�__del__�sztqdm.__del__cCs|jf|j�S)N)r�r�)r1r)r)r*�__str__�sztqdm.__str__cCstt|dd��S)Nr�r
�l)r�r�)r1r)r)r*�_comparable�sztqdm._comparablecCst|�S)N)�id)r1r)r)r*�__hash__�sz
tqdm.__hash__ccs�|j}|jr$x|D]
}|VqWdS|j}|j}|j}|j|j}|j}|j}zfx`|D]X}|V|d7}|||j	krV|�}	|	|}
|
|krV|	|krV|j
||�|j}|j}qVWWd||_|j�XdS)z6Backward-compatibility to use: for x in tqdm(iterable)Nr
)r6r7r9rFrDrr=r�rBr;r�r#)r1r6�objr9rFrDZmin_start_tr�r
�cur_t�dtr)r)r*rO�s0


z
tqdm.__iter__r
cCs8|jr
dS|dkr |j|7_|j|7_|j|j|jk�r4|j�}||j}||jkol||j|jk�r4|j�}|j|j}|j	r�|r�|r�|j
|�|j|�|j|j
d�|j�r"|jr�||jkr�||jp�|j||_n>|j	�r|j||jo�|�r|j|nd�|_nt|j|�|_|j|_||_dSdS)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.
        Nr)r3r
T)r7rDr�r;rBrFr9rr=r�r?r@rr3r<r:rArb)r1r�r_r`�dnr)r)r*r��s4


ztqdm.updatecs
�jr
dSd�_t�j�}�j���j�j�jkr:dSt�dd�dkrNdS�fdd�}y|d�Wn4tk
r�}zdt	|�kr�dS�WYdd}~XnX�j
dkr�|dkn�j
}�j�F|r�d	d
��_�j
dd�|d�n�j
d|d
�r�|r�|d�WdQRXdS)z3Cleanup and (if leave=False) close the progressbar.NTrEcs�jjt|��dS)N)r�r�r)r�)r1r)r*r3sztqdm.close.<locals>.fp_writerX�closedrcSsdS)Nr)r)r)r)r*r�#sztqdm.close.<locals>.<lambda>)r�r+)r2r�r�)r7r�r�r�rFrr=r��
ValueErrorr-r8r�r@�display)r1r�r3r�r8r))r1r*r#�s0



z
tqdm.closecCsn|jr
dS|s|jj�t|j�}||jp,dkr\|j|�|jd�|jj	d�|j|�|sj|jj
�dS)zClear current bar display.Nr�rXr�)r7r�rDr�r�r��movetorEr�r�rH)r1r�r�r)r)r*r�+s



z
tqdm.clearcCsH|jr
dS|s.|r$|jj|�s.dSn
|jj�|j�|sD|jj�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)r7r�rDrdrH)r1r�r3r)r)r*r;s


ztqdm.refreshcCs0|jr
dS|j�}|j||j7_||_dS)z(Restart tqdm timer from last print time.N)r7rBrrF)r1r_r)r)r*�unpauseVs
ztqdm.unpausecCsdd|_|dk	r||_|jrdSd|_|j�|_|_t|j�|_	t|j�|_
t|j�|_|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�r7rDrBrFrr�r�r?r@rAr)r1r�r)r)r*�reset^s
z
tqdm.resetcCs"|r|dnd|_|r|j�dS)z�
        Set/modify description of the progress bar.

        Parameters
        ----------
        desc  : str, optional
        refresh  : bool, optional
            Forces refresh [default: True].
        z: rXN)r�r)r1r�rr)r)r*�set_descriptionts
ztqdm.set_descriptioncCs|pd|_|r|j�dS)z-Set/modify description without ': ' appended.rXN)r�r)r1r�rr)r)r*�set_description_str�s
ztqdm.set_description_strcs�t|dkrgn|��x t|j��D]}||�|<q"WxP�j�D]D}t�|t�rf|j�|��|<q@t�|t�s@t�|��|<q@Wdj�fdd��j�D��|_	|r�|j
�dS)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
        Nz, c3s"|]}|d�|j�VqdS)�=N)�strip)r@r�)r�r)r*rn�sz#tqdm.set_postfix.<locals>.<genexpr>)r�sorted�keysr r	r�rr-rxr�r)r1Zordered_dictrr=r�r))r�r*rC�s
ztqdm.set_postfixcCst|�|_|r|j�dS)zS
        Postfix without dictionary expansion, similar to prefix handling.
        N)r-r�r)r1r�rr)r)r*�set_postfix_str�s
ztqdm.set_postfix_strcCs8|jjtd|t�|��t|jddd���dS)Nr+r�cSsdS)Nr)r)r)r)r*r��sztqdm.moveto.<locals>.<lambda>)r�r�rrr�)r1r�r)r)r*re�s ztqdm.movetocCs�|jr.t|d�r.tdd�|j|jddd��S|jrH|j|j�\|_|_|j|jt|d�rh|j	�|j
nd|j|j|j|j|j
|j|j�r�|j�|j�nd|j|j|j|j|jd	�S)
z'Public API for read-only member access.r�cSsdS)Nr)r)r)r)r*r��sz"tqdm.format_dict.<locals>.<lambda>rr�)r�r�r�r�rN)r�r�r�r�r�r�r�r�r�r�r�r�r�r�rg)r7rOrr�r�r>r�r�r�rBrr�r�r�r�r@r?r�r�r�r�rg)r1r)r)r*r��sztqdm.format_dictcCs�|dkrt|j�}|jpd}||dkrD||kr4dS|s@|dkrDd}t|d�shtdt|jdtjj	�d	��|rv|j
|�|j|dkr�|j�n|�|r�|j
|�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�r
Fz ... (more hidden) ...rEzAPlease use `tqdm.gui.tqdm(...)` instead of `tqdm(..., gui=True)`
r�)r3T)
r�r�r�rOr$r�r�r�r�r�rerErY)r1r2r�r�r)r)r*rd�s$




ztqdm.displaycksH|fd|i|���,}|r*d|_d|_d|_t|j||�VWdQRXdS)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��BTiN)r�r�r�rr�)rI�stream�methodr��bytesr%r�r)r)r*�wrapattr�sz
tqdm.wrapattr)rXr�)NrXFr�FNNNr�rN)N)Nr+F)NF)NNNTNNr,r-NNFr�FFr.NrNNr�NNNNrF)r
)F)FN)N)NT)NT)NT)rXT)NN)NT)4r&r'r(r6r�r�rr��staticmethodr�r�r�r�r�r�rUr�r�r�rrrr�r*r0rJrKrLrQrRrLrNrXrYr�r[r]rOr�r#r�rrfrgrhrirCrnrer�rdrsr)r)r)r*r�s~K7
	&
C,







$cOstt|�f|�S)zh
    A shortcut for tqdm(xrange(*args), **kwargs).
    On Python3+ range is used instead of xrange.
    )rr)r<r=r)r)r*rs):r6�
__future__rrr��collectionsrr�
contextlibrrrZnumbersr	r
r(r�weakrefr�_monitorr�utilsrrrrrrrrrrrrrrr�
__author__�__all__r�r rvr!�Warningr"r)r#�DeprecationWarningr$�RuntimeWarningr%r>r�r?rVr�rrr)r)r)r*�<module>	sLD	7S
@ Telegram