U
    ƒIÀ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
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__© úR/home/sam/Atlas/atlas_env/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   Ú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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}©rv   rw   rx   ry   )r{   T)Úelapsed_when_finishedrh   ©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   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 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   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)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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)   )	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kr&tddd�S tt|ƒd�}tt|ƒdd�S )zShow time elapsed.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   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ø   )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)Ú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  é<   Ú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k	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k	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ß   )r0  rD   rE   )rF   r0  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³   ÚKiBÚMiBÚGiBÚTiBÚPiBÚEiBÚZiBÚYiBi   ÚkBÚMBÚGBÚTBÚPBÚEBÚZBÚYBr  r)   r   z,.Úfr-  r+  rä   r.  r  )rµ   rC   rp   r0  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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   rJ  ‡  s   rJ  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   rK  “  s   
rK  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>)rN  rQ  rR  Ú	_progress)rR  rN  Ú_lockrK   c                 C   s   |   ¡ S )z(float: Get the current time, in seconds.)rL  rV   rI   rI   rJ   rt   Ì  s    zTask.get_timec                 C   s
   | j dk	S )z#bool: Check if the task as started.N)rS  rV   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)rp   rC   rV   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)rS  rT  rt   rV   rI   rI   rJ   r
  Ü  s
    

zTask.elapsedc                 C   s
   | j dk	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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 rS   r¬   )Ú.0ÚsamplerI   rI   rJ   Ú	<genexpr>  s     zTask.speed.<locals>.<genexpr>)rS  rY  rX  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kr*dS t|| ƒ}|S )zJOptional[float]: Get estimated time to completion, or ``None`` if no data.r[  N)rî   ræ   rZ  r   )rF   ræ   rZ  ÚestimaterI   rI   rJ   r    s    zTask.time_remainingc                 C   s   | j  ¡  d| _d| _dS )zReset progress.N)rX  Úclearr	  r  rV   rI   rI   rJ   Ú_reset  s    
zTask._reset)$r`   ra   rb   rc   r:   rÛ   r¶   r   rd   ÚGetTimeCallabler	  rM  r²   r   ÚdictrO  r   r   rS  rT  r  rX  r   rK  r   rY  rt   r´   r  rZ  r
  rî   r^  ræ   r  rh  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.
    NTrh   g      >@F)
rr   rq   ru   Úspeed_estimate_periodrs   Úredirect_stdoutÚredirect_stderrrt   rz   Úexpand)r†   rr   rq   ru   rk  rs   rl  rm  rt   rz   rn  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)rr   rq   ru   rs   rl  rm  Úget_renderable)ÚAssertionErrorr   rY  Úget_default_columnsr†   rk  rz   rn  Ú_tasksr:   Ú_task_indexr2   r+   ro  Úliverr   rt   ÚprintÚlog)rF   rr   rq   ru   rk  rs   rl  rm  rt   rz   rn  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   s,   | j � t| j ¡ ƒW  5 Q R £ S Q R X dS )zGet a list of Task instances.N)rY  Úlistrr  ÚvaluesrV   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)rY  rw  rr  ÚkeysrV   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 rS   )rî   )r_  r‰   rI   rI   rJ   ra  ƒ  s     z$Progress.finished.<locals>.<genexpr>N)rY  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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©rp   r)   )
rd   r   Úadd_taskrP   rt  rq   r=   rC   rN   rM   )
rF   rn   rp   r@   ro   rA   Útrack_threadÚvaluerN   rM   rI   rI   rJ   r…   œ  s     
zProgress.trackr¼   )r@   ro   )r½   rp   r@   ro   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Š   )rY  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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)   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Ä   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   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)rY  rr  rS  rt   )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)rY  rr  rt   rS  rT  )rF   r@   r‰   rÖ   rI   rI   rJ   Ú	stop_taskj  s    

zProgress.stop_task)rp   rC   rN   ro   rM  rM   )	r@   rp   rC   rN   ro   rM  rM   rO  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   )rY  rr  rC   rp   rh  ro   rM  rO  rP   rt   rk  rX  Úpopleftr×   ÚappendrK  r	  r
  rM   )rF   r@   rp   rC   rN   ro   rM  rM   rO  r‰   Úcompleted_startÚupdate_completedrÖ   Úold_sample_timerX  r“  rI   rI   rJ   rP   y  sB    



ÿ
þýzProgress.updater   )rU   rp   rC   rM  ro   )r@   rU   rp   rC   rM  ro   rO  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)rt   rY  rr  rh  rS  rp   rC   rM  rO  ro   r	  rM   )
rF   r@   rU   rp   rC   rM  ro   rO  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)rt   rY  rr  rC   rk  rX  r“  r×   r’   r”  rK  rp   r	  r
  ræ   r  )
rF   r@   rN   rÖ   r‰   r•  r–  r—  rX  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   ro     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   ra    s   ýÿz,Progress.make_tasks_table.<locals>.<genexpr>)r   r)   )Úpaddingrn  c                 3   s,   | ]$}t |tƒr|jˆ d �n|ˆ ƒV  qdS )rù   N)rê   r¶   rú   )r_  Úcolumnrù   rI   rJ   ra     s   ýÿ)r†   r7   Úgridrn  rM  Úadd_row)rF   ry  Útable_columnsrœ  rI   rù   rJ   r›  
  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)rY  ro  rV   rI   rI   rJ   Ú__rich__+  s    zProgress.__rich__r\  )ro   rU   rp   rC   rM  rO  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`.
        )rM  rO  rL  rY  r)   )	rY  rÑ   rs  rt   rr  r‘  r:   rµ   rM   )	rF   ro   rU   rp   rC   rM  rO  r‰   Ú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)rY  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   ri  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/   ro  rš  r7   r›  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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   Ú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+   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   ri  r<   r=   r¶   r²   r…   r‡   r¹   r¿   r¨  r³   rÈ   rÊ   rÜ   rà   r€   r‚   r  rƒ   r„   r$  r)  r*  r¾   rJ  rK  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	}    P
ó÷
ÿýû
