o
    kôjéë  ã                   @  sž  d dl m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/m0Z0m1Z1 er’d dl2m3Z3 ddl4m5Z5m6Z6 ddl7m8Z8m9Z9m:Z:m;Z; ddl<m=Z= ddl>m?Z? ddl@mAZA ddlBmCZC ddlDmEZE ddlFmGZG ddlHmIZImJZJ ddlKmLZLmMZM e+deNƒZOe0dƒZPe"g eQf ZRe 0de-e!¡ZSG dd„ deƒZT	 		 	!		"		#	$	%	&	'	(	"	!d¨d©dCdD„ZUG dEdF„ dFee!ƒZVG dGdH„ dHe#eS e&eS ƒZWdId!dd"dd#d$d%d&d'd"dJœdªdNdO„ZXejY	P			d«ddId!dd"dd#d$d%d&d'd"dQœd¬d\d]„ƒZZejY	P			d«ddId!dd"dd#d$d%d&d'd"dQœd­d_d]„ƒZZ	`	P			d®ddId!dd"dd#d$d%d&d'd"dQœd¯dcd]„ZZG ddde„ deeƒZ[G dfdg„ dge[ƒZ\G dhdi„ die[ƒZ]G djdk„ dke[ƒZ^G dldm„ dme[ƒZ_G dndo„ doe[ƒZ`G dpdq„ dqe^ƒZaG drds„ dse[ƒZbG dtdu„ due[ƒZcG dvdw„ dwe[ƒZdG dxdy„ dye[ƒZeG dzd{„ d{e[ƒZfG d|d}„ d}e[ƒZgG d~d„ de*ƒZheG d€d�„ d�ƒƒZiG d‚dƒ„ dƒe?ƒZjekd„k�rÍd dllZld dlmZmdd…lnmoZo dd†lpmqZq dd‡lrmsZs ddˆlHmJZJ esd‰dŠd!d‹�ZreJdŒd�dŽƒZHeH td�d�d‘¡ d’eod“ƒd”eHd•d–d—d˜œd™ereqdšƒg	Zud d›lvmwZw eweuƒZxe8d!dœ�Z7eje]ƒ gej y¡ ¢e`ƒ ‘R e7d"d�œŽ�QZzezj{dždŸd �Z|ezj{d¡dŸd �Z}ezj{d¢dd �Z~ezj�sºezj€e|d£d¤� ezj€e}d¥d¤� em �d¦¡ el ‚d d§¡dk �r®ez ƒe„exƒ¡ ezj�r‹W d  ƒ dS W d  ƒ dS 1 �sÆw   Y  dS dS )°é    )ÚannotationsN)ÚABCÚabstractmethod©Údeque)Ú	dataclassÚfield)Ú	timedelta)Ú	RawIOBaseÚUnsupportedOperation)Úceil)Úmmap)Úlength_hint)ÚPathLikeÚstat)ÚEventÚRLockÚThread)ÚTracebackType)ÚTYPE_CHECKINGÚAnyÚBinaryIOÚCallableÚContextManagerÚDequeÚDictÚGenericÚIterableÚListÚLiteralÚ
NamedTupleÚNewTypeÚOptionalÚTextIOÚTupleÚTypeÚTypeVarÚUnion)ÚSelfé   )ÚfilesizeÚget_console)ÚConsoleÚGroupÚJustifyMethodÚRenderableType)ÚHighlighter)ÚJupyterMixin)ÚLive)ÚProgressBar)ÚSpinner)Ú	StyleType)ÚColumnÚTable)ÚTextÚTextTypeÚTaskIDÚProgressTypeÚ_Ic                      s@   e Zd ZdZd‡ fdd	„Zddd„Zddd„Zddd„Z‡  ZS )Ú_TrackThreadz)A thread to periodically update progress.Úprogressú
'Progress'Útask_idú'TaskID'Úupdate_periodÚfloatc                   s2   || _ || _|| _tƒ | _d| _tƒ jdd� d S )Nr   T)Údaemon)r>   r@   rB   r   ÚdoneÚ	completedÚsuperÚ__init__)Úselfr>   r@   rB   ©Ú	__class__© ú^/var/www/html/academy/tools/voices/clone/sv-venv/lib/python3.10/site-packages/rich/progress.pyrH   C   s   z_TrackThread.__init__ÚreturnÚNonec                 C  s~   | j }| jj}| j}d}| jj}||ƒs2| jjjr2| j}||kr)|||| ƒ |}||ƒs2| jjjs| jj	| j | jdd� d S )Nr   T)rF   Úrefresh)
r@   r>   ÚadvancerB   rE   ÚwaitÚliveÚ
is_startedrF   Úupdate)rI   r@   rQ   rB   Zlast_completedrR   rF   rL   rL   rM   ÚrunL   s   üz_TrackThread.runú'_TrackThread'c                 C  ó   |   ¡  | S ©N©Ústart©rI   rL   rL   rM   Ú	__enter__Z   ó   z_TrackThread.__enter__Úexc_typeúOptional[Type[BaseException]]Úexc_valúOptional[BaseException]Úexc_tbúOptional[TracebackType]c                 C  s   | j  ¡  |  ¡  d S rY   )rE   ÚsetÚjoin©rI   r_   ra   rc   rL   rL   rM   Ú__exit__^   s   
z_TrackThread.__exit__)r>   r?   r@   rA   rB   rC   ©rN   rO   )rN   rW   ©r_   r`   ra   rb   rc   rd   rN   rO   )	Ú__name__Ú
__module__Ú__qualname__Ú__doc__rH   rV   r]   rh   Ú__classcell__rL   rL   rJ   rM   r=   @   s    
	
r=   ú
Working...TFé
   úbar.backúbar.completeúbar.finishedú	bar.pulseçš™™™™™¹?ÚsequenceúIterable[ProgressType]ÚdescriptionÚstrÚtotalúOptional[float]rF   ÚintÚauto_refreshÚboolÚconsoleúOptional[Console]Ú	transientÚget_timeúOptional[Callable[[], float]]Úrefresh_per_secondrC   Ústyler5   Úcomplete_styleÚfinished_styleÚpulse_stylerB   ÚdisableÚ
show_speedrN   c              	   c  sœ   � |rt dƒgng }| t|	|
||d�t|d�tdd�f¡ t||||||p'd|dœŽ}|� |j| ||||d�E d	H  W d	  ƒ d	S 1 sGw   Y  d	S )
a¥  Track progress by iterating over a sequence.

    You can also track progress of an iterable, which might require that you additionally specify ``total``.

    Args:
        sequence (Iterable[ProgressType]): Values you wish to iterate over and track progress.
        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).
        completed (int, optional): Number of steps completed so far. Defaults to 0.
        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}©r†   r‡   rˆ   r‰   )r‹   T)Úelapsed_when_finishedrq   ©r~   r€   r‚   rƒ   r…   rŠ   )r{   rF   ry   rB   N)Ú
TextColumnÚextendÚ	BarColumnÚTaskProgressColumnÚTimeRemainingColumnÚProgressÚtrack)rw   ry   r{   rF   r~   r€   r‚   rƒ   r…   r†   r‡   rˆ   r‰   rB   rŠ   r‹   Úcolumnsr>   rL   rL   rM   r–   h   s@   €,ÿüøÿù
û"ÿr–   c                   @  s  e Zd ZdZ	dQdRdd„ZdSdd„ZdTdd„ZdUdd„ZdVdd„Ze	dWdd „ƒZ
dXd"d#„ZdWd$d%„Ze	dYd'd(„ƒZe	dYd)d*„ƒZdWd+d,„ZdWd-d.„ZdWd/d0„ZdZd[d3d4„Zd\d7d8„ZdZd[d9d:„ZdZd]d=d>„Zd^d?d@„Zd_d`dDdE„ZdXdFdG„ZdadJdK„ZdbdNdO„ZdPS )cÚ_Readerz9A reader that tracks progress while it's being read from.TÚhandler   r>   r?   Útaskr:   Úclose_handler   rN   rO   c                 C  s"   || _ || _|| _|| _d| _d S ©NF)r™   r>   rš   r›   Ú_closed)rI   r™   r>   rš   r›   rL   rL   rM   rH   ¹   s
   
z_Reader.__init__ú	'_Reader'c                 C  s   | j  ¡  | S rY   )r™   r]   r\   rL   rL   rM   r]   Æ   s   
z_Reader.__enter__r_   r`   ra   rb   rc   rd   c                 C  ó   |   ¡  d S rY   )Úcloserg   rL   rL   rM   rh   Ê   ó   z_Reader.__exit__c                 C  s   | S rY   rL   r\   rL   rL   rM   Ú__iter__Ò   ó   z_Reader.__iter__Úbytesc                 C  s$   t | jƒ}| jj| jt|ƒd� |S ©N©rQ   )Únextr™   r>   rQ   rš   Úlen)rI   ÚlinerL   rL   rM   Ú__next__Õ   s   
z_Reader.__next__c                 C  ó   | j S rY   )r�   r\   rL   rL   rM   ÚclosedÚ   s   z_Reader.closedr}   c                 C  ó
   | j  ¡ S rY   )r™   Úfilenor\   rL   rL   rM   r®   Þ   ó   
z_Reader.filenoc                 C  r­   rY   )r™   Úisattyr\   rL   rL   rM   r°   á   r¯   z_Reader.isattyrz   c                 C  ó   | j jS rY   )r™   Úmoder\   rL   rL   rM   r²   ä   ó   z_Reader.modec                 C  r±   rY   )r™   Únamer\   rL   rL   rM   r´   è   r³   z_Reader.namec                 C  r­   rY   )r™   Úreadabler\   rL   rL   rM   rµ   ì   r¯   z_Reader.readablec                 C  r­   rY   )r™   Úseekabler\   rL   rL   rM   r¶   ï   r¯   z_Reader.seekablec                 C  ó   dS rœ   rL   r\   rL   rL   rM   Úwritableò   r£   z_Reader.writableéÿÿÿÿÚsizec                 C  ó&   | j  |¡}| jj| jt|ƒd� |S r¥   )r™   Úreadr>   rQ   rš   r¨   )rI   rº   ÚblockrL   rL   rM   r¼   õ   ó   z_Reader.readÚbú"Union[bytearray, memoryview, mmap]c                 C  s"   | j  |¡}| jj| j|d� |S r¥   )r™   Úreadintor>   rQ   rš   )rI   r¿   ÚnrL   rL   rM   rÁ   ú   s   z_Reader.readintoc                 C  r»   r¥   )r™   Úreadliner>   rQ   rš   r¨   )rI   rº   r©   rL   rL   rM   rÃ   ÿ   r¾   z_Reader.readlineÚhintúList[bytes]c                 C  s,   | j  |¡}| jj| jttt|ƒƒd� |S r¥   )r™   Ú	readlinesr>   rQ   rš   ÚsumÚmapr¨   )rI   rÄ   ÚlinesrL   rL   rM   rÆ     s   z_Reader.readlinesc                 C  s   | j r| j ¡  d| _d S )NT)r›   r™   r    r�   r\   rL   rL   rM   r    	  s   

z_Reader.closer   ÚoffsetÚwhencec                 C  s$   | j  ||¡}| jj| j|d� |S )N©rF   )r™   Úseekr>   rU   rš   )rI   rÊ   rË   ÚposrL   rL   rM   rÍ     s   z_Reader.seekc                 C  r­   rY   )r™   Útellr\   rL   rL   rM   rÏ     r¯   z_Reader.tellÚsr   c                 C  ó   t dƒ‚)NÚwrite©r   )rI   rÐ   rL   rL   rM   rÒ     ó   z_Reader.writerÉ   úIterable[Any]c                 C  rÑ   )NÚ
writelinesrÓ   )rI   rÉ   rL   rL   rM   rÖ     rÔ   z_Reader.writelinesN)T)
r™   r   r>   r?   rš   r:   r›   r   rN   rO   )rN   rž   rj   )rN   r   )rN   r¤   ©rN   r   )rN   r}   )rN   rz   )r¹   )rº   r}   rN   r¤   )r¿   rÀ   )rÄ   r}   rN   rÅ   ri   )r   )rÊ   r}   rË   r}   rN   r}   )rÐ   r   rN   r}   )rÉ   rÕ   rN   rO   )rk   rl   rm   rn   rH   r]   rh   r¢   rª   Úpropertyr¬   r®   r°   r²   r´   rµ   r¶   r¸   r¼   rÁ   rÃ   rÆ   r    rÍ   rÏ   rÒ   rÖ   rL   rL   rL   rM   r˜   ¶   s8    û












r˜   c                   @  s.   e Zd ZdZddd	„Zdd
d„Zddd„ZdS )Ú_ReadContextzEA utility class to handle a context for both a reader and a progress.r>   r?   Úreaderr<   rN   rO   c                 C  s   || _ || _d S rY   )r>   rÚ   )rI   r>   rÚ   rL   rL   rM   rH      s   
z_ReadContext.__init__c                 C  s   | j  ¡  | j ¡ S rY   )r>   r[   rÚ   r]   r\   rL   rL   rM   r]   $  s   

z_ReadContext.__enter__r_   r`   ra   rb   rc   rd   c                 C  s   | j  ¡  | j |||¡ d S rY   )r>   ÚstoprÚ   rh   rg   rL   rL   rM   rh   (  s   
z_ReadContext.__exit__N)r>   r?   rÚ   r<   rN   rO   )rN   r<   rj   )rk   rl   rm   rn   rH   r]   rh   rL   rL   rL   rM   rÙ     s
    

rÙ   ú
Reading...)ry   r~   r€   r‚   rƒ   r…   r†   r‡   rˆ   r‰   rŠ   Úfiler   úContextManager[BinaryIO]c             	   C  sh   |rt dƒgng }| t||	|
|d�tƒ tƒ f¡ t||||||p"d|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�   rq   r�   )r{   ry   )r�   r‘   r’   ÚDownloadColumnr”   r•   Ú	wrap_filerÙ   )rÝ   r{   ry   r~   r€   r‚   rƒ   r…   r†   r‡   rˆ   r‰   rŠ   r—   r>   rÚ   rL   rL   rM   rà   2  s0   %ÿüøÿù

rà   r¹   )r{   ry   r~   r€   r‚   rƒ   r…   r†   r‡   rˆ   r‰   rŠ   ú"Union[str, 'PathLike[str]', bytes]r²   ú"Union[Literal['rt'], Literal['r']]Ú	bufferingÚencodingúOptional[str]ÚerrorsÚnewlineúOptional[int]úContextManager[TextIO]c                C  ó   d S rY   rL   ©rÝ   r²   rã   rä   ræ   rç   r{   ry   r~   r€   r‚   rƒ   r…   r†   r‡   rˆ   r‰   rŠ   rL   rL   rM   Úopens  ó   rì   úLiteral['rb']c                C  rê   rY   rL   rë   rL   rL   rM   rì   Œ  rí   Úrú1Union[Literal['rb'], Literal['rt'], Literal['r']]ú7Union[ContextManager[BinaryIO], ContextManager[TextIO]]c             
   C  sr   |rt dƒgng }| t||||d�tƒ tƒ f¡ t|||	|
||p"d|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�   rq   r�   )r²   rã   rä   ræ   rç   r{   ry   )r�   r‘   r’   rß   r”   r•   rì   rÙ   )rÝ   r²   rã   rä   ræ   rç   r{   ry   r~   r€   r‚   rƒ   r…   r†   r‡   rˆ   r‰   rŠ   r—   r>   rÚ   rL   rL   rM   rì   ¥  sB   1ÿüøÿù
ø

c                   @  sL   e Zd ZU dZdZded< ddd	d
„Zddd„Zddd„Ze	ddd„ƒZ
dS )ÚProgressColumnz3Base class for a widget to use in progress display.Nr|   Úmax_refreshÚtable_columnúOptional[Column]rN   rO   c                 C  s   || _ i | _d | _d S rY   )Ú_table_columnÚ_renderable_cacheZ_update_time)rI   rô   rL   rL   rM   rH      s   
zProgressColumn.__init__r6   c                 C  s   | j ptƒ S )z.Get a table column, used to build tasks table.)rö   r6   r\   rL   rL   rM   Úget_table_column  s   zProgressColumn.get_table_columnrš   ú'Task'r/   c                 C  sp   |  ¡ }| jdur)|js)z
| j|j \}}W n	 ty   Y n
w || j |kr)|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)rƒ   ró   rF   r÷   ÚidÚKeyErrorÚrender)rI   rš   Úcurrent_timeÚ	timestampÚ
renderablerL   rL   rM   Ú__call__	  s   	ÿ
zProgressColumn.__call__c                 C  r·   )z"Should return a renderable object.NrL   ©rI   rš   rL   rL   rM   rü      s    zProgressColumn.renderrY   )rô   rõ   rN   rO   )rN   r6   ©rš   rù   rN   r/   )rk   rl   rm   rn   ró   Ú__annotations__rH   rø   r   r   rü   rL   rL   rL   rM   rò   û  s   
 

rò   c                      s6   e Zd ZdZ	dddœd‡ fd	d
„Z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/   rô   rõ   c                  ó   || _ tƒ j|d� d S ©Nr  )rÿ   rG   rH   )rI   rÿ   rô   rJ   rL   rM   rH   ,  ó   zRenderableColumn.__init__rš   rù   rN   c                 C  r«   rY   )rÿ   r  rL   rL   rM   rü   2  s   zRenderableColumn.render)r  )rÿ   r/   rô   rõ   r  ©rk   rl   rm   rn   rH   rü   ro   rL   rL   rJ   rM   r  %  s    ÿÿr  c                      sH   e Zd ZdZ					dd‡ fdd„Z		dd dd„Z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_namerz   r†   úOptional[StyleType]ÚspeedrC   Úfinished_textr9   rô   rõ   c                   s<   t |||d�| _t|tƒrt |¡n|| _tƒ j|d� d S )N©r†   r  r  )	r4   ÚspinnerÚ
isinstancerz   r8   Úfrom_markupr  rG   rH   )rI   r  r†   r  r  rô   rJ   rL   rM   rH   @  s   ÿýzSpinnerColumn.__init__Úspinner_stylerN   rO   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  )rI   r  r  r  rL   rL   rM   Úset_spinnerP  s   zSpinnerColumn.set_spinnerrš   rù   r/   c                 C  s$   |j r| j}|S | j | ¡ ¡}|S rY   )Úfinishedr  r  rü   rƒ   )rI   rš   ÚtextrL   rL   rM   rü   _  s   ÿÿþýzSpinnerColumn.render)r  r  r  r  N)
r  rz   r†   r  r  rC   r  r9   rô   rõ   )r  r  )r  rz   r  r  r  rC   rN   rO   r  )rk   rl   rm   rn   rH   r  rü   ro   rL   rL   rJ   rM   r  6  s    úür  c                      s8   e Zd ZdZ					dd‡ fdd„Zddd„Z‡  ZS )r�   zA column containing text.ÚnoneÚleftTNÚtext_formatrz   r†   r5   Újustifyr.   Úmarkupr   ÚhighlighterúOptional[Highlighter]rô   rõ   rN   rO   c                   s:   || _ || _|| _|| _|| _tƒ j|ptdd�d� d S )NT©Úno_wrapr  )r  r  r†   r   r!  rG   rH   r6   )rI   r  r†   r  r   r!  rô   rJ   rL   rM   rH   k  s   	zTextColumn.__init__rš   rù   r8   c                 C  sR   | j j|d�}| jrtj|| j| jd�}n	t|| j| jd�}| jr'| j |¡ |S ©N©rš   )r†   r  )	r  Úformatr   r8   r  r†   r  r!  Ú	highlight)rI   rš   Ú_textr  rL   rL   rM   rü   {  s   zTextColumn.render)r  r  TNN)r  rz   r†   r5   r  r.   r   r   r!  r"  rô   rõ   rN   rO   ©rš   rù   rN   r8   r
  rL   rL   rJ   rM   r�   h  s    ùr�   c                      s:   e Zd ZdZ						dd‡ fdd„Z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".
    é(   rr   rs   rt   ru   NÚ	bar_widthrè   r†   r5   r‡   rˆ   r‰   rô   rõ   rN   rO   c                   s0   || _ || _|| _|| _|| _tƒ j|d� d S r  )r,  r†   r‡   rˆ   r‰   rG   rH   )rI   r,  r†   r‡   rˆ   r‰   rô   rJ   rL   rM   rH   ‘  s   	zBarColumn.__init__rš   rù   r3   c                 C  s^   t |jdurtd|jƒndtd|jƒ| jdu rdntd| jƒ|j | ¡ | j| j| j	| j
d�	S )z&Gets a progress bar widget for a task.Nr   r)   )	r{   rF   ÚwidthZpulseZanimation_timer†   r‡   rˆ   r‰   )r3   r{   ÚmaxrF   r,  Ústartedrƒ   r†   r‡   rˆ   r‰   r  rL   rL   rM   rü   ¡  s   
÷zBarColumn.render)r+  rr   rs   rt   ru   N)r,  rè   r†   r5   r‡   r5   rˆ   r5   r‰   r5   rô   rõ   rN   rO   )rš   rù   rN   r3   r
  rL   rL   rJ   rM   r’   †  s    ùr’   c                   @  ó   e Zd ZdZd	dd„ZdS )
ÚTimeElapsedColumnzRenders time elapsed.rš   rù   rN   r8   c                 C  sJ   |j r|jn|j}|du rtddd�S ttdt|ƒƒd�}tt|ƒdd�S )zShow time elapsed.Nú-:--:--úprogress.elapsed©r†   r   )Úseconds)r  Úfinished_timeÚelapsedr8   r	   r.  r}   rz   )rI   rš   r7  ÚdeltarL   rL   rM   rü   ³  s
   zTimeElapsedColumn.renderNr*  ©rk   rl   rm   rn   rü   rL   rL   rL   rM   r1  °  ó    r1  c                      sL   e Zd ZdZ								d$d%‡ fdd„Zed&dd„ƒZ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  TNFr  rz   Útext_format_no_percentager†   r5   r  r.   r   r   r!  r"  rô   rõ   r‹   rN   rO   c	           	        s(   || _ || _tƒ j||||||d� d S )N)r  r†   r  r   r!  rô   )r<  r‹   rG   rH   )	rI   r  r<  r†   r  r   r!  rô   r‹   rJ   rL   rM   rH   Ê  s   
úzTaskProgressColumn.__init__r  r|   r8   c                 C  sN   |du r
t ddd�S t t|ƒg d¢d¡\}}|| }t |d›|› d�dd�S )	zµRender the speed in iterations per second.

        Args:
            task (Task): A Task object.

        Returns:
            Text: Text object containing the task speed.
        Nr  zprogress.percentager4  )r  u   Ã—10Â³u   Ã—10â�¶u   Ã—10â�¹u   Ã—10Â¹Â²éè  z.1fz it/s)r8   r*   Úpick_unit_and_suffixr}   )Úclsr  ÚunitÚsuffixÚ
data_speedrL   rL   rM   Úrender_speedà  s   
ýzTaskProgressColumn.render_speedrš   rù   c                 C  sˆ   |j d u r| jr|  |jp|j¡S |j d u r| jn| j}|j|d�}| jr0t	j
|| j| jd�}n	t	|| j| jd�}| jrB| j |¡ |S r%  )r{   r‹   rC  Úfinished_speedr  r<  r  r'  r   r8   r  r†   r  r!  r(  )rI   rš   r  r)  r  rL   rL   rM   rü   ô  s   ÿzTaskProgressColumn.render)r;  r  r  r  TNNF)r  rz   r<  rz   r†   r5   r  r.   r   r   r!  r"  rô   rõ   r‹   r   rN   rO   )r  r|   rN   r8   r*  )	rk   rl   rm   rn   rH   ÚclassmethodrC  rü   ro   rL   rL   rJ   rM   r“   ¼  s    ÷r“   c                      s8   e Zd ZdZdZ			dd‡ fd
d„Z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Ž   rô   rõ   c                   s   || _ || _tƒ j|d� d S r  )rG  rŽ   rG   rH   )rI   rG  rŽ   rô   rJ   rL   rM   rH     s   zTimeRemainingColumn.__init__rš   rù   rN   r8   c                 C  sÀ   | j r|jr|j}d}n|j}d}|jdu rtd|d�S |du r.t| jr)d|d�S d|d�S tt|ƒdƒ\}}t|dƒ\}}| jrM|sM|d	›d
|d	›�}n|d›d
|d	›d
|d	›�}t||d�S )zShow time remaining.r3  zprogress.remainingNr  r4  z--:--r2  é<   Ú02dú:Úd)	rŽ   r  r6  Útime_remainingr{   r8   rG  Údivmodr}   )rI   rš   Z	task_timer†   Úminutesr5  ÚhoursÚ	formattedrL   rL   rM   rü     s   

zTimeRemainingColumn.render)FFN)rG  r   rŽ   r   rô   rõ   r*  )rk   rl   rm   rn   ró   rH   rü   ro   rL   rL   rJ   rM   r”     s    ü
r”   c                   @  r0  )
ÚFileSizeColumnzRenders completed filesize.rš   rù   rN   r8   c                 C  s   t  t|jƒ¡}t|dd�S )úShow data completed.zprogress.filesizer4  )r*   Údecimalr}   rF   r8   ©rI   rš   Ú	data_sizerL   rL   rM   rü   7  s   zFileSizeColumn.renderNr*  r9  rL   rL   rL   rM   rQ  4  r:  rQ  c                   @  r0  )
ÚTotalFileSizeColumnzRenders total filesize.rš   rù   rN   r8   c                 C  s*   |j durt t|j ƒ¡nd}t|dd�S )rR  Nr  zprogress.filesize.totalr4  )r{   r*   rS  r}   r8   rT  rL   rL   rM   rü   @  s   zTotalFileSizeColumn.renderNr*  r9  rL   rL   rL   rM   rV  =  r:  rV  c                      s.   e Zd ZdZdd‡ fdd	„Z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Ú	separatorrz   rô   rõ   c                   r  r  )rY  rG   rH   )rI   rY  rô   rJ   rL   rM   rH   R  s   zMofNCompleteColumn.__init__rš   rù   rN   r8   c                 C  sP   t |jƒ}|jdurt |jƒnd}tt|ƒƒ}t||› d�›| j› |› �dd�S )zShow completed/total.NÚ?rK  úprogress.downloadr4  )r}   rF   r{   r¨   rz   r8   rY  )rI   rš   rF   r{   Útotal_widthrL   rL   rM   rü   V  s   
þzMofNCompleteColumn.render)rX  N)rY  rz   rô   rõ   r*  r
  rL   rL   rJ   rM   rW  F  s    rW  c                      s0   e Zd ZdZ	dd‡ fd
d„Z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   rô   rõ   rN   rO   c                   r  r  )r]  rG   rH   )rI   r]  rô   rJ   rL   rM   rH   h  r	  zDownloadColumn.__init__rš   rù   r8   c                 C  sÔ   t |jƒ}|jdurt |jƒn|}| jr t |g d¢d¡\}}nt |g d¢d¡\}}|dkr1dnd}|| }|d|› d	�›}|jdurVt |jƒ}	|	| }
|
d|› d	�›}nd
}|› d|› d|› �}t|dd�}|S )z.Calculate common unit for completed and total.N)	r¤   ÚKiBÚMiBÚGiBÚTiBÚPiBÚEiBZZiBÚYiBi   )	r¤   ZkBÚMBÚGBZTBZPBZEBZZBZYBr=  r)   r   z,.ÚfrZ  rX  r  r[  r4  )r}   rF   r{   r]  r*   r>  r8   )rI   rš   rF   Z unit_and_suffix_calculation_baser@  rA  Ú	precisionZcompleted_ratioZcompleted_strr{   Útotal_ratioZ	total_strZdownload_statusZdownload_textrL   rL   rM   rü   n  s2   
ÿ
ýý

zDownloadColumn.render)FN)r]  r   rô   rõ   rN   rO   r*  r
  rL   rL   rJ   rM   rß   a  s
    ÿrß   c                   @  r0  )
ÚTransferSpeedColumnz&Renders human readable transfer speed.rš   rù   rN   r8   c                 C  s@   |j p|j}|du rtddd�S t t|ƒ¡}t|› d�dd�S )zShow data transfer speed.NrZ  zprogress.data.speedr4  z/s)rD  r  r8   r*   rS  r}   )rI   rš   r  rB  rL   rL   rM   rü   •  s
   zTransferSpeedColumn.renderNr*  r9  rL   rL   rL   rM   rj  ’  r:  rj  c                   @  s$   e Zd ZU dZded< 	 ded< dS )ÚProgressSamplez$Sample of progress for a given time.rC   rþ   rF   N)rk   rl   rm   rn   r  rL   rL   rL   rM   rk  ž  s   
 rk  c                   @  sX  e Zd ZU dZded< 	 ded< 	 ded< 	 ded	< 	 d
ed< 	 dZded< 	 dZded< 	 eed�Z	ded< 	 edddd�Z
ded< 	 edddd�Zded< 	 dZded< 	 edd„ ddd�Zded< eded�Zded < 	 d5d"d#„Zed6d$d%„ƒZed7d&d'„ƒZed7d(d)„ƒZed6d*d+„ƒZed5d,d-„ƒZed7d.d/„ƒZed7d0d1„ƒZd8d3d4„ZdS )9ÚTaskz…Information regarding a progress task.

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

    r:   rú   rz   ry   r|   r{   rC   rF   ÚGetTimeCallableÚ	_get_timeNr6  Tr   Úvisible)Údefault_factoryzDict[str, Any]ÚfieldsF)ÚdefaultÚinitÚreprÚ
start_timeÚ	stop_timerD  c                   C  s
   t dd�S )Nr=  )Úmaxlenr   rL   rL   rL   rM   Ú<lambda>Ñ  s   
 zTask.<lambda>)rp  rs  rt  zDeque[ProgressSample]Ú	_progress)rt  rp  r   Ú_lockrN   c                 C  s   |   ¡ S )z(float: Get the current time, in seconds.)rn  r\   rL   rL   rM   rƒ   ×  r³   zTask.get_timec                 C  ó
   | j duS )z#bool: Check if the task as started.N)ru  r\   rL   rL   rM   r/  Û  ó   
zTask.startedc                 C  s   | j du rdS | j | j S )zPOptional[float]: Get the number of steps remaining, if a non-None total was set.N©r{   rF   r\   rL   rL   rM   Ú	remainingà  s   
zTask.remainingc                 C  s2   | j du rdS | jdur| j| j  S |  ¡ | j  S )z]Optional[float]: Time elapsed since task was started, or ``None`` if the task hasn't started.N)ru  rv  rƒ   r\   rL   rL   rM   r7  ç  s
   

zTask.elapsedc                 C  r{  )zCheck if the task has finished.N)r6  r\   rL   rL   rM   r  ð  r|  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@)r{   rF   Úminr.  )rI   rF   rL   rL   rM   Ú
percentageõ  s
   zTask.percentagec                 C  s°   | j du rdS | j�D | j}|s	 W d  ƒ dS |d j|d j }|dkr0	 W d  ƒ dS t|ƒ}t|ƒ tdd„ |D ƒƒ}|| }|W  d  ƒ S 1 sQw   Y  dS )z=Optional[float]: Get the estimated speed in steps per second.Nr¹   r   c                 s  ó   � | ]}|j V  qd S rY   rÌ   )Ú.0ÚsamplerL   rL   rM   Ú	<genexpr>  ó   € zTask.speed.<locals>.<genexpr>)ru  rz  ry  rþ   Úiterr§   rÇ   )rI   r>   Ú
total_timeZiter_progressZtotal_completedr  rL   rL   rM   r  þ  s"   
ýú$õz
Task.speedc                 C  s:   | j rdS | j}|sdS | j}|du rdS t|| ƒ}|S )zJOptional[float]: Get estimated time to completion, or ``None`` if no data.r  N)r  r  r~  r   )rI   r  r~  ZestimaterL   rL   rM   rL    s   zTask.time_remainingrO   c                 C  s   | j  ¡  d| _d| _dS )zReset progress.N)ry  Úclearr6  rD  r\   rL   rL   rM   Ú_reset  s   

zTask._reset)rN   rC   r×   )rN   r|   ri   )rk   rl   rm   rn   r  r6  ro  r   Údictrq  ru  rv  rD  ry  r   rz  rƒ   rØ   r/  r~  r7  r  r‚  r  rL  r‹  rL   rL   rL   rM   rl  §  sZ   
 
ÿ
rl  c                   @  sÖ  e Zd ZdZdddddddddddœ
dŒdd„Zed�dd„ƒZedŽd d!„ƒZed�d#d$„ƒZ	ed�d&d'„ƒZ
ed‘d(d)„ƒZd’d*d+„Zd’d,d-„Zd“d/d0„Zd”d7d8„Z		9		:	;d•d–dGdH„Z	d—ddIdJœd˜dNdO„Zej	P			d™dddIdQœdšdZd[„ƒZej	P			d™dddIdQœd›d^d[„ƒZ	_	P			dœdddIdQœd�dbd[„Zdžddde„Zdždfdg„ZdddddddhœdŸdodp„Zddd9dddqœd dsdt„Zd¡d¢dvdw„Zd’dxdy„Zd£d{d|„Zd¤d~d„Zd¥dƒd„„Zd£d…d†„Z		‡	9	d¦d§dˆd‰„ZdždŠd‹„Z dS )¨r•   ad  Renders an auto-updating progress bar(s).

    Args:
        console (Console, optional): Optional Console instance. Defaults to 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 (float, optional): Number of times per second to refresh the progress information. Defaults to 10.
        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.
    NTrq   g      >@F)
r€   r~   r…   Úspeed_estimate_periodr‚   Úredirect_stdoutÚredirect_stderrrƒ   rŠ   Úexpandr—   úUnion[str, ProgressColumn]r€   r�   r~   r   r…   rC   r�  r‚   rŽ  r�  rƒ   úOptional[GetTimeCallable]rŠ   r�  rN   rO   c       
      	   G  sŽ   |dksJ dƒ‚t ƒ | _|p|  ¡ | _|| _|	| _|
| _i | _tdƒ| _	t
|p)tƒ |||||| jd�| _|p9| jj| _| jj| _| jj| _d S )Nr   zrefresh_per_second must be > 0)r€   r~   r…   r‚   rŽ  r�  Úget_renderable)r   rz  Úget_default_columnsr—   r�  rŠ   r�  Ú_tasksr:   Ú_task_indexr2   r+   r“  rS   r€   rƒ   ÚprintÚlog)rI   r€   r~   r…   r�  r‚   rŽ  r�  rƒ   rŠ   r�  r—   rL   rL   rM   rH   5  s(   
ù	
zProgress.__init__úTuple[ProgressColumn, ...]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.get_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?  rL   rL   rM   r”  Y  s
   üzProgress.get_default_columnsr,   c                 C  r±   rY   )rS   r€   r\   rL   rL   rM   r€   x  r³   zProgress.consoleú
List[Task]c                 C  ó8   | j � t| j ¡ ƒW  d  ƒ S 1 sw   Y  dS )zGet a list of Task instances.N)rz  Úlistr•  Úvaluesr\   rL   rL   rM   Útasks|  ó   $ÿzProgress.tasksúList[TaskID]c                 C  r›  )zA list of task IDs.N)rz  rœ  r•  Úkeysr\   rL   rL   rM   Útask_ids‚  rŸ  zProgress.task_idsc                 C  sZ   | j �  | js	 W d  ƒ dS tdd„ | j ¡ D ƒƒW  d  ƒ S 1 s&w   Y  dS )z'Check if all tasks have been completed.NTc                 s  rƒ  rY   )r  )r„  rš   rL   rL   rM   r†  Ž  r‡  z$Progress.finished.<locals>.<genexpr>)rz  r•  Úallr�  r\   rL   rL   rM   r  ˆ  s   þ$ýzProgress.finishedc                 C  s   | j s| jjdd� dS dS )zStart the progress display.T)rP   N)rŠ   rS   r[   r\   rL   rL   rM   r[   �  s   ÿzProgress.startc                 C  s:   | j s| j ¡  | jjs| jjs| j ¡  dS dS dS dS )zStop the progress display.N)rŠ   rS   rÛ   r€   Úis_interactiveÚ
is_jupyterr—  r\   rL   rL   rM   rÛ   •  s   
ýzProgress.stopr(   c                 C  rX   rY   rZ   r\   rL   rL   rM   r]   œ  r^   zProgress.__enter__r_   r`   ra   rb   rc   rd   c                 C  rŸ   rY   )rÛ   rg   rL   rL   rM   rh      r¡   zProgress.__exit__r   rp   rv   rw   rx   r{   r|   rF   r}   r@   úOptional[TaskID]ry   rz   rB   c                 c  sÌ   � |du rt t|ƒƒpd}|du r| j|||d�}n| j|||d� | jjrNt| ||ƒ�}|D ]}|V  | jd7  _q/W d  ƒ dS 1 sGw   Y  dS | j}	| j	}
|D ]}|V  |	|dƒ |
ƒ  qVdS )aC  Track progress by iterating over a sequence.

        You can also track progress of an iterable, which might require that you additionally specify ``total``.

        Args:
            sequence (Iterable[ProgressType]): Values you want to iterate over and track progress.
            total: (float, optional): Total number of steps. Default is len(sequence).
            completed (int, optional): Number of steps completed so far. Defaults to 0.
            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.
        Nr}  r)   )
rC   r   Úadd_taskrU   rS   r~   r=   rF   rQ   rP   )rI   rw   r{   rF   r@   ry   rB   Ztrack_threadÚvaluerQ   rP   rL   rL   rM   r–   ¨  s(   €þ"ÿ
ýzProgress.trackrÜ   )r@   ry   rÝ   r   rè   c                C  s’   d}|dur	|}n|dur&| j � | j| j}W d  ƒ n1 s!w   Y  |du r.tdƒ‚|du 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›   )rz  r•  r{   Ú
ValueErrorr§  rU   r˜   )rI   rÝ   r{   r@   ry   Útotal_bytesrL   rL   rM   rà   Õ  s   ÿÿzProgress.wrap_filer¹   )r{   r@   ry   rá   r²   rî   rã   rä   rå   ræ   rç   c          
      C  rê   rY   rL   ©
rI   rÝ   r²   rã   rä   ræ   rç   r{   r@   ry   rL   rL   rM   rì   ÿ  ó   zProgress.openú"Union[Literal['r'], Literal['rt']]r#   c          
      C  rê   rY   rL   r­  rL   rL   rM   rì     r®  rï   rð   úUnion[BinaryIO, TextIO]c                C  sî   d  t|dd�¡}
|
dvrtd|›�ƒ‚|dk}|
dkr)|dkr)t dt¡ d	}n|
d
v r;|dkr5tdƒ‚|dkr;d	}|du rDt|ƒj}|du rP| j|	|d�}n| j	||d� t
j|d|d�}t|| |dd�}|dv rut
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)ÚbrÚrtrï   zinvalid mode 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©  Úrb)rã   Trª  )rï   r³  )rä   ræ   rç   Úline_buffering)rf   Úsortedr«  ÚwarningsÚwarnÚRuntimeWarningr   Úst_sizer§  rU   Úiorì   r˜   ÚTextIOWrapper)rI   rÝ   r²   rã   rä   ræ   rç   r{   r@   ry   Ú_moderµ  r™   rÚ   rL   rL   rM   rì     s>   !þ
ûr:   c                 C  sZ   | j �  | j| }|jdu r|  ¡ |_W d  ƒ dS W d  ƒ dS 1 s&w   Y  dS )zéStart a task.

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

        Args:
            task_id (TaskID): ID of task.
        N)rz  r•  ru  rƒ   )rI   r@   rš   rL   rL   rM   Ú
start_taskl  s   	

ý"þzProgress.start_taskc                 C  sT   | j � | j| }|  ¡ }|jdu r||_||_W d  ƒ dS 1 s#w   Y  dS )z†Stop a task.

        This will freeze the elapsed time on the task.

        Args:
            task_id (TaskID): ID of task.
        N)rz  r•  rƒ   ru  rv  )rI   r@   rš   rý   rL   rL   rM   Ú	stop_taskz  s   

"ûzProgress.stop_task)r{   rF   rQ   ry   ro  rP   rQ   ro  úOptional[bool]rP   rq  r   c                K  sH  | j �� | j| }	|	j}
|dur||	jkr||	_|	 ¡  |dur'|	 j|7  _|dur.||	_|dur5||	_|dur<||	_|	j |¡ |	j|
 }|  	¡ }|| j
 }|	j}|j}|rk|d j|k rk|ƒ  |rk|d j|k s_|dkrw| t||ƒ¡ |	jdur‹|	j|	jkr‹|	jdu r‹|	j|	_W d  ƒ n1 s•w   Y  |r¢|  ¡  dS dS )a˜  Update information associated with a task.

        Args:
            task_id (TaskID): Task id (returned by add_task).
            total (float, optional): Updates task.total if not None.
            completed (float, optional): Updates task.completed if not None.
            advance (float, optional): Add a value to task.completed if not None.
            description (str, optional): Change task description if not None.
            visible (bool, optional): Set visible flag if not None.
            refresh (bool): Force a refresh of progress information. Default is False.
            **fields (Any): Additional data fields required for rendering.
        Nr   )rz  r•  rF   r{   r‹  ry   ro  rq  rU   rƒ   r�  ry  Úpopleftrþ   Úappendrk  r6  r7  rP   )rI   r@   r{   rF   rQ   ry   ro  rP   rq  rš   Úcompleted_startÚupdate_completedrý   Úold_sample_timery  rÁ  rL   rL   rM   rU   ‰  sD   


ÿ

€à"ÿzProgress.update)r[   r{   rF   ro  ry   r[   c          
      K  sš   |   ¡ }| j�8 | j| }	|	 ¡  |r|nd|	_|dur||	_||	_|dur)||	_|r.||	_|dur5||	_	d|	_
W d  ƒ n1 sBw   Y  |  ¡  dS )ax  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): Set visible flag if not None.
            description (str, optional): Change task description if not None. Defaults to None.
            **fields (str): Additional data fields required for rendering.
        N)rƒ   rz  r•  r‹  ru  r{   rF   ro  rq  ry   r6  rP   )
rI   r@   r[   r{   rF   ro  ry   rq  rý   rš   rL   rL   rM   ÚresetÆ  s"   
ózProgress.resetr)   c           
      C  s*  |   ¡ }| j�„ | j| }|j}| j|7  _|j| }|| j }|j}|j}	|r<|d j|k r<|	ƒ  |r<|d j|k s0t|ƒdkrK|	ƒ  t|ƒdksB| 	t
||ƒ¡ |jdurs|j|jkr{|jdu rƒ|j|_|j|_W d  ƒ dS W d  ƒ dS W d  ƒ dS W d  ƒ dS 1 sŽw   Y  dS )z«Advance task by a number of steps.

        Args:
            task_id (TaskID): ID of task.
            advance (float): Number of steps to advance. Default is 1.
        r   r=  N)rƒ   rz  r•  rF   r�  ry  rÁ  rþ   r¨   rÂ  rk  r{   r6  r7  r  rD  )
rI   r@   rQ   rý   rš   rÃ  rÄ  rÅ  ry  rÁ  rL   rL   rM   rQ   í  s8   


ÿÿ


ìñð"ïzProgress.advancec                 C  s$   | j s| jjr| j ¡  dS dS dS )z*Refresh (render) the progress information.N)rŠ   rS   rT   rP   r\   rL   rL   rM   rP     s   ÿzProgress.refreshr/   c                 C  s   t |  ¡ Ž }|S )z*Get a renderable for the progress display.)r-   Úget_renderables)rI   rÿ   rL   rL   rM   r“    s   zProgress.get_renderableúIterable[RenderableType]c                 c  s   � |   | j¡}|V  dS )z5Get a number of renderables for the progress display.N)Úmake_tasks_tablerž  )rI   ÚtablerL   rL   rM   rÇ    s   €
zProgress.get_renderablesrž  úIterable[Task]r7   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  s0   � | ]}t |tƒrtd d�n| ¡  ¡ V  qdS )Tr#  N)r  rz   r6   rø   Úcopy)r„  Z_columnrL   rL   rM   r†  #  s   € ýÿ

üz,Progress.make_tasks_table.<locals>.<genexpr>)r   r)   )Úpaddingr�  c                 3  s.   � | ]}t |tƒr|jˆ d �n|ˆ ƒV  qdS )r&  N)r  rz   r'  )r„  Úcolumnr&  rL   rM   r†  0  s   € ýÿ
ü)r—   r7   Úgridr�  ro  Úadd_row)rI   rž  Ztable_columnsrÊ  rL   r&  rM   rÉ    s   	ú
úÿ€
zProgress.make_tasks_tablec                 C  s2   | j � |  ¡ W  d  ƒ S 1 sw   Y  dS )z+Makes the Progress class itself renderable.N)rz  r“  r\   rL   rL   rM   Ú__rich__;  s   $ÿzProgress.__rich__r€  c           	      K  s†   | j �2 t| j|||||| j| j d�}|| j| j< |r!|  | j¡ | j}tt| jƒd ƒ| _W d  ƒ n1 s8w   Y  |  ¡  |S )a  Add a new 'task' to the Progress display.

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

        Returns:
            TaskID: An ID you can use when calling `update`.
        )ro  rq  rn  rz  r)   N)	rz  rl  r–  rƒ   r•  r¾  r:   r}   rP   )	rI   ry   r[   r{   rF   ro  rq  rš   Znew_task_indexrL   rL   rM   r§  @  s&   ø
ñzProgress.add_taskc                 C  s4   | j � | j|= W d  ƒ dS 1 sw   Y  dS )z]Delete a task if it exists.

        Args:
            task_id (TaskID): A task ID.

        N)rz  r•  )rI   r@   rL   rL   rM   Úremove_taskk  s   
"ÿzProgress.remove_task)r—   r‘  r€   r�   r~   r   r…   rC   r�  rC   r‚   r   rŽ  r   r�  r   rƒ   r’  rŠ   r   r�  r   rN   rO   )rN   r™  )rN   r,   )rN   rš  )rN   r   r×   ri   )rN   r(   rj   )Nr   Nrp   rv   )rw   rx   r{   r|   rF   r}   r@   r¦  ry   rz   rB   rC   rN   rx   rY   )
rÝ   r   r{   rè   r@   r¦  ry   rz   rN   r   ©r¹   NNN)rÝ   rá   r²   rî   rã   r}   rä   rå   ræ   rå   rç   rå   r{   rè   r@   r¦  ry   rz   rN   r   )rÝ   rá   r²   r¯  rã   r}   rä   rå   ræ   rå   rç   rå   r{   rè   r@   r¦  ry   rz   rN   r#   ©rï   r¹   NNN)rÝ   rá   r²   rð   rã   r}   rä   rå   ræ   rå   rç   rå   r{   rè   r@   r¦  ry   rz   rN   r°  )r@   r:   rN   rO   )r@   r:   r{   r|   rF   r|   rQ   r|   ry   rå   ro  rÀ  rP   r   rq  r   rN   rO   )r@   r:   r[   r   r{   r|   rF   r}   ro  rÀ  ry   rå   rq  r   rN   rO   )r)   )r@   r:   rQ   rC   rN   rO   )rN   r/   )rN   rÈ  )rž  rË  rN   r7   )Tr€  r   T)ry   rz   r[   r   r{   r|   rF   r}   ro  r   rq  r   rN   r:   )!rk   rl   rm   rn   rH   rE  r”  rØ   r€   rž  r¢  r  r[   rÛ   r]   rh   r–   rà   ÚtypingÚoverloadrì   r¾  r¿  rU   rÆ  rQ   rP   r“  rÇ  rÉ  rÑ  r§  rÒ  rL   rL   rL   rM   r•   %  s¾    ô$



ù0ýú*ù	õù	õù	õ
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_numbersÚ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...ÚexamplezPretty printed)Útyper  z	Syntax...zGive it a try!)Úcycle)Úrecord)r€   r‚   z[red]Downloadingr=  r©  z[green]Processingz[yellow]ThinkingrF  r¦   g333333Ó?g{®Gáz„?éd   )rp   Nr   TNFNrq   rr   rs   rt   ru   rv   FT)"rw   rx   ry   rz   r{   r|   rF   r}   r~   r   r€   r�   r‚   r   rƒ   r„   r…   rC   r†   r5   r‡   r5   rˆ   r5   r‰   r5   rB   rC   rŠ   r   r‹   r   rN   rx   )rÝ   r   r{   r}   ry   rz   r~   r   r€   r�   r‚   r   rƒ   r„   r…   rC   r†   r5   r‡   r5   rˆ   r5   r‰   r5   rŠ   r   rN   rÞ   rÓ  )&rÝ   rá   r²   râ   rã   r}   rä   rå   ræ   rå   rç   rå   r{   rè   ry   rz   r~   r   r€   r�   r‚   r   rƒ   r„   r…   rC   r†   r5   r‡   r5   rˆ   r5   r‰   r5   rŠ   r   rN   ré   )&rÝ   rá   r²   rî   rã   r}   rä   rå   ræ   rå   rç   rå   r{   rè   ry   rz   r~   r   r€   r�   r‚   r   rƒ   r„   r…   rC   r†   r5   r‡   r5   rˆ   r5   r‰   r5   rŠ   r   rN   rÞ   rÔ  )&rÝ   rá   r²   rð   rã   r}   rä   rå   ræ   rå   rç   rå   r{   rè   ry   rz   r~   r   r€   r�   r‚   r   rƒ   r„   r…   rC   r†   r5   r‡   r5   rˆ   r5   r‰   r5   rŠ   r   rN   rñ   )…Ú
__future__r   r»  rÕ  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&   r'   Útyping_extensionsr(   r  r*   r+   r€   r,   r-   r.   r/   r!  r0   Újupyterr1   rS   r2   Zprogress_barr3   r  r4   r†   r5   rÊ  r6   r7   r  r8   r9   r}   r:   r;   rC   rm  r<   r=   r–   r˜   rÙ   rà   rÖ  rì   rò   r  r  r�   r’   r1  r“   r”   rQ  rV  rW  rß   rj  rk  rl  r•   rk   ÚrandomÚtimeÚpanelrØ  ÚrulerÙ  ÚsyntaxrÚ  rÐ  Zprogress_renderablesÚ	itertoolsrä  Úexamplesr”  r>   r§  Ztask1Ztask2Ztask3r  rU   ÚsleepÚrandintr˜  r§   rL   rL   rL   rM   Ú<module>   s‚   T
*ðNgòAúíúíúíV*2*H0		1	}    
Uó÷
ÿþýû

ûõ$õÒ