U
    „}ag:é  ã                   @   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
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 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_ƒ fel {¡ ebƒ fž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 5 Q R X dS )ˆé    N)ÚABCÚabstractmethod©Údeque)Ú	dataclassÚfield)Ú	timedelta)Ú	RawIOBaseÚUnsupportedOperation)Úceil)Úmmap)Úlength_hint)Ú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__© úQ/var/www/html/publicvenv/lib/python3.8/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   Z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 rR   )rB   ÚsetÚjoin©rF   rX   rY   rZ   rI   rI   rJ   Ú__exit__]   s    
z_TrackThread.__exit__)Ú__name__Ú
__module__Ú__qualname__Ú__doc__ÚfloatrE   rQ   rV   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dd�f¡ t||||||pLd|dœŽ}|� |j| |||d�E d	H  W 5 Q R X 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}©ru   rv   rw   rx   )rz   T)Úelapsed_when_finishedrg   ©rp   rq   rr   rs   rt   ry   )ro   rn   rA   N)Ú
TextColumnÚextendÚ	BarColumnÚTaskProgressColumnÚTimeRemainingColumnr>   Útrack)rm   rn   ro   rp   rq   rr   rs   rt   ru   rv   rw   rx   rA   ry   rz   Úcolumnsr?   rI   rI   rJ   r„   g   s:    (ÿüøÿù
   ÿ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 rR   )r‡   rV   rU   rI   rI   rJ   rV   ½   s    
z_Reader.__enter__rW   c                 C   s   |   ¡  d S rR   )Úcloser]   rI   rI   rJ   r^   Á   s    z_Reader.__exit__c                 C   s   | S rR   rI   rU   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 rR   )r‹   rU   rI   rI   rJ   ÚclosedÑ   s    z_Reader.closedc                 C   s
   | j  ¡ S rR   )r‡   ÚfilenorU   rI   rI   rJ   r•   Õ   s    z_Reader.filenoc                 C   s
   | j  ¡ S rR   )r‡   ÚisattyrU   rI   rI   rJ   r–   Ø   s    z_Reader.isattyc                 C   s   | j jS rR   )r‡   ÚmoderU   rI   rI   rJ   r—   Û   s    z_Reader.modec                 C   s   | j jS rR   )r‡   ÚnamerU   rI   rI   rJ   r˜   ß   s    z_Reader.namec                 C   s
   | j  ¡ S rR   )r‡   ÚreadablerU   rI   rI   rJ   r™   ã   s    z_Reader.readablec                 C   s
   | j  ¡ S rR   )r‡   ÚseekablerU   rI   rI   rJ   rš   æ   s    z_Reader.seekablec                 C   s   dS rŠ   rI   rU   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‹   rU   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 rR   )r‡   ÚtellrU   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_   r`   ra   rb   r   r:   ÚboolrE   rV   r   r#   rd   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 rR   )r?   r¹   )rF   r?   r¹   rI   rI   rJ   rE     s    z_ReadContext.__init__rK   c                 C   s   | j  ¡  | j ¡ S rR   )r?   rT   r¹   rV   rU   rI   rI   rJ   rV     s    
z_ReadContext.__enter__rW   c                 C   s   | j  ¡  | j |||¡ d S rR   )r?   Ústopr¹   r^   r]   rI   rI   rJ   r^     s    
z_ReadContext.__exit__)r_   r`   ra   rb   r<   rE   rV   r   r#   rd   r   r^   rI   rI   rI   rJ   r¸     s   
ûr¸   ú
Reading...)rn   rp   rq   rr   rs   rt   ru   rv   rw   rx   ry   )Úfilero   rn   rp   rq   rr   rs   rt   ru   rv   rw   rx   ry   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|   rg   r~   )ro   rn   )r   r€   r�   ÚDownloadColumnrƒ   r>   Ú	wrap_filer¸   )r¼   ro   rn   rp   rq   rr   rs   rt   ru   rv   rw   rx   ry   r…   r?   r¹   rI   rI   rJ   r¾   &  s0    %ÿüøÿù
r¾   rœ   )ro   rn   rp   rq   rr   rs   rt   ru   rv   rw   rx   ry   úPathLike[str]ÚrtÚr)r¼   r—   Ú	bufferingÚencodingÚerrorsÚnewlinero   rn   rp   rq   rr   rs   rt   ru   rv   rw   rx   ry   rL   c                C   s   d S rR   rI   ©r¼   r—   rÂ   rÃ   rÄ   rÅ   ro   rn   rp   rq   rr   rs   rt   ru   rv   rw   rx   ry   rI   rI   rJ   Úopeng  s    rÇ   Úrbc                C   s   d S rR   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|   rg   r~   )r—   rÂ   rÃ   rÄ   rÅ   ro   rn   )r   r€   r�   r½   rƒ   r>   rÇ   r¸   )r¼   r—   rÂ   rÃ   rÄ   rÅ   ro   rn   rp   rq   rr   rs   rt   ru   rv   rw   rx   ry   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 rR   )Ú_table_columnÚ_renderable_cacheZ_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   rU   rI   rI   rJ   Úget_table_columnù  s    zProgressColumn.get_table_columnÚTask©rˆ   rL   c                 C   sr   |  ¡ }| jdk	rT|jsTz| j|j \}}W n tk
r@   Y nX || j |krT|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)rs   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_   r`   ra   rb   rÊ   r   rc   Ú__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 rR   )rÖ   rØ   rI   rI   rJ   rÓ   &  s    zRenderableColumn.render)rÛ   )
r_   r`   ra   rb   r/   r   r6   rE   rÓ   re   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_nameru   ÚspeedÚfinished_textrË   c                    s<   t |||d�| _t|tƒr$t |¡n|| _tƒ j|d� d S )N©ru   rä   rÜ   )	r4   ÚspinnerÚ
isinstancerµ   r8   Úfrom_markuprå   rD   rE   )rF   rã   ru   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 rR   )Úfinishedrå   rç   rÓ   rs   )rF   rˆ   ÚtextrI   rI   rJ   rÓ   S  s
    ÿýzSpinnerColumn.render)rß   rà   rá   râ   N)rà   rá   )r_   r`   ra   rb   rµ   r   r5   rc   r9   r6   rE   rë   r/   rÓ   re   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_formatru   ÚjustifyÚmarkupÚhighlighterrË   rL   c                    s:   || _ || _|| _|| _|| _tƒ j|p0tdd�d� d S )NT©Úno_wraprÜ   )rð   rñ   ru   rò   ró   rD   rE   r6   )rF   rð   ru   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ˆ   )ru   rñ   )	rð   Úformatrò   r8   ré   ru   rñ   ró   Ú	highlight)rF   rˆ   Ú_textrí   rI   rI   rJ   rÓ   o  s    zTextColumn.render)rî   rï   TNN)r_   r`   ra   rb   rµ   r5   r.   r±   r   r0   r6   rE   r8   rÓ   re   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".
    é(   rh   ri   rj   rk   N)Ú	bar_widthru   rv   rw   rx   rË   rL   c                    s0   || _ || _|| _|| _|| _tƒ j|d� d S rÝ   )rü   ru   rv   rw   rx   rD   rE   )rF   rü   ru   rv   rw   rx   rË   rG   rI   rJ   rE   …  s    	zBarColumn.__init__rÏ   rÐ   c                 C   s^   t |jdk	rtd|jƒndtd|jƒ| jdkr2dn
td| jƒ|j | ¡ | j| j| j	| j
d�	S )z&Gets a progress bar widget for a task.Nr   r)   )	ro   rC   ÚwidthZpulseZanimation_timeru   rv   rw   rx   )r3   ro   ÚmaxrC   rü   Ústartedrs   ru   rv   rw   rx   rØ   rI   rI   rJ   rÓ   •  s    
÷zBarColumn.render)rû   rh   ri   rj   rk   N)r_   r`   ra   rb   r   r´   r5   r6   rE   r3   rÓ   re   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kr&tddd�S tt|ƒd�}tt|ƒdd�S )zShow time elapsed.Nú-:--:--úprogress.elapsed©ru   )Úseconds)rì   Úfinished_timeÚelapsedr8   r   r´   rµ   )rF   rˆ   r  ÚdeltarI   rI   rJ   rÓ   §  s
    zTimeElapsedColumn.renderN©r_   r`   ra   rb   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_percentageru   rñ   rò   ró   rË   rz   rL   c	           	         s(   || _ || _tƒ j||||||d� d S )N)rð   ru   rñ   rò   ró   rË   )r
  rz   rD   rE   )	rF   rð   r
  ru   rñ   rò   ró   rË   rz   rG   rI   rJ   rE   ¾  s    úzTaskProgressColumn.__init__)rä   rL   c                 C   sT   |dkrt ddd�S t t|ƒdddddg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  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 kr"| jr"|  |jp|j¡S |j d kr2| jn| j}|j|d�}| jr`t	j
|| j| jd�}nt	|| j| jd�}| jr„| j |¡ |S rö   )ro   rz   r  Úfinished_speedrä   r
  rð   rø   rò   r8   ré   ru   rñ   ró   rù   )rF   rˆ   rð   rú   rí   rI   rI   rJ   rÓ   é  s    ÿzTaskProgressColumn.render)r	  rÛ   rî   rï   TNNF)r_   r`   ra   rb   rµ   r5   r.   r±   r   r0   r6   rE   Úclassmethodrc   r8   r  rÓ   re   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)Úcompactr}   rË   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kr8td|d�S |dk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 )zShow time remaining.r  zprogress.remainingNrÛ   r  z--:--r  é<   Z02dú:Úd)	r}   rì   r  Útime_remainingro   r8   r  Údivmodr´   )rF   rˆ   Z	task_timeru   Úminutesr  ÚhoursÚ	formattedrI   rI   rJ   rÓ     s    

zTimeRemainingColumn.render)FFN)r_   r`   ra   rb   rÊ   r±   r   r6   rE   r8   rÓ   re   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k	rt t|j ƒ¡nd}t|dd�S )r  NrÛ   zprogress.filesize.totalr  )ro   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k	rt |jƒnd}tt|ƒƒ}t||› d�›| j› |› �dd�S )zShow completed/total.Nú?r  úprogress.downloadr  )r´   rC   ro   r‘   rµ   r8   r&  )rF   rˆ   rC   ro   Útotal_widthrI   rI   rJ   rÓ   K  s    
þzMofNCompleteColumn.render)r%  N)r_   r`   ra   rb   rµ   r   r6   rE   r8   rÓ   re   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Ý   )r*  rD   rE   )rF   r*  rË   rG   rI   rJ   rE   ]  s    zDownloadColumn.__init__rÏ   rÐ   c                 C   sð   t |jƒ}|jdk	rt |jƒn|}| jrNt |dddddddd	d
g	d¡\}}n$t |dddddddddg	d¡\}}|dkr~dnd}|| }|d|› d�›}|jdk	rÈt |jƒ}	|	| }
|
d|› d�›}nd}|› d|› d|› �}t|dd�}|S )z.Calculate common unit for completed and total.Nr²   ZKiBZMiBZGiBZTiBZPiBZEiBZZiBZYiBi   ZkBZMBZGBZTBZPBZEBZZBZYBr  r)   r   z,.Úfr'  r%  râ   r(  r  )r´   rC   ro   r*  r*   r  r8   )rF   rˆ   rC   Z unit_and_suffix_calculation_baser  r  Z	precisionZcompleted_ratioZcompleted_strro   Útotal_ratioZ	total_strZdownload_statusZdownload_textrI   rI   rJ   rÓ   c  s2    
ÿý
ý

zDownloadColumn.render)FN)r_   r`   ra   rb   r±   r   r6   rE   r8   rÓ   re   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k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   r-  ‡  s   r-  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_   r`   ra   rb   rc   rÙ   rI   rI   rI   rJ   r.  “  s   
r.  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Ñ   rn   ro   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>)r1  r4  r5  Ú	_progress)r5  r1  Ú_lockrK   c                 C   s   |   ¡ S )z(float: Get the current time, in seconds.)r/  rU   rI   rI   rJ   rs   Ì  s    zTask.get_timec                 C   s
   | j dk	S )z#bool: Check if the task as started.N)r6  rU   rI   rI   rJ   rÿ   Ð  s    zTask.startedc                 C   s   | j dkrdS | j | j S )zPOptional[float]: Get the number of steps remaining, if a non-None total was set.N)ro   rC   rU   rI   rI   rJ   Ú	remainingÕ  s    
zTask.remainingc                 C   s2   | j dkrdS | jdk	r$| j| j  S |  ¡ | j  S )z]Optional[float]: Time elapsed since task was started, or ``None`` if the task hasn't started.N)r6  r7  rs   rU   rI   rI   rJ   r  Ü  s
    

zTask.elapsedc                 C   s
   | j dk	S )zCheck if the task has finished.N)r  rU   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@)ro   rC   Úminrþ   )rF   rC   rI   rI   rJ   Ú
percentageê  s
    zTask.percentagec              
   C   sœ   | j dkrdS | j�~ | j}|s.W 5 Q R £ dS |d j|d j }|dkrXW 5 Q R £ dS t|ƒ}t|ƒ tdd„ |D ƒƒ}|| }|W  5 Q R £ S Q R X dS )z=Optional[float]: Get the estimated speed in steps per second.Nrœ   r   c                 s   s   | ]}|j V  qd S rR   r«   )Ú.0ÚsamplerI   rI   rJ   Ú	<genexpr>  s     zTask.speed.<locals>.<genexpr>)r6  r<  r;  rÕ   Úiterr�   r¦   )rF   r?   Z
total_timeZiter_progressZtotal_completedrä   rI   rI   rJ   rä   ó  s    
z
Task.speedc                 C   s:   | j r
dS | j}|sdS | j}|dk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=  ZestimaterI   rI   rJ   r    s    zTask.time_remainingc                 C   s   | j  ¡  d| _d| _dS )zReset progress.N)r;  Úclearr  r  rU   rI   rI   rJ   Ú_reset  s    
zTask._reset)$r_   r`   ra   rb   r:   rÙ   rµ   r   rc   ÚGetTimeCallabler  r0  r±   r   Údictr2  r   r   r6  r7  r  r;  r   r.  r   r<  rs   r³   rÿ   r=  r  rì   rA  rä   r  rG  rI   rI   rI   rJ   rÏ   œ  sD   
  ÿ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.
    NTrg   g      >@F)
rq   rp   rt   Úspeed_estimate_periodrr   Úredirect_stdoutÚredirect_stderrrs   ry   Úexpand)r…   rq   rp   rt   rJ  rr   rK  rL  rs   ry   rM  rL   c       
      	   G   sŽ   |dkst 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)rq   rp   rt   rr   rK  rL  Úget_renderable)ÚAssertionErrorr   r<  Úget_default_columnsr…   rJ  ry   rM  Ú_tasksr:   Ú_task_indexr2   r+   rN  Úliverq   rs   ÚprintÚlog)rF   rq   rp   rt   rJ  rr   rK  rL  rs   ry   rM  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   rP  N  s
    üzProgress.get_default_columnsc                 C   s   | j jS rR   )rS  rq   rU   rI   rI   rJ   rq   m  s    zProgress.consolec              
   C   s,   | j � t| j ¡ ƒW  5 Q R £ S Q R X dS )zGet a list of Task instances.N)r<  ÚlistrQ  ÚvaluesrU   rI   rI   rJ   Útasksq  s    zProgress.tasksc              
   C   s,   | j � t| j ¡ ƒW  5 Q R £ S Q R X dS )zA list of task IDs.N)r<  rV  rQ  ÚkeysrU   rI   rI   rJ   Útask_idsw  s    zProgress.task_idsc              
   C   sJ   | j �: | jsW 5 Q R £ dS tdd„ | j ¡ D ƒƒW  5 Q R £ S Q R X dS )z'Check if all tasks have been completed.Tc                 s   s   | ]}|j V  qd S rR   )rì   )rB  rˆ   rI   rI   rJ   rD  ƒ  s     z$Progress.finished.<locals>.<genexpr>N)r<  rQ  ÚallrW  rU   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)ry   rS  rT   rU   rI   rI   rJ   rT   …  s    zProgress.startc                 C   s    | j  ¡  | jjs| j ¡  dS )zStop the progress display.N)rS  rº   rq   Úis_interactiverT  rU   rI   rI   rJ   rº   Š  s    
zProgress.stopc                 C   s   |   ¡  | S rR   rS   rU   rI   rI   rJ   rV   �  s    zProgress.__enter__rW   c                 C   s   |   ¡  d S rR   )rº   r]   rI   rI   rJ   r^   ”  s    zProgress.__exit__rf   rl   )rm   ro   r@   rn   rA   rL   c           
   	   c   s®   |dkrt t|ƒƒpd}|dkr0| j||d�}n| j||d� | jjr~t| ||ƒ�$}|D ]}|V  | jd7  _qXW 5 Q R X 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©ro   r)   )
rc   r   Úadd_taskrP   rS  rp   r=   rC   rN   rM   )
rF   rm   ro   r@   rn   rA   Ztrack_threadÚvaluerN   rM   rI   rI   rJ   r„   œ  s     
zProgress.trackr»   )r@   rn   )r¼   ro   r@   rn   rL   c             	   C   s~   d}|dk	r|}n&|dk	r8| j � | j| j}W 5 Q R X |dkrHtdƒ‚|dkr`| 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‰   )r<  rQ  ro   Ú
ValueErrorr^  rP   r†   )rF   r¼   ro   r@   rn   Útotal_bytesrI   rI   rJ   r¾   Å  s    ÿzProgress.wrap_filerœ   )ro   r@   rn   r¿   rÈ   )
r¼   r—   rÂ   rÃ   rÄ   rÅ   ro   r@   rn   rL   c          
      C   s   d S rR   rI   ©
rF   r¼   r—   rÂ   rÃ   rÄ   rÅ   ro   r@   rn   rI   rI   rJ   rÇ   ï  s    zProgress.openrÁ   rÀ   c          
      C   s   d S rR   rI   rc  rI   rI   rJ   rÇ   ÿ  s    c                C   sð   d  t|dd�¡}
|
dkr(td |¡ƒ‚|dk}|
dkrR|dkrRt dt¡ d	}n&|
d
krx|dkrltdƒ‚n|dkrxd	}|dkrŠt|ƒj}|dkr¢| j	|	|d�}n| j
||d� tj|d|d�}t|| |dd�}|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)   re  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Ã   rÄ   rÅ   Úline_buffering)r\   Úsortedra  rø   ÚwarningsÚwarnÚRuntimeWarningr   Úst_sizer^  rP   ÚiorÇ   r†   ÚTextIOWrapper)rF   r¼   r—   rÂ   rÃ   rÄ   rÅ   ro   r@   rn   Ú_moderf  r‡   r¹   rI   rI   rJ   rÇ     s>    !þ

û)r@   rL   c              	   C   s4   | j �$ | j| }|jdkr&|  ¡ |_W 5 Q R X 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)r<  rQ  r6  rs   )rF   r@   rˆ   rI   rI   rJ   Ú
start_task\  s    	

zProgress.start_taskc              	   C   s>   | j �. | j| }|  ¡ }|jdkr*||_||_W 5 Q R X dS )z†Stop a task.

        This will freeze the elapsed time on the task.

        Args:
            task_id (TaskID): ID of task.
        N)r<  rQ  rs   r6  r7  )rF   r@   rˆ   rÔ   rI   rI   rJ   Ú	stop_taskj  s    

zProgress.stop_task)ro   rC   rN   rn   r0  rM   )	r@   ro   rC   rN   rn   r0  rM   r2  rL   c             	   K   s*  | j ��
 | j| }	|	j}
|dk	r:||	jkr:||	_|	 ¡  |dk	rP|	 j|7  _|dk	r^||	_|dk	rl||	_|dk	rz||	_|	j |¡ |	j|
 }|  	¡ }|| j
 }|	j}|j}|rÈ|d j|k rÈ|ƒ  q®|dkrà| t||ƒ¡ |	jdk	�r|	j|	jk�r|	jdk�r|	j|	_W 5 Q R X |�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   )r<  rQ  rC   ro   rG  rn   r0  r2  rP   rs   rJ  r;  ÚpopleftrÕ   Úappendr.  r  r  rM   )rF   r@   ro   rC   rN   rn   r0  rM   r2  rˆ   Úcompleted_startÚupdate_completedrÔ   Úold_sample_timer;  rq  rI   rI   rJ   rP   y  sB    



ÿ
þýzProgress.updater   )rT   ro   rC   r0  rn   )r@   rT   ro   rC   r0  rn   r2  rL   c          
   	   K   s†   |   ¡ }| j�f | j| }	|	 ¡  |r*|nd|	_|dk	r>||	_||	_|dk	rR||	_|r\||	_|dk	rj||	_	d|	_
W 5 Q R X |  ¡  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)rs   r<  rQ  rG  r6  ro   rC   r0  r2  rn   r  rM   )
rF   r@   rT   ro   rC   r0  rn   r2  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k	r¼|j|jkr¼|jdkr¼|j|_|j|_W 5 Q R X 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)rs   r<  rQ  rC   rJ  r;  rq  rÕ   r‘   rr  r.  ro   r  r  rä   r  )
rF   r@   rN   rÔ   rˆ   rs  rt  ru  r;  rq  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)ry   rS  Z
is_startedrM   rU   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   rN     s    zProgress.get_renderablec                 c   s   |   | j¡}|V  dS )z5Get a number of renderables for the progress display.N)Úmake_tasks_tablerX  )rF   ÚtablerI   rI   rJ   rw    s    zProgress.get_renderables)rX  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)rB  Z_columnrI   rI   rJ   rD    s   ýÿz,Progress.make_tasks_table.<locals>.<genexpr>)r   r)   )ÚpaddingrM  c                 3   s,   | ]$}t |tƒr|jˆ d �n|ˆ ƒV  qdS )r÷   N)rè   rµ   rø   )rB  Úcolumnr÷   rI   rJ   rD     s   ýÿ)r…   r7   ÚgridrM  r0  Úadd_row)rF   rX  Ztable_columnsry  rI   r÷   rJ   rx  
  s    	ú
úÿ
zProgress.make_tasks_tablec              
   C   s&   | j � |  ¡ W  5 Q R £ S Q R X dS )z+Makes the Progress class itself renderable.N)r<  rN  rU   rI   rI   rJ   Ú__rich__+  s    zProgress.__rich__r?  )rn   rT   ro   rC   r0  r2  rL   c           	      K   sr   | j �Z t| j|||||| j| j d�}|| j| j< |rB|  | j¡ | j}tt| jƒd ƒ| _W 5 Q R X |  ¡  |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`.
        )r0  r2  r/  r<  r)   )	r<  rÏ   rR  rs   rQ  ro  r:   r´   rM   )	rF   rn   rT   ro   rC   r0  r2  rˆ   Znew_task_indexrI   rI   rJ   r^  0  s$    ø
zProgress.add_taskc              	   C   s   | j � | j|= W 5 Q R X dS )z]Delete a task if it exists.

        Args:
            task_id (TaskID): A task ID.

        N)r<  rQ  )rF   r@   rI   rI   rJ   Úremove_task[  s    zProgress.remove_task)NNrf   rl   )N)rœ   NNN)rœ   NNN)rÁ   rœ   NNN)r)   )Tr?  r   T);r_   r`   ra   rb   r%   rµ   rÉ   r   r,   r±   rc   rH  rE   r  r"   rP  r³   rq   r   rÏ   rX  r:   rZ  rì   rT   rº   rV   r#   rd   r   r^   r   r;   r    r„   r   r´   r¾   ÚtypingÚoverloadr²   r(   rÇ   r!   ro  rp  r   rP   rv  rN   rM   r/   rN  rw  r7   rx  r  r^  r€  rI   rI   rI   rJ   r>     sn  ô
ó$
û    úù, ýúù*    ù	õô    ù	õô     ù	õ
ô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fooZ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)rq   rr   z[red]Downloadingr  r]  z[green]Processingz[yellow]Thinkingr  r�   g333333Ó?g{®Gáz„?éd   )rf   NTNFNrg   rh   ri   rj   rk   rl   FT)rœ   NNN)rœ   NNN)rÁ   rœ   NNN)‡rl  Úsysr�  rh  Úabcr   r   Úcollectionsr   Údataclassesr   r   Údatetimer   r	   r
   Úmathr   r   Úoperatorr   Ú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+   rq   r,   r-   r.   r/   ró   r0   Újupyterr1   rS  r2   Úprogress_barr3   rç   r4   ru   r5   ry  r6   r7   rí   r8   r9   r´   r:   r;   rc   rH  r<   r=   rµ   r±   r„   r†   r¸   r¾   r‚  r²   rÇ   rÉ   rÚ   rÞ   r   r�   r   r‚   rƒ   r  r#  r$  r½   r-  r.  rÏ   r>   r_   ÚrandomÚtimeÚpanelr„  Úruler…  Úsyntaxr†  r~  Zprogress_renderablesÚ	itertoolsr�  ZexamplesrP  r?   r^  Ztask1Ztask2Ztask3rì   rP   ÚsleepÚrandintrU  r�   rI   rI   rI   rJ   Ú<module>   s,  P
*              ñðFdòñA    úíì    úíì     úíìV*2*I0		1	}    P
ó÷
ÿýû
