a
    |Ä#d¼é  ã                   @   s  d dl Z d dlZd dlZd dlZd dlmZmZ d dlmZ d dl	m
Z
 d dlmZmZ d dlmZ d dl mZmZ d dlmZ d d	lmZ d d
lmZmZ d dlmZmZmZ d dlmZ d dlmZmZm Z m!Z!m"Z"m#Z#m$Z$m%Z%m&Z&m'Z'm(Z(m)Z)m*Z*m+Z+m,Z,m-Z-m.Z.m/Z/ ej0dk�r&d dlm1Z1 nd dl2m1Z1 ddl3m4Z4m5Z5 ddl6m7Z7m8Z8m9Z9m:Z: ddl;m<Z< ddl=m>Z> ddl?m@Z@ ddlAmBZB ddlCmDZD ddlEmFZF ddlGmHZHmIZI ddlJmKZKmLZL e(deMƒZNe.dƒZOe g ePf ZQe .de+e¡ZRG dd„ deƒZSd„e/e*eO e%eO f eTe)eP eUe)e7 eUe)e g ePf  ePeFeFeFeFePeUeUe%eO d)œd*d+„ZVG d,d-„ d-eeƒZWG d.d/„ d/e!eR e$eR ƒZXd0d!dd"dd#d$d%d&d'd"d1œeeMeTeUe)e7 eUe)e g ePf  ePeFeFeFeFeUe!e d2œd3d4„ZYejZd…dd0d!dd"dd#d$d%d&d'd"d6œe/eTd7e[f e/e1d8 e1d9 f eMe)eT e)eT e)eT e)eM eTeUe)e7 eUe)e g ePf  ePeFeFeFeFeUe!e+ d:œd;d<„ƒZ\ejZd†dd0d!dd"dd#d$d%d&d'd"d6œe/eTd7e[f e1d= eMe)eT e)eT e)eT e)eM eTeUe)e7 eUe)e g ePf  ePeFeFeFeFeUe!e d:œd>d<„ƒZ\d‡dd0d!dd"dd#d$d%d&d'd"d6œe/eTd7e[f e/e1d= e1d8 e1d9 f eMe)eT e)eT e)eT e)eM eTeUe)e7 eUe)e g ePf  ePeFeFeFeFeUe/e!e e!e+ f d:œd?d<„Z\G d@dA„ dAeƒZ]G dBdC„ dCe]ƒZ^G dDdE„ dEe]ƒZ_G dFdG„ dGe]ƒZ`G dHdI„ dIe]ƒZaG dJdK„ dKe]ƒZbG dLdM„ dMe`ƒZcG dNdO„ dOe]ƒZdG dPdQ„ dQe]ƒZeG dRdS„ dSe]ƒZfG dTdU„ dUe]ƒZgG dVdW„ dWe]ƒZhG dXdY„ dYe]ƒZiG dZd[„ d[e'ƒZjeG d\d]„ d]ƒƒZkG d^d_„ d_e>ƒZlemd`k�r
d dlnZnd dloZoddalpmqZq ddblrmsZs ddcltmuZu dddlGmIZI eudedfd!dg�ZteIdhdidjƒZGeG vdkdldm¡ dneqdoƒdpeGdqdrdsdtœduetesdvƒg	Zwd dwlxmyZy eyewƒZze7d!dx�Z6ele_ƒ gel {¡ ¢ebƒ ‘R e6d"dyœŽ�ŒZ|e|j}dzd{d|�Z~e|j}d}d{d|�Ze|j}d~dd|�Z€e|j��sêe|j‚e~dd€� e|j‚ed�d€� eo ƒd‚¡ en „d dƒ¡dk �r˜e| …e†ezƒ¡ �q˜W d  ƒ n1 �s 0    Y  dS )ˆé    N)ÚABCÚabstractmethod©Údeque)ÚSized)Ú	dataclassÚfield)Ú	timedelta)Ú	RawIOBaseÚUnsupportedOperation)Úceil)Úmmap)ÚPathLikeÚstat)ÚEventÚRLockÚThread)ÚTracebackType)ÚAnyÚBinaryIOÚCallableÚContextManagerÚDequeÚDictÚGenericÚIterableÚListÚ
NamedTupleÚNewTypeÚOptionalÚSequenceÚTextIOÚTupleÚTypeÚTypeVarÚUnion)é   é   )ÚLiteralé   )ÚfilesizeÚget_console)ÚConsoleÚGroupÚJustifyMethodÚRenderableType)ÚHighlighter)ÚJupyterMixin)ÚLive)ÚProgressBar)ÚSpinner)Ú	StyleType)ÚColumnÚTable)ÚTextÚTextTypeÚTaskIDÚProgressTypeÚ_Ic                       sj   e Zd ZdZddedœ‡ fdd„Zddœd	d
„Zd dœdd„Zee	e
  ee
 ee ddœdd„Z‡  ZS )Ú_TrackThreadz)A thread to periodically update progress.ÚProgressr:   )ÚprogressÚtask_idÚupdate_periodc                    s.   || _ || _|| _tƒ | _d| _tƒ  ¡  d S )Nr   )r?   r@   rA   r   ÚdoneÚ	completedÚsuperÚ__init__)Úselfr?   r@   rA   ©Ú	__class__© úP/var/www/html/gsl.tools/lib/python3.9/site-packages/pip/_vendor/rich/progress.pyrE   B   s    z_TrackThread.__init__N©Úreturnc                 C   sd   | j }| jj}| j}d}| jj}||ƒsJ| j}||kr |||| ƒ |}q | jj| j | jdd� d S )Nr   T)rC   Úrefresh)r@   r?   ÚadvancerA   rB   ÚwaitrC   Úupdate)rF   r@   rN   rA   Úlast_completedrO   rC   rI   rI   rJ   ÚrunK   s    z_TrackThread.runc                 C   s   |   ¡  | S ©N©Ústart©rF   rI   rI   rJ   Ú	__enter__Y   s    z_TrackThread.__enter__©Úexc_typeÚexc_valÚexc_tbrL   c                 C   s   | j  ¡  |  ¡  d S rS   )rB   ÚsetÚjoin©rF   rY   rZ   r[   rI   rI   rJ   Ú__exit__]   s    
z_TrackThread.__exit__)Ú__name__Ú
__module__Ú__qualname__Ú__doc__ÚfloatrE   rR   rW   r   r#   ÚBaseExceptionr   r_   Ú__classcell__rI   rI   rG   rJ   r=   ?   s   	
ûr=   ú
Working...TFé
   úbar.backúbar.completeúbar.finishedú	bar.pulseçš™™™™™¹?)ÚsequenceÚdescriptionÚtotalÚauto_refreshÚconsoleÚ	transientÚget_timeÚrefresh_per_secondÚstyleÚcomplete_styleÚfinished_styleÚpulse_stylerA   ÚdisableÚ
show_speedrL   c              	   c   s’   |rt dƒgng }| t||	|
|d�t|d�tƒ f¡ t||||||pHd|dœŽ}|�( |j| |||d�E dH  W d  ƒ n1 s„0    Y  dS )aé  Track progress by iterating over a sequence.

    Args:
        sequence (Iterable[ProgressType]): A sequence (must support "len") you wish to iterate over.
        description (str, optional): Description of task show next to progress bar. Defaults to "Working".
        total: (float, optional): Total number of steps. Default is len(sequence).
        auto_refresh (bool, optional): Automatic refresh, disable to force a refresh after each iteration. Default is True.
        transient: (bool, optional): Clear the progress on exit. Defaults to False.
        console (Console, optional): Console to write to. Default creates internal Console instance.
        refresh_per_second (float): Number of times per second to refresh the progress information. Defaults to 10.
        style (StyleType, optional): Style for the bar background. Defaults to "bar.back".
        complete_style (StyleType, optional): Style for the completed bar. Defaults to "bar.complete".
        finished_style (StyleType, optional): Style for a finished bar. Defaults to "bar.finished".
        pulse_style (StyleType, optional): Style for pulsing bars. Defaults to "bar.pulse".
        update_period (float, optional): Minimum time (in seconds) between calls to update(). Defaults to 0.1.
        disable (bool, optional): Disable display of progress.
        show_speed (bool, optional): Show speed if total isn't known. Defaults to True.
    Returns:
        Iterable[ProgressType]: An iterable of the values in the sequence.

    ú([progress.description]{task.description}©rv   rw   rx   ry   )r{   rh   ©rq   rr   rs   rt   ru   rz   )rp   ro   rA   N)Ú
TextColumnÚextendÚ	BarColumnÚTaskProgressColumnÚTimeRemainingColumnr>   Útrack)rn   ro   rp   rq   rr   rs   rt   ru   rv   rw   rx   ry   rA   rz   r{   Úcolumnsr?   rI   rI   rJ   r„   g   s4    (ÿüøÿù
ÿr„   c                   @   s„  e Zd ZdZd9edeeddœdd„Zd dœd	d
„Ze	e
e  e	e e	e ddœdd„Zedœdd„Zedœdd„Zeedœdd„ƒZedœdd„Zedœdd„Zeedœdd„ƒZeedœdd„ƒZedœdd„Zedœdd„Zedœd d!„Zd:eed#œd$d%„Zeeee f d&œd'd(„Z!d;eed#œd)d*„Z"d<ee#e d+œd,d-„Z$ddœd.d/„Z%d=eeed1œd2d3„Z&edœd4d5„Z'e(ed6œd7d8„Z)dS )>Ú_Readerz9A reader that tracks progress while it's being read from.Tr>   N)Úhandler?   ÚtaskÚclose_handlerL   c                 C   s"   || _ || _|| _|| _d| _d S ©NF)r‡   r?   rˆ   r‰   Ú_closed)rF   r‡   r?   rˆ   r‰   rI   rI   rJ   rE   °   s
    z_Reader.__init__rK   c                 C   s   | j  ¡  | S rS   )r‡   rW   rV   rI   rI   rJ   rW   ½   s    
z_Reader.__enter__rX   c                 C   s   |   ¡  d S rS   )Úcloser^   rI   rI   rJ   r_   Á   s    z_Reader.__exit__c                 C   s   | S rS   rI   rV   rI   rI   rJ   Ú__iter__É   s    z_Reader.__iter__c                 C   s$   t | jƒ}| jj| jt|ƒd� |S ©N©rN   )Únextr‡   r?   rN   rˆ   Úlen)rF   ÚlinerI   rI   rJ   Ú__next__Ì   s    
z_Reader.__next__c                 C   s   | j S rS   )r‹   rV   rI   rI   rJ   ÚclosedÑ   s    z_Reader.closedc                 C   s
   | j  ¡ S rS   )r‡   ÚfilenorV   rI   rI   rJ   r•   Õ   s    z_Reader.filenoc                 C   s
   | j  ¡ S rS   )r‡   ÚisattyrV   rI   rI   rJ   r–   Ø   s    z_Reader.isattyc                 C   s   | j jS rS   )r‡   ÚmoderV   rI   rI   rJ   r—   Û   s    z_Reader.modec                 C   s   | j jS rS   )r‡   ÚnamerV   rI   rI   rJ   r˜   ß   s    z_Reader.namec                 C   s
   | j  ¡ S rS   )r‡   ÚreadablerV   rI   rI   rJ   r™   ã   s    z_Reader.readablec                 C   s
   | j  ¡ S rS   )r‡   ÚseekablerV   rI   rI   rJ   rš   æ   s    z_Reader.seekablec                 C   s   dS rŠ   rI   rV   rI   rI   rJ   Úwritableé   s    z_Reader.writableéÿÿÿÿ)ÚsizerL   c                 C   s&   | j  |¡}| jj| jt|ƒd� |S rŽ   )r‡   Úreadr?   rN   rˆ   r‘   )rF   r�   ÚblockrI   rI   rJ   rž   ì   s    z_Reader.read)Úbc                 C   s"   | j  |¡}| jj| j|d� |S rŽ   )r‡   Úreadintor?   rN   rˆ   )rF   r    ÚnrI   rI   rJ   r¡   ñ   s    z_Reader.readintoc                 C   s&   | j  |¡}| jj| jt|ƒd� |S rŽ   )r‡   Úreadliner?   rN   rˆ   r‘   )rF   r�   r’   rI   rI   rJ   r£   ö   s    z_Reader.readline)ÚhintrL   c                 C   s,   | j  |¡}| jj| jttt|ƒƒd� |S rŽ   )r‡   Ú	readlinesr?   rN   rˆ   ÚsumÚmapr‘   )rF   r¤   ÚlinesrI   rI   rJ   r¥   û   s    z_Reader.readlinesc                 C   s   | j r| j ¡  d| _d S )NT)r‰   r‡   rŒ   r‹   rV   rI   rI   rJ   rŒ      s    
z_Reader.closer   )ÚoffsetÚwhencerL   c                 C   s$   | j  ||¡}| jj| j|d� |S )N©rC   )r‡   Úseekr?   rP   rˆ   )rF   r©   rª   ÚposrI   rI   rJ   r¬     s    z_Reader.seekc                 C   s
   | j  ¡ S rS   )r‡   ÚtellrV   rI   rI   rJ   r®   
  s    z_Reader.tell)ÚsrL   c                 C   s   t dƒ‚d S )NÚwrite)r   )rF   r¯   rI   rI   rJ   r°     s    z_Reader.write)T)rœ   )rœ   )rœ   )r   )*r`   ra   rb   rc   r   r:   ÚboolrE   rW   r   r#   re   r   r_   r�   Úbytesr“   Úpropertyr”   Úintr•   r–   Ústrr—   r˜   r™   rš   r›   rž   r%   Ú	bytearrayÚ
memoryviewr   r¡   r£   r   r¥   rŒ   r¬   r®   r   r°   rI   rI   rI   rJ   r†   ­   sH    ûú
ûr†   c                   @   sT   e Zd ZdZdeddœdd„Zedœdd	„Zeee	  ee	 ee
 dd
œdd„ZdS )Ú_ReadContextzEA utility class to handle a context for both a reader and a progress.r>   N)r?   ÚreaderrL   c                 C   s   || _ || _d S rS   )r?   r¹   )rF   r?   r¹   rI   rI   rJ   rE     s    z_ReadContext.__init__rK   c                 C   s   | j  ¡  | j ¡ S rS   )r?   rU   r¹   rW   rV   rI   rI   rJ   rW     s    
z_ReadContext.__enter__rX   c                 C   s   | j  ¡  | j |||¡ d S rS   )r?   Ústopr¹   r_   r^   rI   rI   rJ   r_     s    
z_ReadContext.__exit__)r`   ra   rb   rc   r<   rE   rW   r   r#   re   r   r_   rI   rI   rI   rJ   r¸     s   
ûr¸   ú
Reading...)ro   rq   rr   rs   rt   ru   rv   rw   rx   ry   rz   )Úfilerp   ro   rq   rr   rs   rt   ru   rv   rw   rx   ry   rz   rL   c             	   C   sh   |rt dƒgng }| t||	|
|d�tƒ tƒ f¡ t||||||pDd|dœŽ}|j| ||d�}t||ƒS )a  Read bytes from a file while tracking progress.

    Args:
        file (Union[str, PathLike[str], BinaryIO]): The path to the file to read, or a file-like object in binary mode.
        total (int): Total number of bytes to read.
        description (str, optional): Description of task show next to progress bar. Defaults to "Reading".
        auto_refresh (bool, optional): Automatic refresh, disable to force a refresh after each iteration. Default is True.
        transient: (bool, optional): Clear the progress on exit. Defaults to False.
        console (Console, optional): Console to write to. Default creates internal Console instance.
        refresh_per_second (float): Number of times per second to refresh the progress information. Defaults to 10.
        style (StyleType, optional): Style for the bar background. Defaults to "bar.back".
        complete_style (StyleType, optional): Style for the completed bar. Defaults to "bar.complete".
        finished_style (StyleType, optional): Style for a finished bar. Defaults to "bar.finished".
        pulse_style (StyleType, optional): Style for pulsing bars. Defaults to "bar.pulse".
        disable (bool, optional): Disable display of progress.
    Returns:
        ContextManager[BinaryIO]: A context manager yielding a progress reader.

    r|   r}   rh   r~   )rp   ro   )r   r€   r�   ÚDownloadColumnrƒ   r>   Ú	wrap_filer¸   )r¼   rp   ro   rq   rr   rs   rt   ru   rv   rw   rx   ry   rz   r…   r?   r¹   rI   rI   rJ   r¾   &  s0    %ÿüøÿù
r¾   rœ   )rp   ro   rq   rr   rs   rt   ru   rv   rw   rx   ry   rz   úPathLike[str]ÚrtÚr)r¼   r—   Ú	bufferingÚencodingÚerrorsÚnewlinerp   ro   rq   rr   rs   rt   ru   rv   rw   rx   ry   rz   rL   c                C   s   d S rS   rI   ©r¼   r—   rÂ   rÃ   rÄ   rÅ   rp   ro   rq   rr   rs   rt   ru   rv   rw   rx   ry   rz   rI   rI   rJ   Úopeng  s    rÇ   Úrbc                C   s   d S rS   rI   rÆ   rI   rI   rJ   rÇ   €  s    c             
   C   sr   |rt dƒgng }| t||||d�tƒ tƒ f¡ t|||	|
||pDd|dœŽ}|j| |||||||d�}t||ƒS )a®  Read bytes from a file while tracking progress.

    Args:
        path (Union[str, PathLike[str], BinaryIO]): The path to the file to read, or a file-like object in binary mode.
        mode (str): The mode to use to open the file. Only supports "r", "rb" or "rt".
        buffering (int): The buffering strategy to use, see :func:`io.open`.
        encoding (str, optional): The encoding to use when reading in text mode, see :func:`io.open`.
        errors (str, optional): The error handling strategy for decoding errors, see :func:`io.open`.
        newline (str, optional): The strategy for handling newlines in text mode, see :func:`io.open`
        total: (int, optional): Total number of bytes to read. Must be provided if reading from a file handle. Default for a path is os.stat(file).st_size.
        description (str, optional): Description of task show next to progress bar. Defaults to "Reading".
        auto_refresh (bool, optional): Automatic refresh, disable to force a refresh after each iteration. Default is True.
        transient: (bool, optional): Clear the progress on exit. Defaults to False.
        console (Console, optional): Console to write to. Default creates internal Console instance.
        refresh_per_second (float): Number of times per second to refresh the progress information. Defaults to 10.
        style (StyleType, optional): Style for the bar background. Defaults to "bar.back".
        complete_style (StyleType, optional): Style for the completed bar. Defaults to "bar.complete".
        finished_style (StyleType, optional): Style for a finished bar. Defaults to "bar.finished".
        pulse_style (StyleType, optional): Style for pulsing bars. Defaults to "bar.pulse".
        disable (bool, optional): Disable display of progress.
        encoding (str, optional): The encoding to use when reading in text mode.

    Returns:
        ContextManager[BinaryIO]: A context manager yielding a progress reader.

    r|   r}   rh   r~   )r—   rÂ   rÃ   rÄ   rÅ   rp   ro   )r   r€   r�   r½   rƒ   r>   rÇ   r¸   )r¼   r—   rÂ   rÃ   rÄ   rÅ   rp   ro   rq   rr   rs   rt   ru   rv   rw   rx   ry   rz   r…   r?   r¹   rI   rI   rJ   rÇ   ™  sB    1ÿüøÿù
ø
c                   @   sj   e Zd ZU dZdZee ed< dee ddœdd„Z	edœdd	„Z
d
edœdd„Zed
edœdd„ƒZdS )ÚProgressColumnz3Base class for a widget to use in progress display.NÚmax_refresh)Útable_columnrL   c                 C   s   || _ i | _d | _d S rS   )Ú_table_columnÚ_renderable_cacheÚ_update_time)rF   rË   rI   rI   rJ   rE   ô  s    zProgressColumn.__init__rK   c                 C   s   | j p
tƒ S )z.Get a table column, used to build tasks table.)rÌ   r6   rV   rI   rI   rJ   Úget_table_columnù  s    zProgressColumn.get_table_columnÚTask©rˆ   rL   c                 C   sp   |  ¡ }| jdurR|jsRz| j|j \}}W n ty>   Y n0 || j |krR|S |  |¡}||f| j|j< |S )a  Called by the Progress object to return a renderable for the given task.

        Args:
            task (Task): An object containing information regarding the task.

        Returns:
            RenderableType: Anything renderable (including str).
        N)rt   rÊ   rC   rÍ   ÚidÚKeyErrorÚrender)rF   rˆ   Úcurrent_timeÚ	timestampÚ
renderablerI   rI   rJ   Ú__call__ý  s    	
zProgressColumn.__call__c                 C   s   dS )z"Should return a renderable object.NrI   ©rF   rˆ   rI   rI   rJ   rÔ     s    zProgressColumn.render)N)r`   ra   rb   rc   rÊ   r   rd   Ú__annotations__r6   rE   rÏ   r/   rØ   r   rÔ   rI   rI   rI   rJ   rÉ   ï  s   
rÉ   c                       sD   e Zd ZdZdddœeee dœ‡ fdd„Zded	œd
d„Z‡  Z	S )ÚRenderableColumnz�A column to insert an arbitrary column.

    Args:
        renderable (RenderableType, optional): Any renderable. Defaults to empty string.
    Ú N©rË   )r×   rË   c                   s   || _ tƒ j|d� d S ©NrÝ   )r×   rD   rE   )rF   r×   rË   rG   rI   rJ   rE      s    zRenderableColumn.__init__rÐ   rÑ   c                 C   s   | j S rS   )r×   rÙ   rI   rI   rJ   rÔ   &  s    zRenderableColumn.render)rÜ   )
r`   ra   rb   rc   r/   r   r6   rE   rÔ   rf   rI   rI   rG   rJ   rÛ     s    ÿÿÿrÛ   c                       sb   e Zd ZdZdeee eeee	 dœ‡ fdd	„Z
deee edd
œdd„Zdedœdd„Z‡  ZS )ÚSpinnerColumna‰  A column with a 'spinner' animation.

    Args:
        spinner_name (str, optional): Name of spinner animation. Defaults to "dots".
        style (StyleType, optional): Style of spinner. Defaults to "progress.spinner".
        speed (float, optional): Speed factor of spinner. Defaults to 1.0.
        finished_text (TextType, optional): Text used when task is finished. Defaults to " ".
    Údotsúprogress.spinnerç      ð?ú N)Úspinner_namerv   ÚspeedÚfinished_textrË   c                    s<   t |||d�| _t|tƒr$t |¡n|| _tƒ j|d� d S )N©rv   rå   rÝ   )	r4   ÚspinnerÚ
isinstancerµ   r8   Úfrom_markupræ   rD   rE   )rF   rä   rv   rå   ræ   rË   rG   rI   rJ   rE   4  s    ÿýzSpinnerColumn.__init__)rä   Úspinner_stylerå   rL   c                 C   s   t |||d�| _dS )a-  Set a new spinner.

        Args:
            spinner_name (str): Spinner name, see python -m rich.spinner.
            spinner_style (Optional[StyleType], optional): Spinner style. Defaults to "progress.spinner".
            speed (float, optional): Speed factor of spinner. Defaults to 1.0.
        rç   N)r4   rè   )rF   rä   rë   rå   rI   rI   rJ   Úset_spinnerD  s    zSpinnerColumn.set_spinnerrÐ   rÑ   c                 C   s    |j r| jn| j | ¡ ¡}|S rS   )Úfinishedræ   rè   rÔ   rt   )rF   rˆ   ÚtextrI   rI   rJ   rÔ   S  s
    ÿýzSpinnerColumn.render)rà   rá   râ   rã   N)rá   râ   )r`   ra   rb   rc   rµ   r   r5   rd   r9   r6   rE   rì   r/   rÔ   rf   rI   rI   rG   rJ   rß   *  s,        úú  üûrß   c                	       sL   e Zd ZdZdeeeeee	 ee
 ddœ‡ fdd„Zd	ed
œdd„Z‡  ZS )r   zA column containing text.ÚnoneÚleftTN)Útext_formatrv   ÚjustifyÚmarkupÚhighlighterrË   rL   c                    s:   || _ || _|| _|| _|| _tƒ j|p0tdd�d� d S )NT©Úno_wraprÝ   )rñ   rò   rv   ró   rô   rD   rE   r6   )rF   rñ   rv   rò   ró   rô   rË   rG   rI   rJ   rE   _  s    	zTextColumn.__init__rÐ   rÑ   c                 C   sR   | j j|d�}| jr*tj|| j| jd�}nt|| j| jd�}| jrN| j |¡ |S ©N©rˆ   )rv   rò   )	rñ   Úformatró   r8   rê   rv   rò   rô   Ú	highlight)rF   rˆ   Ú_textrî   rI   rI   rJ   rÔ   o  s    zTextColumn.render)rï   rð   TNN)r`   ra   rb   rc   rµ   r5   r.   r±   r   r0   r6   rE   r8   rÔ   rf   rI   rI   rG   rJ   r   \  s         ùør   c                	       sL   e Zd ZdZdee eeeeee ddœ‡ fd	d
„Zde	dœdd„Z
‡  ZS )r�   a  Renders a visual progress bar.

    Args:
        bar_width (Optional[int], optional): Width of bar or None for full width. Defaults to 40.
        style (StyleType, optional): Style for the bar background. Defaults to "bar.back".
        complete_style (StyleType, optional): Style for the completed bar. Defaults to "bar.complete".
        finished_style (StyleType, optional): Style for a finished bar. Defaults to "bar.finished".
        pulse_style (StyleType, optional): Style for pulsing bars. Defaults to "bar.pulse".
    é(   ri   rj   rk   rl   N)Ú	bar_widthrv   rw   rx   ry   rË   rL   c                    s0   || _ || _|| _|| _|| _tƒ j|d� d S rÞ   )rý   rv   rw   rx   ry   rD   rE   )rF   rý   rv   rw   rx   ry   rË   rG   rI   rJ   rE   …  s    	zBarColumn.__init__rÐ   rÑ   c                 C   s^   t |jdurtd|jƒndtd|jƒ| jdu r2dn
td| jƒ|j | ¡ | j| j| j	| j
d�	S )z&Gets a progress bar widget for a task.Nr   r)   )	rp   rC   ÚwidthÚpulseÚanimation_timerv   rw   rx   ry   )r3   rp   ÚmaxrC   rý   Ústartedrt   rv   rw   rx   ry   rÙ   rI   rI   rJ   rÔ   •  s    
÷zBarColumn.render)rü   ri   rj   rk   rl   N)r`   ra   rb   rc   r   r´   r5   r6   rE   r3   rÔ   rf   rI   rI   rG   rJ   r�   z  s"         ùør�   c                   @   s    e Zd ZdZdedœdd„ZdS )ÚTimeElapsedColumnzRenders time elapsed.rÐ   rÑ   c                 C   sD   |j r|jn|j}|du r&tddd�S tt|ƒd�}tt|ƒdd�S )úShow time remaining.Nú-:--:--úprogress.elapsed©rv   )Úseconds)rí   Úfinished_timeÚelapsedr8   r	   r´   rµ   )rF   rˆ   r
  ÚdeltarI   rI   rJ   rÔ   §  s
    zTimeElapsedColumn.renderN©r`   ra   rb   rc   r8   rÔ   rI   rI   rI   rJ   r  ¤  s   r  c                       sh   e Zd ZdZdeeeeeee	 ee
 edd	œ	‡ fd
d„Zeee edœdd„ƒZdedœdd„Z‡  ZS )r‚   a  Show task progress as a percentage.

    Args:
        text_format (str, optional): Format for percentage display. Defaults to "[progress.percentage]{task.percentage:>3.0f}%".
        text_format_no_percentage (str, optional): Format if percentage is unknown. Defaults to "".
        style (StyleType, optional): Style of output. Defaults to "none".
        justify (JustifyMethod, optional): Text justification. Defaults to "left".
        markup (bool, optional): Enable markup. Defaults to True.
        highlighter (Optional[Highlighter], optional): Highlighter to apply to output. Defaults to None.
        table_column (Optional[Column], optional): Table Column to use. Defaults to None.
        show_speed (bool, optional): Show speed if total is unknown. Defaults to False.
    ú-[progress.percentage]{task.percentage:>3.0f}%rÜ   rï   rð   TNF)	rñ   Útext_format_no_percentagerv   rò   ró   rô   rË   r{   rL   c	           	         s(   || _ || _tƒ j||||||d� d S )N)rñ   rv   rò   ró   rô   rË   )r  r{   rD   rE   )	rF   rñ   r  rv   rò   ró   rô   rË   r{   rG   rI   rJ   rE   ¾  s    úzTaskProgressColumn.__init__)rå   rL   c                 C   sN   |du rt ddd�S t t|ƒg d¢d¡\}}|| }t |d›|› d�dd�S )	zµRender the speed in iterations per second.

        Args:
            task (Task): A Task object.

        Returns:
            Text: Text object containing the task speed.
        NrÜ   zprogress.percentager  )rÜ   u   Ã—10Â³u   Ã—10â�¶u   Ã—10â�¹u   Ã—10Â¹Â²éè  z.1fz it/s)r8   r*   Úpick_unit_and_suffixr´   )Úclsrå   ÚunitÚsuffixÚ
data_speedrI   rI   rJ   Úrender_speedÕ  s    
ýzTaskProgressColumn.render_speedrÐ   rÑ   c                 C   sˆ   |j d u r"| jr"|  |jp|j¡S |j d u r2| jn| j}|j|d�}| jr`t	j
|| j| jd�}nt	|| j| jd�}| jr„| j |¡ |S r÷   )rp   r{   r  Úfinished_speedrå   r  rñ   rù   ró   r8   rê   rv   rò   rô   rú   )rF   rˆ   rñ   rû   rî   rI   rI   rJ   rÔ   é  s    ÿzTaskProgressColumn.render)r  rÜ   rï   rð   TNNF)r`   ra   rb   rc   rµ   r5   r.   r±   r   r0   r6   rE   Úclassmethodrd   r8   r  rÔ   rf   rI   rI   rG   rJ   r‚   °  s.           ÷ör‚   c                       sD   e Zd ZdZdZdeeee dœ‡ fdd„Zde	d	œd
d„Z
‡  ZS )rƒ   a  Renders estimated time remaining.

    Args:
        compact (bool, optional): Render MM:SS when time remaining is less than an hour. Defaults to False.
        elapsed_when_finished (bool, optional): Render time elapsed when the task is finished. Defaults to False.
    ç      à?FN)ÚcompactÚelapsed_when_finishedrË   c                    s   || _ || _tƒ j|d� d S rÞ   )r  r  rD   rE   )rF   r  r  rË   rG   rI   rJ   rE     s    zTimeRemainingColumn.__init__rÐ   rÑ   c                 C   sº   | j r|jr|j}d}n
|j}d}|jdu r8td|d�S |du rVt| jrLdnd|d�S tt|ƒdƒ\}}t|dƒ\}}| jr”|s”|d	›d
|d	›�}n|d›d
|d	›d
|d	›�}t||d�S )r  r  zprogress.remainingNrÜ   r  z--:--r  é<   Ú02dú:Úd)	r  rí   r	  Útime_remainingrp   r8   r  Údivmodr´   )rF   rˆ   Ú	task_timerv   Úminutesr  ÚhoursÚ	formattedrI   rI   rJ   rÔ     s    

zTimeRemainingColumn.render)FFN)r`   ra   rb   rc   rÊ   r±   r   r6   rE   r8   rÔ   rf   rI   rI   rG   rJ   rƒ   ù  s      üü
rƒ   c                   @   s    e Zd ZdZdedœdd„ZdS )ÚFileSizeColumnzRenders completed filesize.rÐ   rÑ   c                 C   s   t  t|jƒ¡}t|dd�S )úShow data completed.zprogress.filesizer  )r*   Údecimalr´   rC   r8   ©rF   rˆ   Ú	data_sizerI   rI   rJ   rÔ   ,  s    zFileSizeColumn.renderNr  rI   rI   rI   rJ   r%  )  s   r%  c                   @   s    e Zd ZdZdedœdd„ZdS )ÚTotalFileSizeColumnzRenders total filesize.rÐ   rÑ   c                 C   s*   |j durt t|j ƒ¡nd}t|dd�S )r&  NrÜ   zprogress.filesize.totalr  )rp   r*   r'  r´   r8   r(  rI   rI   rJ   rÔ   5  s    zTotalFileSizeColumn.renderNr  rI   rI   rI   rJ   r*  2  s   r*  c                       s>   e Zd ZdZdeee dœ‡ fdd„Zdedœd	d
„Z	‡  Z
S )ÚMofNCompleteColumnaH  Renders completed count/total, e.g. '  10/1000'.

    Best for bounded tasks with int quantities.

    Space pads the completed count so that progress length does not change as task progresses
    past powers of 10.

    Args:
        separator (str, optional): Text to separate completed and total values. Defaults to "/".
    ú/N)Ú	separatorrË   c                    s   || _ tƒ j|d� d S rÞ   )r-  rD   rE   )rF   r-  rË   rG   rI   rJ   rE   G  s    zMofNCompleteColumn.__init__rÐ   rÑ   c                 C   sP   t |jƒ}|jdurt |jƒnd}tt|ƒƒ}t||› d�›| j› |› �dd�S )zShow completed/total.Nú?r  úprogress.downloadr  )r´   rC   rp   r‘   rµ   r8   r-  )rF   rˆ   rC   rp   Útotal_widthrI   rI   rJ   rÔ   K  s    
þzMofNCompleteColumn.render)r,  N)r`   ra   rb   rc   rµ   r   r6   rE   r8   rÔ   rf   rI   rI   rG   rJ   r+  ;  s   r+  c                       s@   e Zd ZdZdeee ddœ‡ fdd„Zdedœd	d
„Z	‡  Z
S )r½   z¤Renders file size downloaded and total, e.g. '0.5/2.3 GB'.

    Args:
        binary_units (bool, optional): Use binary units, KiB, MiB etc. Defaults to False.
    FN)Úbinary_unitsrË   rL   c                    s   || _ tƒ j|d� d S rÞ   )r1  rD   rE   )rF   r1  rË   rG   rI   rJ   rE   ]  s    zDownloadColumn.__init__rÐ   rÑ   c                 C   sÔ   t |jƒ}|jdurt |jƒn|}| jr@t |g d¢d¡\}}nt |g d¢d¡\}}|dkrbdnd}|| }|d|› d	�›}|jdur¬t |jƒ}	|	| }
|
d|› d	�›}nd
}|› d|› d|› �}t|dd�}|S )z.Calculate common unit for completed and total.N)	r²   ÚKiBÚMiBÚGiBÚTiBÚPiBÚEiBÚZiBÚYiBi   )	r²   ÚkBÚMBÚGBÚTBÚPBÚEBÚZBÚYBr  r)   r   z,.Úfr.  r,  rã   r/  r  )r´   rC   rp   r1  r*   r  r8   )rF   rˆ   rC   Ú unit_and_suffix_calculation_baser  r  Ú	precisionÚcompleted_ratioÚcompleted_strrp   Útotal_ratioÚ	total_strÚdownload_statusÚdownload_textrI   rI   rJ   rÔ   c  s2    
ÿý
ý

zDownloadColumn.render)FN)r`   ra   rb   rc   r±   r   r6   rE   r8   rÔ   rf   rI   rI   rG   rJ   r½   V  s    ÿþr½   c                   @   s    e Zd ZdZdedœdd„ZdS )ÚTransferSpeedColumnz&Renders human readable transfer speed.rÐ   rÑ   c                 C   s@   |j p
|j}|du r tddd�S t t|ƒ¡}t|› d�dd�S )zShow data transfer speed.Nr.  zprogress.data.speedr  z/s)r  rå   r8   r*   r'  r´   )rF   rˆ   rå   r  rI   rI   rJ   rÔ   Š  s
    zTransferSpeedColumn.renderNr  rI   rI   rI   rJ   rK  ‡  s   rK  c                   @   s"   e Zd ZU dZeed< eed< dS )ÚProgressSamplez$Sample of progress for a given time.rÖ   rC   N)r`   ra   rb   rc   rd   rÚ   rI   rI   rI   rJ   rL  “  s   
rL  c                   @   s”  e Zd ZU dZeed< eed< ee ed< eed< e	ed< dZ
ee ed< d	Zeed
< eed�Zeeef ed< edddd�Zee ed< edddd�Zee ed< dZee ed< edd„ ddd�Zee ed< eded�Zeed< edœdd„Zeedœdd„ƒZeee dœdd„ƒZeee dœdd „ƒZeedœd!d"„ƒZeedœd#d$„ƒZ eee dœd%d&„ƒZ!eee dœd'd(„ƒZ"ddœd)d*„Z#dS )+rÐ   z…Information regarding a progress task.

    This object should be considered read-only outside of the :class:`~Progress` class.

    rÒ   ro   rp   rC   Ú	_get_timeNr	  TÚvisible)Údefault_factoryÚfieldsF)ÚdefaultÚinitÚreprÚ
start_timeÚ	stop_timer  c                   C   s
   t dd�S )Nr  )Úmaxlenr   rI   rI   rI   rJ   Ú<lambda>Æ  ó    zTask.<lambda>)rO  rR  rS  Ú	_progress)rS  rO  Ú_lockrK   c                 C   s   |   ¡ S )z(float: Get the current time, in seconds.)rM  rV   rI   rI   rJ   rt   Ì  s    zTask.get_timec                 C   s
   | j duS )z#bool: Check if the task as started.N)rT  rV   rI   rI   rJ   r  Ð  s    zTask.startedc                 C   s   | j du rdS | j | j S )zPOptional[float]: Get the number of steps remaining, if a non-None total was set.N)rp   rC   rV   rI   rI   rJ   Ú	remainingÕ  s    
zTask.remainingc                 C   s2   | j du rdS | jdur$| j| j  S |  ¡ | j  S )z]Optional[float]: Time elapsed since task was started, or ``None`` if the task hasn't started.N)rT  rU  rt   rV   rI   rI   rJ   r
  Ü  s
    

zTask.elapsedc                 C   s
   | j duS )zCheck if the task has finished.N)r	  rV   rI   rI   rJ   rí   å  s    zTask.finishedc                 C   s.   | j s
dS | j| j  d }tdtd|ƒƒ}|S )zOfloat: Get progress of task as a percentage. If a None total was set, returns 0ç        ç      Y@)rp   rC   Úminr  )rF   rC   rI   rI   rJ   Ú
percentageê  s
    zTask.percentagec                 C   s¬   | j du rdS | j�„ | j}|s0W d  ƒ dS |d j|d j }|dkr\W d  ƒ dS t|ƒ}t|ƒ tdd„ |D ƒƒ}|| }|W  d  ƒ S 1 sž0    Y  dS )z=Optional[float]: Get the estimated speed in steps per second.Nrœ   r   c                 s   s   | ]}|j V  qd S rS   r«   )Ú.0ÚsamplerI   rI   rJ   Ú	<genexpr>  rX  zTask.speed.<locals>.<genexpr>)rT  rZ  rY  rÖ   Úiterr�   r¦   )rF   r?   Ú
total_timeÚiter_progressÚtotal_completedrå   rI   rI   rJ   rå   ó  s    
z
Task.speedc                 C   s:   | j r
dS | j}|sdS | j}|du r*dS t|| ƒ}|S )zJOptional[float]: Get estimated time to completion, or ``None`` if no data.r\  N)rí   rå   r[  r   )rF   rå   r[  ÚestimaterI   rI   rJ   r    s    zTask.time_remainingc                 C   s   | j  ¡  d| _d| _dS )zReset progress.N)rY  Úclearr	  r  rV   rI   rI   rJ   Ú_reset  s    
zTask._reset)$r`   ra   rb   rc   r:   rÚ   rµ   r   rd   ÚGetTimeCallabler	  rN  r±   r   ÚdictrP  r   r   rT  rU  r  rY  r   rL  r   rZ  rt   r³   r  r[  r
  rí   r_  rå   r  ri  rI   rI   rI   rJ   rÐ   œ  s@   

ÿrÐ   c                   @   sº  e Zd ZdZdddddddddddœ
eeef ee e	e
e
e	e	e	ee e	e	ddœd	d
„Zeeedf dœdd„ƒZeedœdd„ƒZeee dœdd„ƒZeee dœdd„ƒZee	dœdd„ƒZddœdd„Zddœdd„Zd dœdd„Zeee  ee ee ddœdd„ZdXeee  e!e  f ee
 ee ee
ee  d"œd#d$„Z"dYdd%d&œe#ee$ ee ee#d'œd(d)„Z%e&j'dZddd%d+œeed,e(f e)d- e$ee ee ee ee$ ee ee#d.œ
d/d0„ƒZ*e&j'd[ddd%d+œeed,e(f ee)d1 e)d2 f e$ee ee ee ee$ ee ee+d.œ
d3d0„ƒZ*d\ddd%d+œeed,e(f ee)d- e)d2 e)d1 f e$ee ee ee ee$ ee eee#e+f d.œ
d4d0„Z*edd5œd6d7„Z,edd5œd8d9„Z-ddddddd:œeee
 ee
 ee
 ee ee	 e	e.dd;œ	d<d=„Z/ddd>ddd?œee	ee
 e$ee	 ee e.dd@œdAdB„Z0d]ee
ddDœdEdF„Z1ddœdGdH„Z2e3dœdIdJ„Z4ee3 dœdKdL„Z5ee e6dMœdNdO„Z7e3dœdPdQ„Z8d^ee	ee
 e$e	e.edSœdTdU„Z9edd5œdVdW„Z:dS )_r>   a�  Renders an auto-updating progress bar(s).

    Args:
        console (Console, optional): Optional Console instance. Default will an internal Console instance writing to stdout.
        auto_refresh (bool, optional): Enable auto refresh. If disabled, you will need to call `refresh()`.
        refresh_per_second (Optional[float], optional): Number of times per second to refresh the progress information or None to use default (10). Defaults to None.
        speed_estimate_period: (float, optional): Period (in seconds) used to calculate the speed estimate. Defaults to 30.
        transient: (bool, optional): Clear the progress on exit. Defaults to False.
        redirect_stdout: (bool, optional): Enable redirection of stdout, so ``print`` may be used. Defaults to True.
        redirect_stderr: (bool, optional): Enable redirection of stderr. Defaults to True.
        get_time: (Callable, optional): A callable that gets the current time, or None to use Console.get_time. Defaults to None.
        disable (bool, optional): Disable progress display. Defaults to False
        expand (bool, optional): Expand tasks table to fit width. Defaults to False.
    NTrh   g      >@F)
rr   rq   ru   Úspeed_estimate_periodrs   Úredirect_stdoutÚredirect_stderrrt   rz   Úexpand)r…   rr   rq   ru   rl  rs   rm  rn  rt   rz   ro  rL   c       
      	   G   sŽ   |dksJ dƒ‚t ƒ | _|p"|  ¡ | _|| _|	| _|
| _i | _tdƒ| _	t
|pRtƒ |||||| jd�| _|pr| jj| _| jj| _| jj| _d S )Nr   zrefresh_per_second must be > 0)rr   rq   ru   rs   rm  rn  Úget_renderable)r   rZ  Úget_default_columnsr…   rl  rz   ro  Ú_tasksr:   Ú_task_indexr2   r+   rp  Úliverr   rt   ÚprintÚlog)rF   rr   rq   ru   rl  rs   rm  rn  rt   rz   ro  r…   rI   rI   rJ   rE   *  s(    
ù	
zProgress.__init__.rK   c                 C   s   t dƒtƒ tƒ tƒ fS )a£  Get the default columns used for a new Progress instance:
           - a text column for the description (TextColumn)
           - the bar itself (BarColumn)
           - a text column showing completion percentage (TextColumn)
           - an estimated-time-remaining column (TimeRemainingColumn)
        If the Progress instance is created without passing a columns argument,
        the default columns defined here will be used.

        You can also create a Progress instance using custom columns before
        and/or after the defaults, as in this example:

            progress = Progress(
                SpinnerColumn(),
                *Progress.default_columns(),
                "Elapsed:",
                TimeElapsedColumn(),
            )

        This code shows the creation of a Progress display, containing
        a spinner to the left, the default columns, and a labeled elapsed
        time column.
        r|   )r   r�   r‚   rƒ   )r  rI   rI   rJ   rq  N  s
    üzProgress.get_default_columnsc                 C   s   | j jS rS   )rt  rr   rV   rI   rI   rJ   rr   m  s    zProgress.consolec                 C   s8   | j � t| j ¡ ƒW  d  ƒ S 1 s*0    Y  dS )zGet a list of Task instances.N)rZ  Úlistrr  ÚvaluesrV   rI   rI   rJ   Útasksq  s    zProgress.tasksc                 C   s8   | j � t| j ¡ ƒW  d  ƒ S 1 s*0    Y  dS )zA list of task IDs.N)rZ  rw  rr  ÚkeysrV   rI   rI   rJ   Útask_idsw  s    zProgress.task_idsc                 C   sX   | j �> | jsW d  ƒ dS tdd„ | j ¡ D ƒƒW  d  ƒ S 1 sJ0    Y  dS )z'Check if all tasks have been completed.NTc                 s   s   | ]}|j V  qd S rS   )rí   )r`  rˆ   rI   rI   rJ   rb  ƒ  rX  z$Progress.finished.<locals>.<genexpr>)rZ  rr  Úallrx  rV   rI   rI   rJ   rí   }  s    zProgress.finishedc                 C   s   | j s| jjdd� dS )zStart the progress display.T)rM   N)rz   rt  rU   rV   rI   rI   rJ   rU   …  s    zProgress.startc                 C   s    | j  ¡  | jjs| j ¡  dS )zStop the progress display.N)rt  rº   rr   Úis_interactiveru  rV   rI   rI   rJ   rº   Š  s    
zProgress.stopc                 C   s   |   ¡  | S rS   rT   rV   rI   rI   rJ   rW   �  s    zProgress.__enter__rX   c                 C   s   |   ¡  d S rS   )rº   r^   rI   rI   rJ   r_   ”  s    zProgress.__exit__rg   rm   )rn   rp   r@   ro   rA   rL   c                 c   sÒ   d}|du r$t |tƒr(tt|ƒƒ}n|}|du r@| j||d�}n| j||d� | jjr¢t| ||ƒ�.}|D ]}|V  | j	d7  _	qhW d  ƒ qÎ1 s–0    Y  n,| j
}	| j}
|D ]}|V  |	|dƒ |
ƒ  q²dS )a‡  Track progress by iterating over a sequence.

        Args:
            sequence (Sequence[ProgressType]): A sequence of values you want to iterate over and track progress.
            total: (float, optional): Total number of steps. Default is len(sequence).
            task_id: (TaskID): Task to track. Default is new task.
            description: (str, optional): Description of task, if new task is created.
            update_period (float, optional): Minimum time (in seconds) between calls to update(). Defaults to 0.1.

        Returns:
            Iterable[ProgressType]: An iterable of values taken from the provided sequence.
        N©rp   r)   )ré   r   rd   r‘   Úadd_taskrP   rt  rq   r=   rC   rN   rM   )rF   rn   rp   r@   ro   rA   Ú
task_totalÚtrack_threadÚvaluerN   rM   rI   rI   rJ   r„   œ  s&    
0
zProgress.trackr»   )r@   ro   )r¼   rp   r@   ro   rL   c                C   s’   d}|dur|}n:|durL| j � | j| j}W d  ƒ n1 sB0    Y  |du r\tdƒ‚|du rt| j||d�}n| j||d� t|| |dd�S )aj  Track progress file reading from a binary file.

        Args:
            file (BinaryIO): A file-like object opened in binary mode.
            total (int, optional): Total number of bytes to read. This must be provided unless a task with a total is also given.
            task_id (TaskID): Task to track. Default is new task.
            description (str, optional): Description of task, if new task is created.

        Returns:
            BinaryIO: A readable file-like object in binary mode.

        Raises:
            ValueError: When no total value can be extracted from the arguments or the task.
        Nz?unable to get the total number of bytes, please specify 'total'r~  F©r‰   )rZ  rr  rp   Ú
ValueErrorr  rP   r†   )rF   r¼   rp   r@   ro   Útotal_bytesrI   rI   rJ   r¾   Ê  s    *ÿzProgress.wrap_filerœ   )rp   r@   ro   r¿   rÈ   )
r¼   r—   rÂ   rÃ   rÄ   rÅ   rp   r@   ro   rL   c          
      C   s   d S rS   rI   ©
rF   r¼   r—   rÂ   rÃ   rÄ   rÅ   rp   r@   ro   rI   rI   rJ   rÇ   ô  s    zProgress.openrÁ   rÀ   c          
      C   s   d S rS   rI   r†  rI   rI   rJ   rÇ     s    c                C   s   d  t|dd�¡}
|
dvr(td |¡ƒ‚|dk}|
dkrR|dkrRt dt¡ d	}n.|
d
ksb|
dkr€|dkrttdƒ‚n|dkr€d	}|du r’t|ƒj}|du rª| j	|	|d�}n| j
||d� tj|d|d�}t|| |dd�}|dksè|d
krütj|||||d�S |S )a#  Track progress while reading from a binary file.

        Args:
            path (Union[str, PathLike[str]]): The path to the file to read.
            mode (str): The mode to use to open the file. Only supports "r", "rb" or "rt".
            buffering (int): The buffering strategy to use, see :func:`io.open`.
            encoding (str, optional): The encoding to use when reading in text mode, see :func:`io.open`.
            errors (str, optional): The error handling strategy for decoding errors, see :func:`io.open`.
            newline (str, optional): The strategy for handling newlines in text mode, see :func:`io.open`.
            total (int, optional): Total number of bytes to read. If none given, os.stat(path).st_size is used.
            task_id (TaskID): Task to track. Default is new task.
            description (str, optional): Description of task, if new task is created.

        Returns:
            BinaryIO: A readable file-like object in binary mode.

        Raises:
            ValueError: When an invalid mode is given.
        rÜ   F)Úreverse)ÚbrrÀ   rÁ   zinvalid mode {!r}r)   rˆ  zaline buffering (buffering=1) isn't supported in binary mode, the default buffer size will be usedrœ   rÀ   rÁ   r   zcan't have unbuffered text I/ONr~  rÈ   )rÂ   Trƒ  )rÃ   rÄ   rÅ   Úline_buffering)r]   Úsortedr„  rù   ÚwarningsÚwarnÚRuntimeWarningr   Úst_sizer  rP   ÚiorÇ   r†   ÚTextIOWrapper)rF   r¼   r—   rÂ   rÃ   rÄ   rÅ   rp   r@   ro   Ú_moder‰  r‡   r¹   rI   rI   rJ   rÇ     s>    !þ

û)r@   rL   c                 C   sH   | j �. | j| }|jdu r&|  ¡ |_W d  ƒ n1 s:0    Y  dS )zéStart a task.

        Starts a task (used when calculating elapsed time). You may need to call this manually,
        if you called ``add_task`` with ``start=False``.

        Args:
            task_id (TaskID): ID of task.
        N)rZ  rr  rT  rt   )rF   r@   rˆ   rI   rI   rJ   Ú
start_taska  s    	

zProgress.start_taskc                 C   sR   | j �8 | j| }|  ¡ }|jdu r*||_||_W d  ƒ n1 sD0    Y  dS )z†Stop a task.

        This will freeze the elapsed time on the task.

        Args:
            task_id (TaskID): ID of task.
        N)rZ  rr  rt   rT  rU  )rF   r@   rˆ   rÕ   rI   rI   rJ   Ú	stop_tasko  s    

zProgress.stop_task)rp   rC   rN   ro   rN  rM   )	r@   rp   rC   rN   ro   rN  rM   rP  rL   c                K   s@  | j �� | j| }	|	j}
|dur:||	jkr:||	_|	 ¡  |durP|	 j|7  _|dur^||	_|durl||	_|durz||	_|	j |¡ |	j|
 }|  	¡ }|| j
 }|	j}|j}|rÈ|d j|k rÈ|ƒ  q®|dkrà| t||ƒ¡ |	jdu�r|	j|	jk�r|	jdu �r|	j|	_W d  ƒ n1 �s$0    Y  |�r<|  ¡  dS )a˜  Update information associated with a task.

        Args:
            task_id (TaskID): Task id (returned by add_task).
            total (float, optional): Updates task.total if not None.
            completed (float, optional): Updates task.completed if not None.
            advance (float, optional): Add a value to task.completed if not None.
            description (str, optional): Change task description if not None.
            visible (bool, optional): Set visible flag if not None.
            refresh (bool): Force a refresh of progress information. Default is False.
            **fields (Any): Additional data fields required for rendering.
        Nr   )rZ  rr  rC   rp   ri  ro   rN  rP  rP   rt   rl  rY  ÚpopleftrÖ   ÚappendrL  r	  r
  rM   )rF   r@   rp   rC   rN   ro   rN  rM   rP  rˆ   Úcompleted_startÚupdate_completedrÕ   Úold_sample_timerY  r”  rI   rI   rJ   rP   ~  sB    



ÿ
þý(zProgress.updater   )rU   rp   rC   rN  ro   )r@   rU   rp   rC   rN  ro   rP  rL   c          
      K   sš   |   ¡ }| j�p | j| }	|	 ¡  |r*|nd|	_|dur>||	_||	_|durR||	_|r\||	_|durj||	_	d|	_
W d  ƒ n1 s„0    Y  |  ¡  dS )aˆ  Reset a task so completed is 0 and the clock is reset.

        Args:
            task_id (TaskID): ID of task.
            start (bool, optional): Start the task after reset. Defaults to True.
            total (float, optional): New total steps in task, or None to use current total. Defaults to None.
            completed (int, optional): Number of steps completed. Defaults to 0.
            visible (bool, optional): Enable display of the task. Defaults to True.
            description (str, optional): Change task description if not None. Defaults to None.
            **fields (str): Additional data fields required for rendering.
        N)rt   rZ  rr  ri  rT  rp   rC   rN  rP  ro   r	  rM   )
rF   r@   rU   rp   rC   rN  ro   rP  rÕ   rˆ   rI   rI   rJ   Úreset»  s     
$zProgress.resetr)   )r@   rN   rL   c           
      C   sÞ   |   ¡ }| j�¼ | j| }|j}| j|7  _|j| }|| j }|j}|j}	|rh|d j|k rh|	ƒ  qNt|ƒdkr||	ƒ  qh| 	t
||ƒ¡ |jdur¼|j|jkr¼|jdu r¼|j|_|j|_W d  ƒ n1 sÐ0    Y  dS )z«Advance task by a number of steps.

        Args:
            task_id (TaskID): ID of task.
            advance (float): Number of steps to advance. Default is 1.
        r   r  N)rt   rZ  rr  rC   rl  rY  r”  rÖ   r‘   r•  rL  rp   r	  r
  rå   r  )
rF   r@   rN   rÕ   rˆ   r–  r—  r˜  rY  r”  rI   rI   rJ   rN   â  s,    


ÿ
þýzProgress.advancec                 C   s   | j s| jjr| j ¡  dS )z*Refresh (render) the progress information.N)rz   rt  Ú
is_startedrM   rV   rI   rI   rJ   rM      s    zProgress.refreshc                 C   s   t |  ¡ Ž }|S )z*Get a renderable for the progress display.)r-   Úget_renderables)rF   r×   rI   rI   rJ   rp    s    zProgress.get_renderablec                 c   s   |   | j¡}|V  dS )z5Get a number of renderables for the progress display.N)Úmake_tasks_tablery  )rF   ÚtablerI   rI   rJ   r›  
  s    zProgress.get_renderables)ry  rL   c                    sR   dd„ | j D ƒ}tj|d| jdœŽ}|D ]$‰ ˆ jr(|j‡ fdd„| j D ƒŽ  q(|S )z×Get a table to render the Progress display.

        Args:
            tasks (Iterable[Task]): An iterable of Task instances, one per row of the table.

        Returns:
            Table: A table instance.
        c                 s   s.   | ]&}t |tƒrtd d�n
| ¡  ¡ V  qdS )Trõ   N)ré   rµ   r6   rÏ   Úcopy)r`  Ú_columnrI   rI   rJ   rb    s   ýÿz,Progress.make_tasks_table.<locals>.<genexpr>)r   r)   )Úpaddingro  c                 3   s,   | ]$}t |tƒr|jˆ d �n|ˆ ƒV  qdS )rø   N)ré   rµ   rù   )r`  Úcolumnrø   rI   rJ   rb  %  s   ýÿ)r…   r7   Úgridro  rN  Úadd_row)rF   ry  Útable_columnsr�  rI   rø   rJ   rœ    s    	ú
úÿ
zProgress.make_tasks_tablec                 C   s2   | j � |  ¡ W  d  ƒ S 1 s$0    Y  dS )z+Makes the Progress class itself renderable.N)rZ  rp  rV   rI   rI   rJ   Ú__rich__0  s    zProgress.__rich__r]  )ro   rU   rp   rC   rN  rP  rL   c           	      K   s†   | j �d t| j|||||| j| j d�}|| j| j< |rB|  | j¡ | j}tt| jƒd ƒ| _W d  ƒ n1 sp0    Y  |  ¡  |S )a  Add a new 'task' to the Progress display.

        Args:
            description (str): A description of the task.
            start (bool, optional): Start the task immediately (to calculate elapsed time). If set to False,
                you will need to call `start` manually. Defaults to True.
            total (float, optional): Number of total steps in the progress if known.
                Set to None to render a pulsing animation. Defaults to 100.
            completed (int, optional): Number of steps completed so far. Defaults to 0.
            visible (bool, optional): Enable display of the task. Defaults to True.
            **fields (str): Additional data fields required for rendering.

        Returns:
            TaskID: An ID you can use when calling `update`.
        )rN  rP  rM  rZ  r)   N)	rZ  rÐ   rs  rt   rr  r’  r:   r´   rM   )	rF   ro   rU   rp   rC   rN  rP  rˆ   Únew_task_indexrI   rI   rJ   r  5  s$    ø
2zProgress.add_taskc                 C   s2   | j � | j|= W d  ƒ n1 s$0    Y  dS )z]Delete a task if it exists.

        Args:
            task_id (TaskID): A task ID.

        N)rZ  rr  )rF   r@   rI   rI   rJ   Úremove_task`  s    zProgress.remove_task)NNrg   rm   )N)rœ   NNN)rœ   NNN)rÁ   rœ   NNN)r)   )Tr]  r   T);r`   ra   rb   rc   r%   rµ   rÉ   r   r,   r±   rd   rj  rE   r  r"   rq  r³   rr   r   rÐ   ry  r:   r{  rí   rU   rº   rW   r#   re   r   r_   r   r;   r    r„   r   r´   r¾   ÚtypingÚoverloadr²   r(   rÇ   r!   r’  r“  r   rP   r™  rN   rM   r/   rp  r›  r7   rœ  r¥  r  r§  rI   rI   rI   rJ   r>     sn  ô
ó$
û    úù1 ýúù*    ù	õô    ù	õô     ù	õ
ôM÷õAøö'!    úø+r>   Ú__main__)ÚPanel)ÚRule)ÚSyntax)r7   a~  def loop_last(values: Iterable[T]) -> Iterable[Tuple[bool, T]]:
    """Iterate and generate a tuple with a flag for last value."""
    iter_values = iter(values)
    try:
        previous_value = next(iter_values)
    except StopIteration:
        return
    for value in iter_values:
        yield False, previous_value
        previous_value = value
    yield True, previous_valueÚpython)Úline_numbersZfooÚbarZbazÚ1Ú2Ú3z:Text may be printed while the progress bars are rendering.z(In fact, [i]any[/i] renderable will workzSuch as [magenta]tables[/]...zPretty printed structures...ZexamplezPretty printed)Útyperî   z	Syntax...zGive it a try!)Úcycle)Úrecord)rr   rs   z[red]Downloadingr  r~  z[green]Processingz[yellow]Thinkingr  r�   g333333Ó?g{®Gáz„?éd   )rg   NTNFNrh   ri   rj   rk   rl   rm   FT)rœ   NNN)rœ   NNN)rÁ   rœ   NNN)‡r�  Úsysr¨  r‹  Úabcr   r   Úcollectionsr   Úcollections.abcr   Údataclassesr   r   Údatetimer	   r
   r   Úmathr   r   Úosr   r   Ú	threadingr   r   r   Útypesr   r   r   r   r   r   r   r   r   r   r   r   r   r    r!   r"   r#   r$   r%   Úversion_infor(   Zpip._vendor.typing_extensionsrÜ   r*   r+   rr   r,   r-   r.   r/   rô   r0   Újupyterr1   rt  r2   Úprogress_barr3   rè   r4   rv   r5   r�  r6   r7   rî   r8   r9   r´   r:   r;   rd   rj  r<   r=   rµ   r±   r„   r†   r¸   r¾   r©  r²   rÇ   rÉ   rÛ   rß   r   r�   r  r‚   rƒ   r%  r*  r+  r½   rK  rL  rÐ   r>   r`   ÚrandomÚtimeÚpanelr«  Úruler¬  Úsyntaxr­  r£  Zprogress_renderablesÚ	itertoolsrµ  Zexamplesrq  r?   r  Ztask1Ztask2Ztask3rí   rP   ÚsleepÚrandintrv  r�   rI   rI   rI   rJ   Ú<module>   s.  P
*              ñðFdòñA    úíì    úíì     úíìV*2*I0		1	}    U
ó÷
ÿþýû
