a
    �˜ë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ƒZTd”d)d*d+d,d-d.d-d/d0d1d1d1d1d0d-d-d)d2œd3d4„ZUG d5d6„ d6ee!ƒZVG d7d8„ d8e#eS e&eS ƒZWd9d!dd"dd#d$d%d&d'd"d:œd;d,d*d-d.d-d/d0d1d1d1d1d-d<d=œd>d?„ZXejYd•dd9d!dd"dd#d$d%d&d'd"dAœdBdCd,dDdDdDdEd*d-d.d-d/d0d1d1d1d1d-dFdGœdHdI„ƒZZejYd–dd9d!dd"dd#d$d%d&d'd"dAœdBdJd,dDdDdDdEd*d-d.d-d/d0d1d1d1d1d-d<dGœdKdI„ƒZZd—dd9d!dd"dd#d$d%d&d'd"dAœdBdMd,dDdDdDdEd*d-d.d-d/d0d1d1d1d1d-dNdGœdOdI„ZZG dPdQ„ dQeƒZ[G dRdS„ dSe[ƒZ\G dTdU„ dUe[ƒZ]G dVdW„ dWe[ƒZ^G dXdY„ dYe[ƒZ_G dZd[„ d[e[ƒZ`G d\d]„ d]e^ƒZaG d^d_„ d_e[ƒZbG d`da„ dae[ƒZcG dbdc„ dce[ƒZdG ddde„ dee[ƒZeG dfdg„ dge[ƒZfG dhdi„ die[ƒZgG djdk„ dke*ƒZheG dldm„ dmƒƒZiG dndo„ doe?ƒZjekdpk�rd dllZld dlmZmddqlnmoZo ddrlpmqZq ddslrmsZs ddtlHmJZJ esdudvd!dw�ZreJdxdydzƒ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‰œŽ�ŒZzezj{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ƒ¡ �q’W d  ƒ n1 �sú0    Y  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                      sZ   e Zd ZdZddddœ‡ fdd„Zdd	œd
d„Zdd	œdd„Zdddddœdd„Z‡  ZS )Ú_TrackThreadz)A thread to periodically update progress.ú
'Progress'z'TaskID'Úfloat)ÚprogressÚtask_idÚupdate_periodc                   s2   || _ || _|| _tƒ | _d| _tƒ jdd� d S )Nr   T)Údaemon)r@   rA   rB   r   ÚdoneÚ	completedÚsuperÚ__init__)Úselfr@   rA   rB   ©Ú	__class__© úL/mnt/bigstor/www/usecases/.venv/lib/python3.9/site-packages/rich/progress.pyrG   C   s    z_TrackThread.__init__ÚNone©Úreturnc                 C  sn   | j }| jj}| j}d}| jj}||ƒsT| jjjrT| j}||kr |||| ƒ |}q | jj	| j | jdd� d S )Nr   T)rE   Úrefresh)
rA   r@   ÚadvancerB   rD   ÚwaitÚliveÚ
is_startedrE   Úupdate)rH   rA   rQ   rB   Zlast_completedrR   rE   rK   rK   rL   ÚrunL   s    z_TrackThread.runz'_TrackThread'c                 C  s   |   ¡  | S ©N©Ústart©rH   rK   rK   rL   Ú	__enter__Z   s    z_TrackThread.__enter__úOptional[Type[BaseException]]úOptional[BaseException]úOptional[TracebackType]©Úexc_typeÚexc_valÚexc_tbrO   c                 C  s   | j  ¡  |  ¡  d S rW   )rD   ÚsetÚjoin©rH   r`   ra   rb   rK   rK   rL   Ú__exit__^   s    
z_TrackThread.__exit__)	Ú__name__Ú
__module__Ú__qualname__Ú__doc__rG   rV   r[   rf   Ú__classcell__rK   rK   rI   rL   r=   @   s
   	r=   ú
Working...TFé
   úbar.backúbar.completeúbar.finishedú	bar.pulseçš™™™™™¹?úIterable[ProgressType]ÚstrúOptional[float]ÚintÚboolúOptional[Console]zOptional[Callable[[], float]]r?   r5   )ÚsequenceÚdescriptionÚtotalrE   Úauto_refreshÚconsoleÚ	transientÚget_timeÚrefresh_per_secondÚstyleÚcomplete_styleÚfinished_styleÚpulse_stylerB   ÚdisableÚ
show_speedrO   c              	   c  s˜   |rt dƒgng }| t|	|
||d�t|d�tdd�f¡ t||||||pLd|dœŽ}|�* |j| ||||d�E d	H  W d	  ƒ n1 sŠ0    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_finishedrm   ©r|   r}   r~   r   r€   r…   )r{   rE   rz   rB   N)Ú
TextColumnÚextendÚ	BarColumnÚTaskProgressColumnÚTimeRemainingColumnÚProgressÚtrack)ry   rz   r{   rE   r|   r}   r~   r   r€   r�   r‚   rƒ   r„   rB   r…   r†   Úcolumnsr@   rK   rK   rL   r‘   h   s<    ,ÿüøÿù
ûr‘   c                   @  sv  e Zd ZdZdKddddddœd	d
„Zddœdd„Zdddddœdd„Zddœdd„Zddœdd„Ze	ddœdd„ƒZ
ddœdd„Zddœdd „Ze	d!dœd"d#„ƒZe	d!dœd$d%„ƒZddœd&d'„Zddœd(d)„Zddœd*d+„ZdLddd-œd.d/„Zd0d1œd2d3„ZdMddd-œd4d5„ZdNdd6d7œd8d9„Zddœd:d;„ZdOdddd=œd>d?„Zddœd@dA„ZdBddCœdDdE„ZdFddGœdHdI„ZdJS )PÚ_Readerz9A reader that tracks progress while it's being read from.Tr   r>   r:   rw   rM   )Úhandler@   ÚtaskÚclose_handlerO   c                 C  s"   || _ || _|| _|| _d| _d S ©NF)r”   r@   r•   r–   Ú_closed)rH   r”   r@   r•   r–   rK   rK   rL   rG   ¹   s
    z_Reader.__init__z	'_Reader'rN   c                 C  s   | j  ¡  | S rW   )r”   r[   rZ   rK   rK   rL   r[   Æ   s    
z_Reader.__enter__r\   r]   r^   r_   c                 C  s   |   ¡  d S rW   )Úclosere   rK   rK   rL   rf   Ê   s    z_Reader.__exit__c                 C  s   | S rW   rK   rZ   rK   rK   rL   Ú__iter__Ò   s    z_Reader.__iter__Úbytesc                 C  s$   t | jƒ}| jj| jt|ƒd� |S ©N©rQ   )Únextr”   r@   rQ   r•   Úlen)rH   ÚlinerK   rK   rL   Ú__next__Õ   s    
z_Reader.__next__c                 C  s   | j S rW   )r˜   rZ   rK   rK   rL   ÚclosedÚ   s    z_Reader.closedrv   c                 C  s
   | j  ¡ S rW   )r”   ÚfilenorZ   rK   rK   rL   r£   Þ   s    z_Reader.filenoc                 C  s
   | j  ¡ S rW   )r”   ÚisattyrZ   rK   rK   rL   r¤   á   s    z_Reader.isattyrt   c                 C  s   | j jS rW   )r”   ÚmoderZ   rK   rK   rL   r¥   ä   s    z_Reader.modec                 C  s   | j jS rW   )r”   ÚnamerZ   rK   rK   rL   r¦   è   s    z_Reader.namec                 C  s
   | j  ¡ S rW   )r”   ÚreadablerZ   rK   rK   rL   r§   ì   s    z_Reader.readablec                 C  s
   | j  ¡ S rW   )r”   ÚseekablerZ   rK   rK   rL   r¨   ï   s    z_Reader.seekablec                 C  s   dS r—   rK   rZ   rK   rK   rL   Úwritableò   s    z_Reader.writableéÿÿÿÿ)ÚsizerO   c                 C  s&   | j  |¡}| jj| jt|ƒd� |S rœ   )r”   Úreadr@   rQ   r•   rŸ   )rH   r«   ÚblockrK   rK   rL   r¬   õ   s    z_Reader.readz"Union[bytearray, memoryview, mmap])Úbc                 C  s"   | j  |¡}| jj| j|d� |S rœ   )r”   Úreadintor@   rQ   r•   )rH   r®   ÚnrK   rK   rL   r¯   ú   s    z_Reader.readintoc                 C  s&   | j  |¡}| jj| jt|ƒd� |S rœ   )r”   Úreadliner@   rQ   r•   rŸ   )rH   r«   r    rK   rK   rL   r±   ÿ   s    z_Reader.readlinezList[bytes])ÚhintrO   c                 C  s,   | j  |¡}| jj| jttt|ƒƒd� |S rœ   )r”   Ú	readlinesr@   rQ   r•   ÚsumÚmaprŸ   )rH   r²   ÚlinesrK   rK   rL   r³     s    z_Reader.readlinesc                 C  s   | j r| j ¡  d| _d S )NT)r–   r”   r™   r˜   rZ   rK   rK   rL   r™   	  s    
z_Reader.closer   )ÚoffsetÚwhencerO   c                 C  s$   | j  ||¡}| jj| j|d� |S )N©rE   )r”   Úseekr@   rU   r•   )rH   r·   r¸   ÚposrK   rK   rL   rº     s    z_Reader.seekc                 C  s
   | j  ¡ S rW   )r”   ÚtellrZ   rK   rK   rL   r¼     s    z_Reader.tellr   )ÚsrO   c                 C  s   t dƒ‚d S )NÚwrite©r   )rH   r½   rK   rK   rL   r¾     s    z_Reader.writezIterable[Any])r¶   rO   c                 C  s   t dƒ‚d S )NÚ
writelinesr¿   )rH   r¶   rK   rK   rL   rÀ     s    z_Reader.writelinesN)T)rª   )rª   )rª   )r   )rg   rh   ri   rj   rG   r[   rf   rš   r¡   Úpropertyr¢   r£   r¤   r¥   r¦   r§   r¨   r©   r¬   r¯   r±   r³   r™   rº   r¼   r¾   rÀ   rK   rK   rK   rL   r“   ¶   s6    ûr“   c                   @  sD   e Zd ZdZddddœdd„Zddœd	d
„Zdddddœdd„ZdS )Ú_ReadContextzEA utility class to handle a context for both a reader and a progress.r>   r<   rM   )r@   ÚreaderrO   c                 C  s   || _ || _d S rW   )r@   rÃ   )rH   r@   rÃ   rK   rK   rL   rG      s    z_ReadContext.__init__rN   c                 C  s   | j  ¡  | j ¡ S rW   )r@   rY   rÃ   r[   rZ   rK   rK   rL   r[   $  s    
z_ReadContext.__enter__r\   r]   r^   r_   c                 C  s   | j  ¡  | j |||¡ d S rW   )r@   ÚstoprÃ   rf   re   rK   rK   rL   rf   (  s    
z_ReadContext.__exit__N)rg   rh   ri   rj   rG   r[   rf   rK   rK   rK   rL   rÂ     s   rÂ   ú
Reading...)rz   r|   r}   r~   r   r€   r�   r‚   rƒ   r„   r…   r   zContextManager[BinaryIO])Úfiler{   rz   r|   r}   r~   r   r€   r�   r‚   rƒ   r„   r…   rO   c             	   C  sh   |rt dƒgng }| t||	|
|d�tƒ tƒ f¡ t||||||pDd|dœŽ}|j| ||d�}t||ƒS )a  Read bytes from a file while tracking progress.

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

    r‡   rˆ   rm   rŠ   )r{   rz   )r‹   rŒ   r�   ÚDownloadColumnr�   r�   Ú	wrap_filerÂ   )rÆ   r{   rz   r|   r}   r~   r   r€   r�   r‚   rƒ   r„   r…   r’   r@   rÃ   rK   rK   rL   rÈ   2  s0    %ÿüøÿù
rÈ   rª   )r{   rz   r|   r}   r~   r   r€   r�   r‚   rƒ   r„   r…   ú"Union[str, 'PathLike[str]', bytes]z"Union[Literal['rt'], Literal['r']]úOptional[str]úOptional[int]zContextManager[TextIO])rÆ   r¥   Ú	bufferingÚencodingÚerrorsÚnewliner{   rz   r|   r}   r~   r   r€   r�   r‚   rƒ   r„   r…   rO   c                C  s   d S rW   rK   ©rÆ   r¥   rÌ   rÍ   rÎ   rÏ   r{   rz   r|   r}   r~   r   r€   r�   r‚   rƒ   r„   r…   rK   rK   rL   Úopens  s    rÑ   úLiteral['rb']c                C  s   d S rW   rK   rÐ   rK   rK   rL   rÑ   Œ  s    Úrú1Union[Literal['rb'], Literal['rt'], Literal['r']]z7Union[ContextManager[BinaryIO], ContextManager[TextIO]]c             
   C  sr   |rt dƒgng }| t||||d�tƒ tƒ f¡ t|||	|
||pDd|dœŽ}|j| |||||||d�}t||ƒS )a®  Read bytes from a file while tracking progress.

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

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

    r‡   rˆ   rm   rŠ   )r¥   rÌ   rÍ   rÎ   rÏ   r{   rz   )r‹   rŒ   r�   rÇ   r�   r�   rÑ   rÂ   )rÆ   r¥   rÌ   rÍ   rÎ   rÏ   r{   rz   r|   r}   r~   r   r€   r�   r‚   rƒ   r„   r…   r’   r@   rÃ   rK   rK   rL   rÑ   ¥  sB    1ÿüøÿù
ø
c                   @  sb   e Zd ZU dZdZded< ddddœdd	„Zd
dœdd„Zdddœdd„Ze	dddœdd„ƒZ
dS )ÚProgressColumnz3Base class for a widget to use in progress display.Nru   Úmax_refreshúOptional[Column]rM   )Útable_columnrO   c                 C  s   || _ i | _d | _d S rW   )Ú_table_columnÚ_renderable_cacheZ_update_time)rH   rØ   rK   rK   rL   rG      s    zProgressColumn.__init__r6   rN   c                 C  s   | j p
tƒ S )z.Get a table column, used to build tasks table.)rÙ   r6   rZ   rK   rK   rL   Úget_table_column  s    zProgressColumn.get_table_columnú'Task'r/   ©r•   rO   c                 C  sp   |  ¡ }| jdurR|jsRz| j|j \}}W n ty>   Y n0 || j |krR|S |  |¡}||f| j|j< |S )a  Called by the Progress object to return a renderable for the given task.

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

        Returns:
            RenderableType: Anything renderable (including str).
        N)r   rÖ   rE   rÚ   ÚidÚKeyErrorÚrender)rH   r•   Úcurrent_timeÚ	timestampÚ
renderablerK   rK   rL   Ú__call__	  s    	
zProgressColumn.__call__c                 C  s   dS )z"Should return a renderable object.NrK   ©rH   r•   rK   rK   rL   rà      s    zProgressColumn.render)N)rg   rh   ri   rj   rÖ   Ú__annotations__rG   rÛ   rä   r   rà   rK   rK   rK   rL   rÕ   û  s   
rÕ   c                      s@   e Zd ZdZdddœdddœ‡ fdd	„Zd
d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                  s   || _ tƒ j|d� d S ©Nré   )rã   rF   rG   )rH   rã   rØ   rI   rK   rL   rG   ,  s    zRenderableColumn.__init__rÜ   rÝ   c                 C  s   | j S rW   )rã   rå   rK   rK   rL   rà   2  s    zRenderableColumn.render)rè   ©rg   rh   ri   rj   rG   rà   rk   rK   rK   rI   rL   rç   %  s    ÿÿrç   c                      sV   e Zd ZdZdddd	d
ddœ‡ fdd„Zdddd	ddœdd„Zdd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ç      ð?ú Nrt   zOptional[StyleType]r?   r9   r×   )Úspinner_namer�   ÚspeedÚfinished_textrØ   c                   s<   t |||d�| _t|tƒr$t |¡n|| _tƒ j|d� d S )N©r�   rò   ré   )	r4   ÚspinnerÚ
isinstancert   r8   Úfrom_markupró   rF   rG   )rH   rñ   r�   rò   ró   rØ   rI   rK   rL   rG   @  s    ÿýzSpinnerColumn.__init__rM   )rñ   Úspinner_stylerò   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õ   )rH   rñ   rø   rò   rK   rK   rL   Úset_spinnerP  s    zSpinnerColumn.set_spinnerrÜ   r/   rÝ   c                 C  s    |j r| jn| j | ¡ ¡}|S rW   )Úfinishedró   rõ   rà   r   )rH   r•   ÚtextrK   rK   rL   rà   _  s
    ÿýzSpinnerColumn.render)rí   rî   rï   rð   N)rî   rï   )rg   rh   ri   rj   rG   rù   rà   rk   rK   rK   rI   rL   rì   6  s        ú  ürì   c                	      sD   e Zd ZdZddddd	d
dddœ‡ fdd„Zdddœdd„Z‡  ZS )r‹   zA column containing text.ÚnoneÚleftTNrt   r5   r.   rw   úOptional[Highlighter]r×   rM   )Útext_formatr�   ÚjustifyÚmarkupÚhighlighterrØ   rO   c                   s:   || _ || _|| _|| _|| _tƒ j|p0tdd�d� d S )NT©Zno_wrapré   )rÿ   r   r�   r  r  rF   rG   r6   )rH   rÿ   r�   r   r  r  rØ   rI   rK   rL   rG   k  s    	zTextColumn.__init__rÜ   r8   rÝ   c                 C  sR   | j j|d�}| jr*tj|| j| jd�}nt|| j| jd�}| jrN| j |¡ |S ©N©r•   )r�   r   )	rÿ   Úformatr  r8   r÷   r�   r   r  Ú	highlight)rH   r•   Ú_textrû   rK   rK   rL   rà   {  s    zTextColumn.render)rü   rý   TNNrë   rK   rK   rI   rL   r‹   h  s        ù r‹   c                	      sD   e Zd ZdZddd	d	d	d	d
ddœ‡ fdd„Zdd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".
    é(   rn   ro   rp   rq   NrË   r5   r×   rM   )Ú	bar_widthr�   r‚   rƒ   r„   rØ   rO   c                   s0   || _ || _|| _|| _|| _tƒ j|d� d S rê   )r
  r�   r‚   rƒ   r„   rF   rG   )rH   r
  r�   r‚   rƒ   r„   rØ   rI   rK   rL   rG   ‘  s    	zBarColumn.__init__rÜ   r3   rÝ   c                 C  s^   t |jdurtd|jƒndtd|jƒ| jdu r2dn
td| jƒ|j | ¡ | j| j| j	| j
d�	S )z&Gets a progress bar widget for a task.Nr   r)   )	r{   rE   ÚwidthZpulseZanimation_timer�   r‚   rƒ   r„   )r3   r{   ÚmaxrE   r
  Ústartedr   r�   r‚   rƒ   r„   rå   rK   rK   rL   rà   ¡  s    
÷zBarColumn.render)r	  rn   ro   rp   rq   Nrë   rK   rK   rI   rL   r�   †  s         ù r�   c                   @  s    e Zd ZdZdddœdd„ZdS )ÚTimeElapsedColumnzRenders time elapsed.rÜ   r8   rÝ   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  rv   rt   )rH   r•   r  ÚdeltarK   rK   rL   rà   ³  s
    zTimeElapsedColumn.renderN©rg   rh   ri   rj   rà   rK   rK   rK   rL   r  °  s   r  c                      s\   e Zd ZdZdd	d	d
dddddddœ	‡ fdd„Zedddœdd„ƒZdd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ý   TNFrt   r5   r.   rw   rþ   r×   rM   )	rÿ   Útext_format_no_percentager�   r   r  r  rØ   r†   rO   c	           	        s(   || _ || _tƒ j||||||d� d S )N)rÿ   r�   r   r  r  rØ   )r  r†   rF   rG   )	rH   rÿ   r  r�   r   r  r  rØ   r†   rI   rK   rL   rG   Ê  s    úzTaskProgressColumn.__init__ru   r8   )rò   rO   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_suffixrv   )Úclsrò   ÚunitÚsuffixÚ
data_speedrK   rK   rL   Úrender_speedà  s    
ýzTaskProgressColumn.render_speedrÜ   rÝ   c                 C  sˆ   |j d u r"| jr"|  |jp|j¡S |j d u r2| jn| j}|j|d�}| jr`t	j
|| j| jd�}nt	|| j| jd�}| jr„| j |¡ |S r  )r{   r†   r  Úfinished_speedrò   r  rÿ   r  r  r8   r÷   r�   r   r  r  )rH   r•   rÿ   r  rû   rK   rK   rL   rà   ô  s    ÿzTaskProgressColumn.render)r  rè   rü   rý   TNNF)	rg   rh   ri   rj   rG   Úclassmethodr  rà   rk   rK   rK   rI   rL   rŽ   ¼  s           ÷$rŽ   c                      s@   e Zd ZdZdZdddddœ‡ fdd	„Zd
d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.
    ç      à?FNrw   r×   )Úcompactr‰   rØ   c                   s   || _ || _tƒ j|d� d S rê   )r#  r‰   rF   rG   )rH   r#  r‰   rØ   rI   rK   rL   rG     s    zTimeRemainingColumn.__init__rÜ   r8   rÝ   c                 C  sº   | j r|jr|j}d}n
|j}d}|jdu r8td|d�S |du rVt| jrLdnd|d�S tt|ƒdƒ\}}t|dƒ\}}| jr”|s”|d	›d
|d	›�}n|d›d
|d	›d
|d	›�}t||d�S )zShow time remaining.r  zprogress.remainingNrè   r  z--:--r  é<   Z02dú:Úd)	r‰   rú   r  Útime_remainingr{   r8   r#  Údivmodrv   )rH   r•   Z	task_timer�   Úminutesr  ÚhoursÚ	formattedrK   rK   rL   rà     s    

zTimeRemainingColumn.render)FFN)rg   rh   ri   rj   rÖ   rG   rà   rk   rK   rK   rI   rL   r�     s      ü
r�   c                   @  s    e Zd ZdZdddœdd„ZdS )ÚFileSizeColumnzRenders completed filesize.rÜ   r8   rÝ   c                 C  s   t  t|jƒ¡}t|dd�S )úShow data completed.zprogress.filesizer  )r*   Údecimalrv   rE   r8   ©rH   r•   Ú	data_sizerK   rK   rL   rà   7  s    zFileSizeColumn.renderNr  rK   rK   rK   rL   r,  4  s   r,  c                   @  s    e Zd ZdZdddœdd„ZdS )ÚTotalFileSizeColumnzRenders total filesize.rÜ   r8   rÝ   c                 C  s*   |j durt t|j ƒ¡nd}t|dd�S )r-  Nrè   zprogress.filesize.totalr  )r{   r*   r.  rv   r8   r/  rK   rK   rL   rà   @  s    zTotalFileSizeColumn.renderNr  rK   rK   rK   rL   r1  =  s   r1  c                      s:   e Zd ZdZddddœ‡ fdd„Zd	d
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 "/".
    ú/Nrt   r×   )Ú	separatorrØ   c                   s   || _ tƒ j|d� d S rê   )r4  rF   rG   )rH   r4  rØ   rI   rK   rL   rG   R  s    zMofNCompleteColumn.__init__rÜ   r8   rÝ   c                 C  sP   t |jƒ}|jdurt |jƒnd}tt|ƒƒ}t||› d�›| j› |› �dd�S )zShow completed/total.Nú?r&  úprogress.downloadr  )rv   rE   r{   rŸ   rt   r8   r4  )rH   r•   rE   r{   Ztotal_widthrK   rK   rL   rà   V  s    
þzMofNCompleteColumn.render)r3  Nrë   rK   rK   rI   rL   r2  F  s   r2  c                      s<   e Zd ZdZdddddœ‡ fdd	„Zd
d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.
    FNrw   r×   rM   )Úbinary_unitsrØ   rO   c                   s   || _ tƒ j|d� d S rê   )r7  rF   rG   )rH   r7  rØ   rI   rK   rL   rG   h  s    zDownloadColumn.__init__rÜ   r8   rÝ   c                 C  sÔ   t |jƒ}|jdurt |jƒn|}| jr@t |g d¢d¡\}}nt |g d¢d¡\}}|dkrbdnd}|| }|d|› d	�›}|jdur¬t |jƒ}	|	| }
|
d|› d	�›}nd
}|› d|› d|› �}t|dd�}|S )z.Calculate common unit for completed and total.N)	r›   ZKiBZMiBZGiBZTiBZPiBZEiBZZiBZYiBi   )	r›   ZkBZMBZGBZTBZPBZEBZZBZYBr  r)   r   z,.Úfr5  r3  rð   r6  r  )rv   rE   r{   r7  r*   r  r8   )rH   r•   rE   Z unit_and_suffix_calculation_baser  r  Z	precisionZcompleted_ratioZcompleted_strr{   Ztotal_ratioZ	total_strZdownload_statusZdownload_textrK   rK   rL   rà   n  s2    
ÿý
ý

zDownloadColumn.render)FNrë   rK   rK   rI   rL   rÇ   a  s    ÿrÇ   c                   @  s    e Zd ZdZdddœdd„ZdS )ÚTransferSpeedColumnz&Renders human readable transfer speed.rÜ   r8   rÝ   c                 C  s@   |j p
|j}|du r tddd�S t t|ƒ¡}t|› d�dd�S )zShow data transfer speed.Nr5  zprogress.data.speedr  z/s)r   rò   r8   r*   r.  rv   )rH   r•   rò   r  rK   rK   rL   rà   •  s
    zTransferSpeedColumn.renderNr  rK   rK   rK   rL   r9  ’  s   r9  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.r?   râ   rE   N)rg   rh   ri   rj   ræ   rK   rK   rK   rL   r:  ž  s   
r:  c                   @  sd  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 < dd!œd"d#„Zedd!œd$d%„ƒZedd!œd&d'„ƒZedd!œd(d)„ƒZedd!œd*d+„ƒZedd!œd,d-„ƒZedd!œd.d/„ƒZedd!œd0d1„ƒZd2d!œd3d4„ZdS )5ÚTaskz…Information regarding a progress task.

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

    r:   rÞ   rt   rz   ru   r{   r?   rE   ÚGetTimeCallableÚ	_get_timeNr  Trw   Úvisible)Údefault_factoryzDict[str, Any]ÚfieldsF)ÚdefaultÚinitÚreprÚ
start_timeÚ	stop_timer   c                   C  s
   t dd�S )Nr  )Úmaxlenr   rK   rK   rK   rL   Ú<lambda>Ñ  ó    zTask.<lambda>)r?  rB  rC  zDeque[ProgressSample]Ú	_progress)rC  r?  r   Ú_lockrN   c                 C  s   |   ¡ S )z(float: Get the current time, in seconds.)r=  rZ   rK   rK   rL   r   ×  s    zTask.get_timec                 C  s
   | j duS )z#bool: Check if the task as started.N)rD  rZ   rK   rK   rL   r  Û  s    zTask.startedc                 C  s   | j du rdS | j | j S )zPOptional[float]: Get the number of steps remaining, if a non-None total was set.N©r{   rE   rZ   rK   rK   rL   Ú	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)rD  rE  r   rZ   rK   rK   rL   r  ç  s
    

zTask.elapsedc                 C  s
   | j duS )zCheck if the task has finished.N)r  rZ   rK   rK   rL   rú   ð  s    zTask.finishedc                 C  s.   | j s
dS | j| j  d }tdtd|ƒƒ}|S )zOfloat: Get progress of task as a percentage. If a None total was set, returns 0ç        ç      Y@)r{   rE   Úminr  )rH   rE   rK   rK   rL   Ú
percentageõ  s
    zTask.percentagec                 C  s¬   | j du rdS | j�„ | j}|s0W d  ƒ dS |d j|d j }|dkr\W d  ƒ dS t|ƒ}t|ƒ tdd„ |D ƒƒ}|| }|W  d  ƒ S 1 sž0    Y  dS )z=Optional[float]: Get the estimated speed in steps per second.Nrª   r   c                 s  s   | ]}|j V  qd S rW   r¹   )Ú.0ÚsamplerK   rK   rL   Ú	<genexpr>  rH  zTask.speed.<locals>.<genexpr>)rD  rJ  rI  râ   Úiterrž   r´   )rH   r@   Z
total_timeZiter_progressZtotal_completedrò   rK   rK   rL   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.rM  N)rú   rò   rL  r   )rH   rò   rL  ZestimaterK   rK   rL   r'    s    zTask.time_remainingrM   c                 C  s   | j  ¡  d| _d| _dS )zReset progress.N)rI  Úclearr  r   rZ   rK   rK   rL   Ú_reset  s    
zTask._reset)rg   rh   ri   rj   ræ   r  r>  r   Údictr@  rD  rE  r   rI  r   rJ  r   rÁ   r  rL  r  rú   rP  rò   r'  rV  rK   rK   rK   rL   r;  §  s@   

ÿr;  c                   @  s°  e Zd ZdZdddddddddddœ
dd	d
ddd
d
d
dd
d
ddœdd„Zeddœdd„ƒZeddœdd„ƒZeddœdd„ƒZ	eddœdd„ƒZ
ed
dœdd„ƒZddœd d!„Zddœd"d#„Zd$dœd%d&„Zd'd(d)dd*œd+d,„Zdwd0d1d2d3d4dd0d5œd6d7„Zdxdd8d9œd:d;d3d4d:d<œd=d>„Zejdyddd8d@œdAdBd2dCdCdCd;d3d4d:dDœ
dEdF„ƒZejdzddd8d@œdAdGd2dCdCdCd;d3d4dHdDœ
dIdF„ƒZd{ddd8d@œdAdKd2dCdCdCd;d3d4dLdDœ
dMdF„ZdNddOœdPdQ„ZdNddOœdRdS„ZdddddddTœdNd1d1d1dCdUd
dVddWœ	dXdY„Zddd-dddZœdNd
d1d2dUdCdVdd[œd\d]„Zd|dNddd_œd`da„Zddœdbdc„Zdddœdedf„Zdgdœdhdi„Zdjdkdlœdmdn„Zdddœdodp„Zd}d4d
d1d2d
dVdNdrœdsdt„ZdNddOœdudv„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.
    NTrm   g      >@F)
r}   r|   r€   Úspeed_estimate_periodr~   Úredirect_stdoutÚredirect_stderrr   r…   ÚexpandzUnion[str, ProgressColumn]rx   rw   r?   zOptional[GetTimeCallable]rM   )r’   r}   r|   r€   rX  r~   rY  rZ  r   r…   r[  rO   c       
      	   G  sŽ   |dksJ dƒ‚t ƒ | _|p"|  ¡ | _|| _|	| _|
| _i | _tdƒ| _	t
|pRtƒ |||||| jd�| _|pr| jj| _| jj| _| jj| _d S )Nr   zrefresh_per_second must be > 0)r}   r|   r€   r~   rY  rZ  Úget_renderable)r   rJ  Úget_default_columnsr’   rX  r…   r[  Ú_tasksr:   Ú_task_indexr2   r+   r\  rS   r}   r   ÚprintÚlog)rH   r}   r|   r€   rX  r~   rY  rZ  r   r…   r[  r’   rK   rK   rL   rG   5  s(    
ù	
zProgress.__init__zTuple[ProgressColumn, ...]rN   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  rK   rK   rL   r]  Y  s
    üzProgress.get_default_columnsr,   c                 C  s   | j jS rW   )rS   r}   rZ   rK   rK   rL   r}   x  s    zProgress.consolez
List[Task]c                 C  s8   | j � t| j ¡ ƒW  d  ƒ S 1 s*0    Y  dS )zGet a list of Task instances.N)rJ  Úlistr^  ÚvaluesrZ   rK   rK   rL   Útasks|  s    zProgress.taskszList[TaskID]c                 C  s8   | j � t| j ¡ ƒW  d  ƒ S 1 s*0    Y  dS )zA list of task IDs.N)rJ  rb  r^  ÚkeysrZ   rK   rK   rL   Útask_ids‚  s    zProgress.task_idsc                 C  sX   | j �> | jsW d  ƒ dS tdd„ | j ¡ D ƒƒW  d  ƒ S 1 sJ0    Y  dS )z'Check if all tasks have been completed.NTc                 s  s   | ]}|j V  qd S rW   )rú   )rQ  r•   rK   rK   rL   rS  Ž  rH  z$Progress.finished.<locals>.<genexpr>)rJ  r^  Úallrc  rZ   rK   rK   rL   rú   ˆ  s    zProgress.finishedc                 C  s   | j s| jjdd� dS )zStart the progress display.T)rP   N)r…   rS   rY   rZ   rK   rK   rL   rY   �  s    zProgress.startc                 C  s.   | j s*| j ¡  | jjs*| jjs*| j ¡  dS )zStop the progress display.N)r…   rS   rÄ   r}   Zis_interactiveZ
is_jupyterr`  rZ   rK   rK   rL   rÄ   •  s    
zProgress.stopr(   c                 C  s   |   ¡  | S rW   rX   rZ   rK   rK   rL   r[   œ  s    zProgress.__enter__r\   r]   r^   r_   c                 C  s   |   ¡  d S rW   )rÄ   re   rK   rK   rL   rf      s    zProgress.__exit__r   rl   rr   rs   ru   rv   zOptional[TaskID]rt   )ry   r{   rE   rA   rz   rB   rO   c                 c  sÆ   |du rt t|ƒƒpd}|du r2| j|||d�}n| j|||d� | jjr–t| ||ƒ�.}|D ]}|V  | jd7  _q\W d  ƒ qÂ1 sŠ0    Y  n,| j}	| j	}
|D ]}|V  |	|dƒ |
ƒ  q¦d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.
        NrK  r)   )
r?   r   Úadd_taskrU   rS   r|   r=   rE   rQ   rP   )rH   ry   r{   rE   rA   rz   rB   Ztrack_threadÚvaluerQ   rP   rK   rK   rL   r‘   ¨  s     0
zProgress.trackrÅ   )rA   rz   r   rË   )rÆ   r{   rA   rz   rO   c                C  s’   d}|dur|}n:|durL| j � | j| j}W d  ƒ n1 sB0    Y  |du r\tdƒ‚|du rt| j||d�}n| j||d� t|| |dd�S )aj  Track progress file reading from a binary file.

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

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

        Raises:
            ValueError: When no total value can be extracted from the arguments or the task.
        Nz?unable to get the total number of bytes, please specify 'total'©r{   F©r–   )rJ  r^  r{   Ú
ValueErrorrh  rU   r“   )rH   rÆ   r{   rA   rz   Útotal_bytesrK   rK   rL   rÈ   Õ  s    *ÿzProgress.wrap_filerª   )r{   rA   rz   rÉ   rÒ   rÊ   )
rÆ   r¥   rÌ   rÍ   rÎ   rÏ   r{   rA   rz   rO   c          
      C  s   d S rW   rK   ©
rH   rÆ   r¥   rÌ   rÍ   rÎ   rÏ   r{   rA   rz   rK   rK   rL   rÑ   ÿ  s    zProgress.openz"Union[Literal['r'], Literal['rt']]r#   c          
      C  s   d S rW   rK   rn  rK   rK   rL   rÑ     s    rÓ   rÔ   zUnion[BinaryIO, TextIO]c                C  sð   d  t|dd�¡}
|
dvr(td|›�ƒ‚|dk}|
dkrR|dkrRt dt¡ d	}n&|
d
v rx|dkrltdƒ‚n|dkrxd	}|du rŠt|ƒj}|du r¢| j|	|d�}n| j	||d� t
j|d|d�}t|| |dd�}|dv rìt
j|||||d�S |S )a#  Track progress while reading from a binary file.

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

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

        Raises:
            ValueError: When an invalid mode is given.
        rè   F)Úreverse)ÚbrÚrtrÓ   zinvalid mode r)   rp  zaline buffering (buffering=1) isn't supported in binary mode, the default buffer size will be usedrª   )rq  rÓ   r   zcan't have unbuffered text I/ONrj  Úrb)rÌ   Trk  )rÓ   rq  )rÍ   rÎ   rÏ   Úline_buffering)rd   Úsortedrl  ÚwarningsÚwarnÚRuntimeWarningr   Úst_sizerh  rU   ÚiorÑ   r“   ÚTextIOWrapper)rH   rÆ   r¥   rÌ   rÍ   rÎ   rÏ   r{   rA   rz   Ú_moders  r”   rÃ   rK   rK   rL   rÑ     s>    !þ

ûr:   )rA   rO   c                 C  sH   | j �. | j| }|jdu r&|  ¡ |_W d  ƒ n1 s:0    Y  dS )zéStart a task.

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

        Args:
            task_id (TaskID): ID of task.
        N)rJ  r^  rD  r   )rH   rA   r•   rK   rK   rL   Ú
start_taskl  s    	

zProgress.start_taskc                 C  sR   | j �8 | j| }|  ¡ }|jdu r*||_||_W d  ƒ n1 sD0    Y  dS )z†Stop a task.

        This will freeze the elapsed time on the task.

        Args:
            task_id (TaskID): ID of task.
        N)rJ  r^  r   rD  rE  )rH   rA   r•   rá   rK   rK   rL   Ú	stop_taskz  s    

zProgress.stop_task)r{   rE   rQ   rz   r>  rP   zOptional[bool]r   )	rA   r{   rE   rQ   rz   r>  rP   r@  rO   c                K  s@  | j �� | j| }	|	j}
|dur:||	jkr:||	_|	 ¡  |durP|	 j|7  _|dur^||	_|durl||	_|durz||	_|	j |¡ |	j|
 }|  	¡ }|| j
 }|	j}|j}|rÈ|d j|k rÈ|ƒ  q®|dkrà| t||ƒ¡ |	jdu�r|	j|	jk�r|	jdu �r|	j|	_W d  ƒ n1 �s$0    Y  |�r<|  ¡  dS )a˜  Update information associated with a task.

        Args:
            task_id (TaskID): Task id (returned by add_task).
            total (float, optional): Updates task.total if not None.
            completed (float, optional): Updates task.completed if not None.
            advance (float, optional): Add a value to task.completed if not None.
            description (str, optional): Change task description if not None.
            visible (bool, optional): Set visible flag if not None.
            refresh (bool): Force a refresh of progress information. Default is False.
            **fields (Any): Additional data fields required for rendering.
        Nr   )rJ  r^  rE   r{   rV  rz   r>  r@  rU   r   rX  rI  Úpopleftrâ   Úappendr:  r  r  rP   )rH   rA   r{   rE   rQ   rz   r>  rP   r@  r•   Úcompleted_startÚupdate_completedrá   Úold_sample_timerI  r~  rK   rK   rL   rU   ‰  sB    



ÿ
þý(zProgress.update)rY   r{   rE   r>  rz   )rA   rY   r{   rE   r>  rz   r@  rO   c          
      K  sš   |   ¡ }| j�p | j| }	|	 ¡  |r*|nd|	_|dur>||	_||	_|durR||	_|r\||	_|durj||	_	d|	_
W d  ƒ n1 s„0    Y  |  ¡  dS )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   rJ  r^  rV  rD  r{   rE   r>  r@  rz   r  rP   )
rH   rA   rY   r{   rE   r>  rz   r@  rá   r•   rK   rK   rL   ÚresetÆ  s     
$zProgress.resetr)   )rA   rQ   rO   c           
      C  sÞ   |   ¡ }| j�¼ | j| }|j}| j|7  _|j| }|| j }|j}|j}	|rh|d j|k rh|	ƒ  qNt|ƒdkr||	ƒ  qh| 	t
||ƒ¡ |jdur¼|j|jkr¼|jdu r¼|j|_|j|_W d  ƒ n1 sÐ0    Y  dS )z«Advance task by a number of steps.

        Args:
            task_id (TaskID): ID of task.
            advance (float): Number of steps to advance. Default is 1.
        r   r  N)r   rJ  r^  rE   rX  rI  r~  râ   rŸ   r  r:  r{   r  r  rò   r   )
rH   rA   rQ   rá   r•   r€  r�  r‚  rI  r~  rK   rK   rL   rQ   í  s,    


ÿ
þýzProgress.advancec                 C  s   | j s| jjr| j ¡  dS )z*Refresh (render) the progress information.N)r…   rS   rT   rP   rZ   rK   rK   rL   rP     s    zProgress.refreshr/   c                 C  s   t |  ¡ Ž }|S )z*Get a renderable for the progress display.)r-   Úget_renderables)rH   rã   rK   rK   rL   r\    s    zProgress.get_renderablezIterable[RenderableType]c                 c  s   |   | j¡}|V  dS )z5Get a number of renderables for the progress display.N)Úmake_tasks_tablerd  )rH   ÚtablerK   rK   rL   r„    s    zProgress.get_renderableszIterable[Task]r7   )rd  rO   c                   sR   dd„ | j D ƒ}tj|d| jdœŽ}|D ]$‰ ˆ jr(|j‡ fdd„| j D ƒŽ  q(|S )z×Get a table to render the Progress display.

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

        Returns:
            Table: A table instance.
        c                 s  s.   | ]&}t |tƒrtd d�n
| ¡  ¡ V  qdS )Tr  N)rö   rt   r6   rÛ   Úcopy)rQ  Z_columnrK   rK   rL   rS  #  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ö   rt   r  )rQ  Úcolumnr  rK   rL   rS  0  s   ýÿ)r’   r7   Zgridr[  r>  Úadd_row)rH   rd  Ztable_columnsr†  rK   r  rL   r…    s    	ú
úÿ
zProgress.make_tasks_tablec                 C  s2   | j � |  ¡ W  d  ƒ S 1 s$0    Y  dS )z+Makes the Progress class itself renderable.N)rJ  r\  rZ   rK   rK   rL   Ú__rich__;  s    zProgress.__rich__rN  )rz   rY   r{   rE   r>  r@  rO   c           	      K  s†   | j �d t| j|||||| j| j d�}|| j| j< |rB|  | j¡ | j}tt| jƒd ƒ| _W d  ƒ n1 sp0    Y  |  ¡  |S )a  Add a new 'task' to the Progress display.

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

        Returns:
            TaskID: An ID you can use when calling `update`.
        )r>  r@  r=  rJ  r)   N)	rJ  r;  r_  r   r^  r|  r:   rv   rP   )	rH   rz   rY   r{   rE   r>  r@  r•   Znew_task_indexrK   rK   rL   rh  @  s$    ø
2zProgress.add_taskc                 C  s2   | j � | j|= W d  ƒ n1 s$0    Y  dS )z]Delete a task if it exists.

        Args:
            task_id (TaskID): A task ID.

        N)rJ  r^  )rH   rA   rK   rK   rL   Úremove_taskk  s    zProgress.remove_task)Nr   Nrl   rr   )N)rª   NNN)rª   NNN)rÓ   rª   NNN)r)   )TrN  r   T)!rg   rh   ri   rj   rG   r!  r]  rÁ   r}   rd  rf  rú   rY   rÄ   r[   rf   r‘   rÈ   ÚtypingÚoverloadrÑ   r|  r}  rU   rƒ  rQ   rP   r\  r„  r…  r‹  rh  rŒ  rK   rK   rK   rL   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)Zline_numbersZfooÚbarZbazÚ1Ú2Ú3z:Text may be printed while the progress bars are rendering.z(In fact, [i]any[/i] renderable will workzSuch as [magenta]tables[/]...zPretty printed structures...ZexamplezPretty printed)Útyperû   z	Syntax...zGive it a try!)Úcycle)Úrecord)r}   r~   z[red]Downloadingr  rj  z[green]Processingz[yellow]Thinkingr"  r�   g333333Ó?g{®Gáz„?éd   )rl   Nr   TNFNrm   rn   ro   rp   rq   rr   FT)rª   NNN)rª   NNN)rÓ   rª   NNN)…Ú
__future__r   ry  r�  ru  Úabcr   r   Úcollectionsr   Z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'   Ztyping_extensionsr(   rè   r*   r+   r}   r,   r-   r.   r/   r  r0   Zjupyterr1   rS   r2   Úprogress_barr3   rõ   r4   r�   r5   r†  r6   r7   rû   r8   r9   rv   r:   r;   r?   r<  r<   r=   r‘   r“   rÂ   rÈ   rŽ  rÑ   rÕ   rç   rì   r‹   r�   r  rŽ   r�   r,  r1  r2  rÇ   r9  r:  r;  r�   rg   ÚrandomÚtimeZpanelr�  Zruler‘  Zsyntaxr’  rŠ  Zprogress_renderablesÚ	itertoolsr™  Zexamplesr]  r@   rh  Ztask1Ztask2Ztask3rú   rU   ÚsleepÚrandintra  rž   rK   rK   rK   rL   Ú<module>   sv  T
*               ð0Ngò,A    úí8    úí8     úí6V*2*H0		1	}    U
ó÷
ÿþýû
