o
    åôj7é  ã                +   @   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ƒZS	 		!		"		#	$	%	&	'	(	"	!d—d)e/e*eO e%eO f d*eTd+e)eP d,eUd-e)e7 d.eUd/e)e g ePf  d0ePd1eFd2eFd3eFd4eFd5ePd6eUd7eUd8e%eO f d9d:„ZVG d;d<„ d<eeƒZWG d=d>„ d>e!eR e$eR ƒZXd?d!dd"dd#d$d%d&d'd"d@œdAed+eMd*eTd,eUd-e)e7 d.eUd/e)e g ePf  d0ePd1eFd2eFd3eFd4eFd6eUd8e!e fdBdC„ZYejZ	D			d˜dd?d!dd"dd#d$d%d&d'd"dEœdAe/eTdFe[f dGe/e1dH e1dI f dJeMdKe)eT dLe)eT dMe)eT d+e)eM d*eTd,eUd-e)e7 d.eUd/e)e g ePf  d0ePd1eFd2eFd3eFd4eFd6eUd8e!e+ f&dNdO„ƒZ\ejZ	D			d˜dd?d!dd"dd#d$d%d&d'd"dEœdAe/eTdFe[f dGe1dP dJeMdKe)eT dLe)eT dMe)eT d+e)eM d*eTd,eUd-e)e7 d.eUd/e)e g ePf  d0ePd1eFd2eFd3eFd4eFd6eUd8e!e f&dQdO„ƒZ\	I	D			d™dd?d!dd"dd#d$d%d&d'd"dEœdAe/eTdFe[f dGe/e1dP e1dH e1dI f dJeMdKe)eT dLe)eT dMe)eT d+e)eM d*eTd,eUd-e)e7 d.eUd/e)e g ePf  d0ePd1eFd2eFd3eFd4eFd6eUd8e/e!e e!e+ f f&dRdO„Z\G dSdT„ dTeƒZ]G dUdV„ dVe]ƒZ^G dWdX„ dXe]ƒZ_G dYdZ„ dZe]ƒZ`G d[d\„ d\e]ƒZaG d]d^„ d^e]ƒZbG d_d`„ d`e`ƒZcG dadb„ dbe]ƒZdG dcdd„ dde]ƒZeG dedf„ dfe]ƒZfG dgdh„ dhe]ƒZgG didj„ dje]ƒZhG dkdl„ dle]ƒZiG dmdn„ dne'ƒZje
G dodp„ dpƒƒZkG dqdr„ dre>ƒZlemdsk�rþd dlnZnd dloZoddtlpmqZq ddulrmsZs ddvltmuZu ddwlGmIZI eudxdyd!dz�ZteId{d|d}ƒZGeG vd~dd€¡ d�eqd‚ƒdƒeGd„d…d†d‡œdˆetesd‰ƒg	Zwd dŠlxmyZy eyewƒZze7d!d‹�Z6ele_ƒ gel {¡ ¢ebƒ ‘R e6d"dŒœŽ�QZ|e|j}d�dŽ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ƒ¡ e|j��r¼W d  ƒ dS W d  ƒ dS 1 �s÷w   Y  dS 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                       sl   e Zd ZdZdddddef‡ fdd„Zddd„Zddd„Zdee	e
  dee
 dee d	d
fdd„Z‡  ZS )Ú_TrackThreadz)A thread to periodically update progress.ÚprogressÚProgressÚtask_idr:   Úupdate_periodc                    s.   || _ || _|| _tƒ | _d| _tƒ  ¡  d S )Nr   )r>   r@   rA   r   ÚdoneÚ	completedÚsuperÚ__init__)Úselfr>   r@   rA   ©Ú	__class__© ú`/var/www/html/academy/tools/voices/clone/cosy-venv/lib/python3.10/site-packages/rich/progress.pyrE   B   s   z_TrackThread.__init__ÚreturnNc                 C   sj   | j }| jj}| j}d}| jj}||ƒs(| j}||kr$|||| ƒ |}||ƒr| jj| j | jdd� d S )Nr   T)rC   Úrefresh)r@   r>   ÚadvancerA   rB   ÚwaitrC   Úupdate)rF   r@   rM   rA   Zlast_completedrN   rC   rI   rI   rJ   ÚrunK   s   üz_TrackThread.runc                 C   ó   |   ¡  | S ©N©Ústart©rF   rI   rI   rJ   Ú	__enter__Y   ó   z_TrackThread.__enter__Úexc_typeÚexc_valÚexc_tbc                 C   s   | j  ¡  |  ¡  d S rR   )rB   ÚsetÚjoin©rF   rX   rY   rZ   rI   rI   rJ   Ú__exit__]   s   
z_TrackThread.__exit__©rK   N)rK   r=   )Ú__name__Ú
__module__Ú__qualname__Ú__doc__ÚfloatrE   rP   rV   r   r#   ÚBaseExceptionr   r^   Ú__classcell__rI   rI   rG   rJ   r=   ?   s    
	

þýüûr=   ú
Working...TFé
   úbar.backúbar.completeúbar.finishedú	bar.pulseçš™™™™™¹?ÚsequenceÚdescriptionÚtotalÚauto_refreshÚconsoleÚ	transientÚget_timeÚrefresh_per_secondÚstyleÚcomplete_styleÚfinished_styleÚpulse_stylerA   ÚdisableÚ
show_speedrK   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 sFw   Y  d	S )
aé  Track progress by iterating over a sequence.

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

    ú([progress.description]{task.description}©rv   rw   rx   ry   )r{   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   s8   €(ÿüøÿù
ÿ"ÿr…   c                   @   s˜  e Zd ZdZ	d?dedddededd	f
d
d„Zd@dd„Zde	e
e  de	e de	e dd	fdd„Zdefdd„Zdefdd„Zedefdd„ƒZdefdd„Zdefdd„Zedefdd„ƒZedefdd „ƒZdefd!d"„Zdefd#d$„Zdefd%d&„ZdAd(edefd)d*„Zd+eeee f fd,d-„Z!dAd(edefd.d/„Z"dAd0ede#e fd1d2„Z$dBd3d4„Z%dCd6ed7edefd8d9„Z&defd:d;„Z'd<e(defd=d>„Z)d	S )DÚ_Readerz9A reader that tracks progress while it's being read from.TÚhandler>   r?   ÚtaskÚclose_handlerK   Nc                 C   s"   || _ || _|| _|| _d| _d S ©NF)rˆ   r>   r‰   rŠ   Ú_closed)rF   rˆ   r>   r‰   rŠ   rI   rI   rJ   rE   °   s
   
z_Reader.__init__c                 C   s   | j  ¡  | S rR   )rˆ   rV   rU   rI   rI   rJ   rV   ½   s   
z_Reader.__enter__rX   rY   rZ   c                 C   ó   |   ¡  d S rR   )Úcloser]   rI   rI   rJ   r^   Á   ó   z_Reader.__exit__c                 C   s   | S rR   rI   rU   rI   rI   rJ   Ú__iter__É   ó   z_Reader.__iter__c                 C   s$   t | jƒ}| jj| jt|ƒd� |S ©N©rM   )Únextrˆ   r>   rM   r‰   Úlen)rF   ÚlinerI   rI   rJ   Ú__next__Ì   s   
z_Reader.__next__c                 C   ó   | j S rR   )rŒ   rU   rI   rI   rJ   ÚclosedÑ   s   z_Reader.closedc                 C   ó
   | j  ¡ S rR   )rˆ   ÚfilenorU   rI   rI   rJ   r›   Õ   ó   
z_Reader.filenoc                 C   rš   rR   )rˆ   ÚisattyrU   rI   rI   rJ   r�   Ø   rœ   z_Reader.isattyc                 C   ó   | j jS rR   )rˆ   ÚmoderU   rI   rI   rJ   rŸ   Û   ó   z_Reader.modec                 C   rž   rR   )rˆ   ÚnamerU   rI   rI   rJ   r¡   ß   r    z_Reader.namec                 C   rš   rR   )rˆ   ÚreadablerU   rI   rI   rJ   r¢   ã   rœ   z_Reader.readablec                 C   rš   rR   )rˆ   ÚseekablerU   rI   rI   rJ   r£   æ   rœ   z_Reader.seekablec                 C   ó   dS r‹   rI   rU   rI   rI   rJ   Úwritableé   r‘   z_Reader.writableéÿÿÿÿÚsizec                 C   ó&   | j  |¡}| jj| jt|ƒd� |S r’   )rˆ   Úreadr>   rM   r‰   r•   )rF   r§   ÚblockrI   rI   rJ   r©   ì   ó   z_Reader.readÚbc                 C   s"   | j  |¡}| jj| j|d� |S r’   )rˆ   Úreadintor>   rM   r‰   )rF   r¬   ÚnrI   rI   rJ   r­   ñ   s   z_Reader.readintoc                 C   r¨   r’   )rˆ   Úreadliner>   rM   r‰   r•   )rF   r§   r–   rI   rI   rJ   r¯   ö   r«   z_Reader.readlineÚhintc                 C   s,   | j  |¡}| jj| jttt|ƒƒd� |S r’   )rˆ   Ú	readlinesr>   rM   r‰   ÚsumÚmapr•   )rF   r°   ÚlinesrI   rI   rJ   r±   û   s   z_Reader.readlinesc                 C   s   | j r| j ¡  d| _d S )NT)rŠ   rˆ   rŽ   rŒ   rU   rI   rI   rJ   rŽ      s   

z_Reader.closer   ÚoffsetÚwhencec                 C   s$   | j  ||¡}| jj| j|d� |S )N©rC   )rˆ   Úseekr>   rO   r‰   )rF   rµ   r¶   ÚposrI   rI   rJ   r¸     s   z_Reader.seekc                 C   rš   rR   )rˆ   ÚtellrU   rI   rI   rJ   rº   
  rœ   z_Reader.tellÚsc                 C   s   t dƒ‚)NÚwrite)r
   )rF   r»   rI   rI   rJ   r¼     s   z_Reader.write)T)rK   r‡   )r¦   r_   )r   )*r`   ra   rb   rc   r   r:   ÚboolrE   rV   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‡   ­   sZ    ûþýüû
ú

þýü
û
r‡   c                   @   s^   e Zd ZdZdddeddfdd„Zdefd	d
„Zdeee	  dee	 dee
 ddfdd„ZdS )Ú_ReadContextzEA utility class to handle a context for both a reader and a progress.r>   r?   ÚreaderrK   Nc                 C   s   || _ || _d S rR   )r>   rÅ   )rF   r>   rÅ   rI   rI   rJ   rE     s   
z_ReadContext.__init__c                 C   s   | j  ¡  | j ¡ S rR   )r>   rT   rÅ   rV   rU   rI   rI   rJ   rV     s   

z_ReadContext.__enter__rX   rY   rZ   c                 C   s   | j  ¡  | j |||¡ d S rR   )r>   ÚstoprÅ   r^   r]   rI   rI   rJ   r^     s   
z_ReadContext.__exit__)r`   ra   rb   rc   r<   rE   rV   r   r#   re   r   r^   rI   rI   rI   rJ   rÄ     s    
þýüûrÄ   ú
Reading...)ro   rq   rr   rs   rt   ru   rv   rw   rx   ry   rz   Úfilec             	   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}   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]rŸ   ÚrtÚrÚ	bufferingÚencodingÚerrorsÚnewlinec                C   ó   d S rR   rI   ©rÈ   rŸ   rÎ   rÏ   rÐ   rÑ   rp   ro   rq   rr   rs   rt   ru   rv   rw   rx   ry   rz   rI   rI   rJ   Úopeng  ó   rÔ   Úrbc                C   rÒ   rR   rI   rÓ   rI   rI   rJ   rÔ   €  rÕ   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}   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                   @   sp   e Zd ZU dZdZee ed< ddee ddfdd„Z	defdd	„Z
d
ddefdd„Zed
ddefdd„ƒZdS )ÚProgressColumnz3Base class for a widget to use in progress display.NÚmax_refreshÚtable_columnrK   c                 C   s   || _ i | _d | _d S rR   )Ú_table_columnÚ_renderable_cacheZ_update_time)rF   rÙ   rI   rI   rJ   rE   ô  s   
zProgressColumn.__init__c                 C   s   | j ptƒ S )z.Get a table column, used to build tasks table.)rÚ   r6   rU   rI   rI   rJ   Úget_table_columnù  s   zProgressColumn.get_table_columnr‰   ÚTaskc                 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)rt   rØ   rC   rÛ   ÚidÚKeyErrorÚrender)rF   r‰   Úcurrent_timeÚ	timestampÚ
renderablerI   rI   rJ   Ú__call__ý  s   	ÿ
zProgressColumn.__call__c                 C   r¤   )z"Should return a renderable object.NrI   ©rF   r‰   rI   rI   rJ   rà     s    zProgressColumn.renderrR   )r`   ra   rb   rc   rØ   r   rd   Ú__annotations__r6   rE   rÜ   r/   rä   r   rà   rI   rI   rI   rJ   r×   ï  s   
 r×   c                       sJ   e Zd ZdZ	dddœdedee f‡ fdd„Zd	d
def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                   ó   || _ tƒ j|d� d S ©Nré   )rã   rD   rE   )rF   rã   rÙ   rG   rI   rJ   rE      ó   zRenderableColumn.__init__r‰   rÝ   rK   c                 C   r˜   rR   )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                       s€   e Zd ZdZ					ddedee d	ed
edee	 f
‡ fdd„Z
		ddedee d	eddfdd„Zdddef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__Úspinner_stylerK   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}|S | j | ¡ ¡}|S rR   )Ú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                       sd   e Zd ZdZ					ddededed	ed
ee	 dee
 ddf‡ fdd„Zdddefdd„Z‡  ZS )r€   zA column containing text.ÚnoneÚleftTNÚtext_formatrv   ÚjustifyÚmarkupÚhighlighterrÙ   rK   c                    s:   || _ || _|| _|| _|| _tƒ j|pt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r'| 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                       sf   e Zd ZdZ						ddee d	ed
edededee ddf‡ fdd„Zddde	f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Ù   rK   c                    s0   || _ || _|| _|| _|| _tƒ j|d� d S rë   )r  rv   rw   rx   ry   rD   rE   )rF   r  rv   rw   rx   ry   rÙ   rG   rI   rJ   rE   …  s   	zBarColumn.__init__r‰   rÝ   c                 C   s^   t |jdurtd|jƒndtd|jƒ| jdu rd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  s0    ùþýüûúùør‚   c                   @   ó"   e Zd ZdZdddefdd„ZdS )ÚTimeElapsedColumnzRenders time elapsed.r‰   rÝ   rK   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©rv   r   )Úseconds)rû   Úfinished_timeÚelapsedr8   r   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  ¤  ó    r  c                       sŒ   e Zd ZdZ								dd	ed
ededededee	 dee
 deddf‡ fdd„Zedee defdd„ƒZdddef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ÿ   Útext_format_no_percentagerv   r   r  r  rÙ   r{   rK   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ó   c                 C   sN   |du r
t ddd�S t t|ƒg d¢d¡\}}|| }t |d›|› d�dd�S )	zµRender the speed in iterations per second.

        Args:
            task (Task): A Task object.

        Returns:
            Text: Text object containing the task speed.
        Nrè   zprogress.percentager  )rè   u   Ã—10Â³u   Ã—10â�¶u   Ã—10â�¹u   Ã—10Â¹Â²éè  z.1fz it/s)r8   r*   Úpick_unit_and_suffixrÀ   )Úclsró   ÚunitÚsuffixÚ
data_speedrI   rI   rJ   Úrender_speedÔ  s   
ýzTaskProgressColumn.render_speedr‰   rÝ   c                 C   sˆ   |j d u r| jr|  |jp|j¡S |j d u r| jn| j}|j|d�}| jr0t	j
|| j| jd�}n	t	|| j| jd�}| jrB| 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                       sP   e Zd ZdZdZ			ddededee f‡ fdd	„Zd
dde	f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Ý   rK   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.r  zprogress.remainingNrè   r  z--:--r  é<   Ú02dú:Úd)	r~   rû   r  Útime_remainingrp   r8   r(  ÚdivmodrÀ   )rF   r‰   Z	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                   @   r  )ÚFileSizeColumnzRenders completed filesize.r‰   rÝ   rK   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   r2  (  r  r2  c                   @   r  )ÚTotalFileSizeColumnzRenders total filesize.r‰   rÝ   rK   c                 C   s*   |j durt t|j ƒ¡nd}t|dd�S )r3  Nrè   zprogress.filesize.totalr  )rp   r*   r4  rÀ   r8   r5  rI   rI   rJ   rà   4  s   zTotalFileSizeColumn.renderNr  rI   rI   rI   rJ   r7  1  r  r7  c                       sB   e Zd ZdZddedee f‡ fdd„Zdd	d
ef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                    rê   rë   )r:  rD   rE   )rF   r:  rÙ   rG   rI   rJ   rE   F  s   zMofNCompleteColumn.__init__r‰   rÝ   rK   c                 C   sP   t |jƒ}|jdurt |jƒnd}tt|ƒƒ}t||› d�›| j› |› �dd�S )zShow completed/total.NÚ?r,  úprogress.downloadr  )rÀ   rC   rp   r•   rÁ   r8   r:  )rF   r‰   rC   rp   Útotal_widthrI   rI   rJ   rà   J  s   
þzMofNCompleteColumn.render)r9  N)r`   ra   rb   rc   rÁ   r   r6   rE   r8   rà   rf   rI   rI   rG   rJ   r8  :  s    r8  c                       sH   e Zd ZdZ	ddedee ddf‡ fdd„Zd	d
def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Ù   rK   c                    rê   rë   )r>  rD   rE   )rF   r>  rÙ   rG   rI   rJ   rE   \  rì   zDownloadColumn.__init__r‰   rÝ   c                 C   sÔ   t |jƒ}|jdurt |jƒn|}| jr t |g d¢d¡\}}nt |g d¢d¡\}}|dk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ÚEiBÚZiBÚYiBi   )	r¾   ÚkBÚMBÚGBÚTBÚPBÚEBÚZBÚYBr  r)   r   z,.Úfr;  r9  rñ   r<  r  )rÀ   rC   rp   r>  r*   r  r8   )rF   r‰   rC   Z unit_and_suffix_calculation_baser!  r"  Ú	precisionZcompleted_ratioZcompleted_strrp   Útotal_ratioZ	total_strZdownload_statusZdownload_textrI   rI   rJ   rà   b  s2   
ÿ
ýý

zDownloadColumn.render)FN)r`   ra   rb   rc   r½   r   r6   rE   r8   rà   rf   rI   rI   rG   rJ   rÉ   U  s    ÿÿÿþrÉ   c                   @   r  )ÚTransferSpeedColumnz&Renders human readable transfer speed.r‰   rÝ   rK   c                 C   s@   |j p|j}|du rtddd�S t t|ƒ¡}t|› d�dd�S )zShow data transfer speed.Nr;  zprogress.data.speedr  z/s)r%  ró   r8   r*   r4  rÀ   )rF   r‰   ró   r#  rI   rI   rJ   rà   ‰  s
   zTransferSpeedColumn.renderNr  rI   rI   rI   rJ   rR  †  r  rR  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   rS  ’  s   
 rS  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< 	 defdd„Zedefdd„ƒZedee fdd„ƒZedee fdd „ƒZedefd!d"„ƒZedefd#d$„ƒZ edee fd%d&„ƒZ!edee fd'd(„ƒZ"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>Å  s   
 zTask.<lambda>)rV  rY  rZ  Ú	_progress)rZ  rV  Ú_lockrK   c                 C   s   |   ¡ S )z(float: Get the current time, in seconds.)rT  rU   rI   rI   rJ   rt   Ë  r    zTask.get_timec                 C   ó
   | j duS )z#bool: Check if the task as started.N)r[  rU   rI   rI   rJ   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)rp   rC   rU   rI   rI   rJ   Ú	remainingÔ  s   
zTask.remainingc                 C   s2   | j du rdS | jdur| j| j  S |  ¡ | j  S )z]Optional[float]: Time elapsed since task was started, or ``None`` if the task hasn't started.N)r[  r\  rt   rU   rI   rI   rJ   r  Û  s
   

zTask.elapsedc                 C   ra  )zCheck if the task has finished.N)r  rU   rI   rI   rJ   rû   ä  rb  zTask.finishedc                 C   s.   | j sdS | j| j  d }tdtd|ƒƒ}|S )zOfloat: Get progress of task as a percentage. If a None total was set, returns 0ç        ç      Y@)rp   rC   Úminr  )rF   rC   rI   rI   rJ   Ú
percentageé  s
   zTask.percentagec                 C   s°   | j du rdS | j�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 rR   r·   )Ú.0ÚsamplerI   rI   rJ   Ú	<genexpr>   ó   € zTask.speed.<locals>.<genexpr>)r[  r`  r_  râ   Úiterr”   r²   )rF   r>   Ú
total_timeZiter_progressZtotal_completedró   rI   rI   rJ   ró   ò  s"   
ýú$õz
Task.speedc                 C   s:   | j rdS | j}|sdS | j}|du rdS t|| ƒ}|S )zJOptional[float]: Get estimated time to completion, or ``None`` if no data.rd  N)rû   ró   rc  r   )rF   ró   rc  ÚestimaterI   rI   rJ   r-    s   zTask.time_remainingc                 C   s   | j  ¡  d| _d| _dS )zReset progress.N)r_  Úclearr  r%  rU   rI   rI   rJ   Ú_reset  s   

zTask._resetr_   )$r`   ra   rb   rc   r:   ræ   rÁ   r   rd   ÚGetTimeCallabler  rU  r½   r   ÚdictrW  r   r   r[  r\  r%  r_  r   rS  r   r`  rt   r¿   r  rc  r  rû   rg  ró   r-  rq  rI   rI   rI   rJ   rÝ   ›  sZ   
 
ÿrÝ   c                   @   sp  e Zd ZdZdddddddddddœ
deeef d	ee d
e	de
de
de	de	de	dee de	de	ddfdd„Zedeedf fdd„ƒZedefdd„ƒZedee fdd„ƒZedee fdd„ƒZede	fdd „ƒZdmd!d"„Zdmd#d$„Zdnd%d&„Zd'eee  d(ee d)ee ddfd*d+„Z			,	-dod.eee  e!e  f d/ee
 d0ee d1ed2e
dee  fd3d4„Z"	dpdd5d6œd7e#d/ee$ d0ee d1ede#f
d8d9„Z%e&j'	:			dqddd5d;œd7eed<e(f d=e)d> d?e$d@ee dAee dBee d/ee$ d0ee d1ede#fdCdD„ƒZ*e&j'	:			dqddd5d;œd7eed<e(f d=ee)dE e)dF f d?e$d@ee dAee dBee d/ee$ d0ee d1ede+fdGdD„ƒZ*	E	:			drddd5d;œd7eed<e(f d=ee)d> e)dF e)dE f d?e$d@ee dAee dBee d/ee$ d0ee d1edee#e+f fdHdD„Z*d0eddfdIdJ„Z,d0eddfdKdL„Z-dddddddMœd0ed/ee
 dNee
 dOee
 d1ee dPee	 dQe	dRe.ddfdSdT„Z/dddUdddVœd0edWe	d/ee
 dNe$dPee	 d1ee dRe.ddfdXdY„Z0dsd0edOe
ddfd[d\„Z1dmd]d^„Z2de3fd_d`„Z4dee3 fdadb„Z5dcee de6fddde„Z7de3fdfdg„Z8		h	U	dtd1edWe	d/ee
 dNe$dPe	dRe.defdidj„Z9d0eddfdkdl„Z:dS )ur?   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   Úexpandr†   rr   rq   ru   rt  rs   ru  rv  rt   rz   rw  rK   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)rr   rq   ru   rs   ru  rv  Úget_renderable)r   r`  Úget_default_columnsr†   rt  rz   rw  Ú_tasksr:   Ú_task_indexr2   r+   rx  Úliverr   rt   ÚprintÚlog)rF   rr   rq   ru   rt  rs   ru  rv  rt   rz   rw  r†   rI   rI   rJ   rE   )  s(   
ù	
zProgress.__init__.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   rI   rI   rJ   ry  M  s
   üzProgress.get_default_columnsc                 C   rž   rR   )r|  rr   rU   rI   rI   rJ   rr   l  r    zProgress.consolec                 C   ó8   | j � t| j ¡ ƒW  d  ƒ S 1 sw   Y  dS )zGet a list of Task instances.N)r`  Úlistrz  ÚvaluesrU   rI   rI   rJ   Útasksp  ó   $ÿzProgress.tasksc                 C   r  )zA list of task IDs.N)r`  r€  rz  ÚkeysrU   rI   rI   rJ   Útask_idsv  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   rh  rR   )rû   )ri  r‰   rI   rI   rJ   rk  ‚  rl  z$Progress.finished.<locals>.<genexpr>)r`  rz  Úallr�  rU   rI   rI   rJ   rû   |  s   þ$ýzProgress.finishedc                 C   s   | j s| jjdd� dS dS )zStart the progress display.T)rL   N)rz   r|  rT   rU   rI   rI   rJ   rT   „  s   ÿzProgress.startc                 C   s$   | j  ¡  | jjs| j ¡  dS dS )zStop the progress display.N)r|  rÆ   rr   Úis_interactiver}  rU   rI   rI   rJ   rÆ   ‰  s   
ÿzProgress.stopc                 C   rQ   rR   rS   rU   rI   rI   rJ   rV   �  rW   zProgress.__enter__rX   rY   rZ   c                 C   r�   rR   )rÆ   r]   rI   rI   rJ   r^   “  r�   zProgress.__exit__rg   rm   rn   rp   r@   ro   rA   c           
      c   sÈ   � |du rt t|ƒƒpd}|du r| j||d�}n| j||d� | jjrLt| ||ƒ�}|D ]}|V  | jd7  _q-W d  ƒ dS 1 sEw   Y  dS | j}| j	}	|D ]}|V  ||dƒ |	ƒ  qTd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_taskrO   r|  rq   r=   rC   rM   rL   )
rF   rn   rp   r@   ro   rA   Ztrack_threadÚvaluerM   rL   rI   rI   rJ   r…   ›  s(   €þ"ÿ
ýzProgress.trackrÇ   )r@   ro   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Š   )r`  rz  rp   Ú
ValueErrorr‰  rO   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Ñ   c          
      C   rÒ   rR   rI   ©
rF   rÈ   rŸ   rÎ   rÏ   rÐ   rÑ   rp   r@   ro   rI   rI   rJ   rÔ   î  ó   zProgress.openrÍ   rÌ   c          
      C   rÒ   rR   rI   rŽ  rI   rI   rJ   rÔ   þ  r�  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)Ú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‰  rO   ÚiorÔ   r‡   ÚTextIOWrapper)rF   rÈ   rŸ   rÎ   rÏ   rÐ   rÑ   rp   r@   ro   Ú_moder’  rˆ   rÅ   rI   rI   rJ   rÔ     s>   !þ
û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)r`  rz  r[  rt   )rF   r@   r‰   rI   rI   rJ   Ú
start_task[  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)r`  rz  rt   r[  r\  )rF   r@   r‰   rá   rI   rI   rJ   Ú	stop_taski  s   

"ûzProgress.stop_task)rp   rC   rM   ro   rU  rL   rC   rM   rU  rL   rW  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   )r`  rz  rC   rp   rq  ro   rU  rW  rO   rt   rt  r_  Úpopleftrâ   ÚappendrS  r  r  rL   )rF   r@   rp   rC   rM   ro   rU  rL   rW  r‰   Úcompleted_startÚupdate_completedrá   Úold_sample_timer_  r�  rI   rI   rJ   rO   x  sD   


ÿ

€à"ÿzProgress.updater   )rT   rp   rC   rU  ro   rT   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 )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   r`  rz  rq  r[  rp   rC   rU  rW  ro   r  rL   )
rF   r@   rT   rp   rC   rU  ro   rW  rá   r‰   rI   rI   rJ   Ú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)rt   r`  rz  rC   rt  r_  r�  râ   r•   rž  rS  rp   r  r  ró   r%  )
rF   r@   rM   rá   r‰   rŸ  r   r¡  r_  r�  rI   rI   rJ   rM   Ü  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)rz   r|  Z
is_startedrL   rU   rI   rI   rJ   rL   ú  s   ÿzProgress.refreshc                 C   s   t |  ¡ Ž }|S )z*Get a renderable for the progress display.)r-   Úget_renderables)rF   rã   rI   rI   rJ   rx  ÿ  s   zProgress.get_renderablec                 c   s   � |   | j¡}|V  dS )z5Get a number of renderables for the progress display.N)Úmake_tasks_tabler‚  )rF   ÚtablerI   rI   rJ   r£    s   €
zProgress.get_renderablesr‚  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÷   rÁ   r6   rÜ   Úcopy)ri  Ú_columnrI   rI   rJ   rk    s   € ýÿ

üz,Progress.make_tasks_table.<locals>.<genexpr>)r   r)   )Úpaddingrw  c                 3   s.   � | ]}t |tƒr|jˆ d �n|ˆ ƒV  qdS )r  N)r÷   rÁ   r  )ri  Úcolumnr  rI   rJ   rk    s   € ýÿ
ü)r†   r7   Úgridrw  rU  Úadd_row)rF   r‚  Útable_columnsr¥  rI   r  rJ   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)r`  rx  rU   rI   rI   rJ   Ú__rich__*  s   $ÿzProgress.__rich__re  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`.
        )rU  rW  rT  r`  r)   N)	r`  rÝ   r{  rt   rz  r›  r:   rÀ   rL   )	rF   ro   rT   rp   rC   rU  rW  r‰   Únew_task_indexrI   rI   rJ   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)r`  rz  )rF   r@   rI   rI   rJ   Úremove_taskZ  s   
"ÿzProgress.remove_taskr_   )rK   r?   )NNrg   rm   rR   ©r¦   NNN©rÍ   r¦   NNN)r)   )Tre  r   T);r`   ra   rb   rc   r%   rÁ   r×   r   r,   r½   rd   rr  rE   r&  r"   ry  r¿   rr   r   rÝ   r‚  r:   r…  rû   rT   rÆ   rV   r#   re   r   r^   r   r;   r    r…   r   rÀ   rÊ   ÚtypingÚoverloadr¾   r(   rÔ   r!   r›  rœ  r   rO   r¢  rM   rL   r/   rx  r£  r7   r¤  r­  r‰  r¯  rI   rI   rI   rJ   r?     s    ô
þýüûúùø	÷
öõô
ó$



þýü
ûúþýüûú
ù,ýúþýûú
ù*ù	õþýüûúù	÷
öõôù	õþýüûúù	÷
öõôù	õþýüûúù	÷
öõ

ô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)Z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)rr   rs   z[red]Downloadingr  rˆ  z[green]Processingz[yellow]Thinkingr'  r“   g333333Ó?g{®Gáz„?éd   )rg   NTNFNrh   ri   rj   rk   rl   rm   FTr°  r±  )‡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(   Útyping_extensionsrè   r*   r+   rr   r,   r-   r.   r/   r  r0   Újupyterr1   r|  r2   Úprogress_barr3   rö   r4   rv   r5   r¥  r6   r7   rü   r8   r9   rÀ   r:   r;   rd   rr  r<   r=   rÁ   r½   r…   r‡   rÄ   rÊ   r³  r¾   rÔ   r×   rç   rí   r€   r‚   r  rƒ   r„   r2  r7  r8  rÉ   rR  rS  rÝ   r?   r`   ÚrandomÚtimeÚpanelrµ  Úruler¶  Úsyntaxr·  r«  Zprogress_renderablesÚ	itertoolsrÀ  Úexamplesry  r>   r‰  Ztask1Ztask2Ztask3rû   rO   ÚsleepÚrandintr~  r”   rI   rI   rI   rJ   Ú<module>   sÞ   P

*ñÿþýüûúùø	÷
öõôóòñ
ðFdòÿþüûúùø	÷
öõôóò
ñAúíÿþýüûúø	÷
öõôóòñðïîíìúíÿþýüûúø	÷
öõôóòñðïîíìúíÿþýüûúø	÷
öõôóòñðïîí
ìV*2*H0		1	}    
Pó÷
ÿþýû

ûõ$õÒ