o
�J�h�� � @ s� d dl mZ d dlZd dlZd dlZd dlmZmZ d dlm Z d dl
m Z m Z d dl
mZ d dlmZmZ d dlmZ d d lmZ d d
lmZ d d lmZmZ d d lmZmZm Z d d
l m Z d dlm 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 dl2m3Z3 ddl4m5Z5m6Z6 ddl7m8Z8m9Z9m:Z:m;Z; ddl<m=Z= ddl>m?Z? ddl@mAZA ddlBmCZC ddlDmEZE ddlFmGZG ddlHmIZImJZJ ddlKmLZLmMZM e+deN�ZOe0d �ZPe"g eQf ZRe�0d e-e!�ZSG d d � d e �ZT ! " # $ % & ' ( " !d�d�dCdD�ZUG dEdF� dFee!�ZVG dGdH� dHe#eS e&eS �ZWdId!dd"dd#d$d%d&d'd"dJ� d�dNdO�ZXejY P d�ddId!dd"dd#d$d%d&d'd"dQ� d�d\d]��ZZejY P d�ddId!dd"dd#d$d%d&d'd"dQ� d�d_d]��ZZ ` P d�ddId!dd"dd#d$d%d&d'd"dQ� d�dcd]�ZZG ddde� dee�Z[G dfdg� dge[�Z\G dhdi� die[�Z]G djdk� dke[�Z^G dldm� dme[�Z_G dndo� doe[�Z`G dpdq� dqe^�ZaG drds� dse[�ZbG dtdu� due[�ZcG dvdw� dwe[�ZdG dxdy� dye[�ZeG dzd{� d{e[�ZfG d|d}� d}e[�ZgG d~d� de*�Zhe G d�d�� d���ZiG d�d�� d�e?�Zjekd�k�r�d dllZld dlmZmdd�lnmoZo dd�lpmqZq dd�lrmsZs dd�lHmJZJ esd�d�d!d��ZreJd�d�d��ZHeH�td�d�d�� d�eod��d�eHd�d�d�d��d�ereqd��g Zud d�lvmwZw eweu�Zxe8d!d��Z7eje]� gej�y� �e`� �R e7d"d����QZzezj{d�d�d��Z|ezj{d�d�d��Z}ezj{d�dd��Z~ezj�s�ezj�e|d�d�� ezj�e}d�d�� em��d�� el��d d��dk �r�ez��e�ex�� ezj�r�W d � dS W d � dS 1 �s�w Y dS dS )�� )� annotationsN)�ABC�abstractmethod��deque)� dataclass�field)� timedelta)� RawIOBase�UnsupportedOperation)�ceil)�mmap)� length_hint)�PathLike�stat)�Event�RLock�Thread)�
TracebackType)�
TYPE_CHECKING�Any�BinaryIO�Callable�ContextManager�Deque�Dict�Generic�Iterable�List�Literal�
NamedTuple�NewType�Optional�TextIO�Tuple�Type�TypeVar�Union)�Self� )�filesize� get_console)�Console�Group�
JustifyMethod�RenderableType)� Highlighter)� JupyterMixin)�Live)� ProgressBar)�Spinner)� StyleType)�Column�Table)�Text�TextType�TaskID� ProgressType�_Ic s@ e Zd ZdZd� fdd � Zdd d
�Zddd�Zd dd�Z� ZS ) � _TrackThreadz)A thread to periodically update progress.�progress�
'Progress'�task_id�'TaskID'�
update_period�floatc s2 || _ || _|| _t� | _d| _t� jdd� d S )Nr T)�daemon)r> r@ rB r �done� completed�super�__init__)�selfr> r@ rB �� __class__� �KC:\pinokio\api\whisper-webui.git\app\env\lib\site-packages\rich\progress.pyrH C s z_TrackThread.__init__�return�Nonec C s~ | j }| jj}| j}d}| jj}||�s2| jjjr2| j}||kr)|||| � |}||�s2| jjjs| jj | j | jdd� d S )Nr T)rF �refresh)
r@ r> �advancerB rE �wait�live�
is_startedrF �update)rI r@ rQ rB Zlast_completedrR rF rL rL rM �runL s �z_TrackThread.run�'_TrackThread'c C � | � � | S �N��start�rI rL rL rM � __enter__Z � z_TrackThread.__enter__�exc_type� Optional[Type[BaseException]]�exc_val�Optional[BaseException]�exc_tb�Optional[TracebackType]c C s | j �� | �� d S rY )rE �set�join�rI r_ ra rc rL rL rM �__exit__^ s
z_TrackThread.__exit__)r> r? r@ rA rB rC �rN rO )rN rW �r_ r` ra rb rc rd rN rO ) �__name__�
__module__� __qualname__�__doc__rH rV r] rh �
__classcell__rL rL rJ rM r= @ s
r= �
Working...TF�
�bar.back� bar.complete� bar.finished� bar.pulse皙�����?�sequence�Iterable[ProgressType]� description�str�total�Optional[float]rF �int� auto_refresh�bool�console�Optional[Console]� transient�get_time� Optional[Callable[[], float]]�refresh_per_secondrC �styler5 �complete_style�finished_style� pulse_stylerB �disable�
show_speedrN c c s� � |rt d�gng }|�t| |
| | d�t|d�tdd�f� t||||||p'd|d��}|� |j| ||||
d�E d H W d � d S 1 sGw Y d S )
a� Track progress by iterating over a sequence.
You can also track progress of an iterable, which might require that you additionally specify ``total``.
Args:
sequence (Iterable[ProgressType]): Values you wish to iterate over and track progress.
description (str, optional): Description of task show next to progress bar. Defaults to "Working".
total: (float, optional): Total number of steps. Default is len(sequence).
completed (int, optional): Number of steps completed so far. Defaults to 0.
auto_refresh (bool, optional): Automatic refresh, disable to force a refresh after each iteration. Default is True.
transient: (bool, optional): Clear the progress on exit. Defaults to False.
console (Console, optional): Console to write to. Default creates internal Console instance.
refresh_per_second (float): Number of times per second to refresh the progress information. Defaults to 10.
style (StyleType, optional): Style for the bar background. Defaults to "bar.back".
complete_style (StyleType, optional): Style for the completed bar. Defaults to "bar.complete".
finished_style (StyleType, optional): Style for a finished bar. Defaults to "bar.finished".
pulse_style (StyleType, optional): Style for pulsing bars. Defaults to "bar.pulse".
update_period (float, optional): Minimum time (in seconds) between calls to update(). Defaults to 0.1.
disable (bool, optional): Disable display of progress.
show_speed (bool, optional): Show speed if total isn't known. Defaults to True.
Returns:
Iterable[ProgressType]: An iterable of the values in the sequence.
�([progress.description]{task.description}�r� r� r� r� )r� T)�elapsed_when_finishedrq �r~ r� r� r� r� r� )r{ rF ry rB N)�
TextColumn�extend� BarColumn�TaskProgressColumn�TimeRemainingColumn�Progress�track)rw ry r{ rF r~ r� r� r� r� r� r� r� r� rB r� r� �columnsr> rL rL rM r� h s@ �,���� �
�"�r� c @ s e Zd ZdZ dQdRd
d�ZdSdd�ZdTdd�ZdUdd�ZdVd d �Ze dWd d ��Z
dXd"d#�Z dWd$d%�Z e dYd'd(��Z
e dYd)d*��ZdWd+d,�ZdWd-d.�ZdWd/d0�ZdZd[d3d4�Zd\d7d8�ZdZd[d9d:�ZdZd]d=d>�Zd^d?d@�Zd_d`dDdE�ZdXdFdG�ZdadJdK�ZdbdNdO�ZdPS )c�_Readerz9A reader that tracks progress while it's being read from.T�handler r> r? �taskr: � close_handler rN rO c C s" || _ || _|| _|| _d| _d S �NF)r� r> r� r� �_closed)rI r� r> r� r� rL rL rM rH � s
z_Reader.__init__� '_Reader'c C s | j �� | S rY )r� r] r\ rL rL rM r] � s
z_Reader.__enter__r_ r` ra rb rc rd c C � | � � d S rY )�closerg rL rL rM rh � � z_Reader.__exit__c C s | S rY rL r\ rL rL rM �__iter__� � z_Reader.__iter__�bytesc C s$ t | j�}| jj| jt|�d� |S �N�rQ )�nextr� r> rQ r� �len)rI �linerL rL rM �__next__� s
z_Reader.__next__c C � | j S rY )r� r\ rL rL rM �closed� s z_Reader.closedr} c C �
| j �� S rY )r� �filenor\ rL rL rM r� � �
z_Reader.filenoc C r� rY )r� �isattyr\ rL rL rM r� � r� z_Reader.isattyrz c C � | j jS rY )r� �moder\ rL rL rM r� � � z _Reader.modec C r� rY )r� �namer\ rL rL rM r� � r� z _Reader.namec C r� rY )r� �readabler\ rL rL rM r� � r� z_Reader.readablec C r� rY )r� �seekabler\ rL rL rM r� � r� z_Reader.seekablec C � dS r� rL r\ rL rL rM �writable� r� z_Reader.writable������sizec C �& | j �|�}| jj| jt|�d� |S r� )r� �readr> rQ r� r� )rI r� �blockrL rL rM r� � � z _Reader.read�b�"Union[bytearray, memoryview, mmap]c C s" | j �|�}| jj| j|d� |S r� )r� �readintor> rQ r� )rI r� �nrL rL rM r� � s z_Reader.readintoc C r� r� )r� �readliner> rQ r� r� )rI r� r� rL rL rM r� � r� z_Reader.readline�hint� List[bytes]c C s, | j �|�}| jj| jttt|��d� |S r� )r� � readlinesr> rQ r� �sum�mapr� )rI r� �linesrL rL rM r� s z_Reader.readlinesc C s | j r| j�� d| _d S )NT)r� r� r� r� r\ rL rL rM r� s
z
_Reader.closer �offset�whencec C s$ | j �||�}| jj| j|d� |S )N�rF )r� �seekr> rU r� )rI r� r� �posrL rL rM r� s z _Reader.seekc C r� rY )r� �tellr\ rL rL rM r� r� z _Reader.tell�sr c C � t d��)N�write�r )rI r� rL rL rM r� � z
_Reader.writer� �
Iterable[Any]c C r� )N�
writelinesr� )rI r� rL rL rM r� r� z_Reader.writelinesN)T)
r� r r> r? r� r: r� r rN rO )rN r� rj )rN r )rN r� �rN r )rN r} )rN rz )r� )r� r} rN r� )r� r� )r� r} rN r� ri )r )r� r} r� r} rN r} )r� r rN r} )r� r� rN rO )rk rl rm rn rH r] rh r� r� �propertyr� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� rL rL rL rM r� � s8 �
r� c @ s. e Zd ZdZddd �Zdd
d �Zddd�ZdS )� _ReadContextzEA utility class to handle a context for both a reader and a progress.r> r? �readerr< rN rO c C s || _ || _d S rY )r> r� )rI r> r� rL rL rM rH s
z_ReadContext.__init__c C s | j �� | j�� S rY )r> r[ r� r] r\ rL rL rM r] $ s
z_ReadContext.__enter__r_ r` ra rb rc rd c C s | j �� | j�|||� d S rY )r> �stopr� rh rg rL rL rM rh ( s
z_ReadContext.__exit__N)r> r? r� r< rN rO )rN r< rj )rk rl rm rn rH r] rh rL rL rL rM r� s
r� �
Reading...) ry r~ r� r� r� r� r� r� r� r� r� �filer �ContextManager[BinaryIO]c C sh |rt d�gng }
|
�t|| |
| d�t� t� f� t|
|||||p"d| d��}|j| ||d�}t||�S )a Read bytes from a file while tracking progress.
Args:
file (Union[str, PathLike[str], BinaryIO]): The path to the file to read, or a file-like object in binary mode.
total (int): Total number of bytes to read.
description (str, optional): Description of task show next to progress bar. Defaults to "Reading".
auto_refresh (bool, optional): Automatic refresh, disable to force a refresh after each iteration. Default is True.
transient: (bool, optional): Clear the progress on exit. Defaults to False.
console (Console, optional): Console to write to. Default creates internal Console instance.
refresh_per_second (float): Number of times per second to refresh the progress information. Defaults to 10.
style (StyleType, optional): Style for the bar background. Defaults to "bar.back".
complete_style (StyleType, optional): Style for the completed bar. Defaults to "bar.complete".
finished_style (StyleType, optional): Style for a finished bar. Defaults to "bar.finished".
pulse_style (StyleType, optional): Style for pulsing bars. Defaults to "bar.pulse".
disable (bool, optional): Disable display of progress.
Returns:
ContextManager[BinaryIO]: A context manager yielding a progress reader.
r� r� rq r� )r{ ry )r� r� r� �DownloadColumnr� r� � wrap_filer� )r� r{ ry r~ r� r� r� r� r� r� r� r� r� r� r> r� rL rL rM r� 2 s0 %���� �
r� r� ) r{ ry r~ r� r� r� r� r� r� r� r� r� �"Union[str, 'PathLike[str]', bytes]r� �"Union[Literal['rt'], Literal['r']]� buffering�encoding�
Optional[str]�errors�newline�
Optional[int]�ContextManager[TextIO]c C � d S rY rL �r� r� r� r� r� r� r{ ry r~ r� r� r� r� r� r� r� r� r� rL rL rM �opens � r� �
Literal['rb']c C r� rY rL r� rL rL rM r� � r� �r�1Union[Literal['rb'], Literal['rt'], Literal['r']]�7Union[ContextManager[BinaryIO], ContextManager[TextIO]]c
C sr |rt d�gng }|�t|
|||d�t� t� f� t||| |
| | p"d|d��}|j| |||||||d�}t||�S )a� Read bytes from a file while tracking progress.
Args:
path (Union[str, PathLike[str], BinaryIO]): The path to the file to read, or a file-like object in binary mode.
mode (str): The mode to use to open the file. Only supports "r", "rb" or "rt".
buffering (int): The buffering strategy to use, see :func:`io.open`.
encoding (str, optional): The encoding to use when reading in text mode, see :func:`io.open`.
errors (str, optional): The error handling strategy for decoding errors, see :func:`io.open`.
newline (str, optional): The strategy for handling newlines in text mode, see :func:`io.open`
total: (int, optional): Total number of bytes to read. Must be provided if reading from a file handle. Default for a path is os.stat(file).st_size.
description (str, optional): Description of task show next to progress bar. Defaults to "Reading".
auto_refresh (bool, optional): Automatic refresh, disable to force a refresh after each iteration. Default is True.
transient: (bool, optional): Clear the progress on exit. Defaults to False.
console (Console, optional): Console to write to. Default creates internal Console instance.
refresh_per_second (float): Number of times per second to refresh the progress information. Defaults to 10.
style (StyleType, optional): Style for the bar background. Defaults to "bar.back".
complete_style (StyleType, optional): Style for the completed bar. Defaults to "bar.complete".
finished_style (StyleType, optional): Style for a finished bar. Defaults to "bar.finished".
pulse_style (StyleType, optional): Style for pulsing bars. Defaults to "bar.pulse".
disable (bool, optional): Disable display of progress.
encoding (str, optional): The encoding to use when reading in text mode.
Returns:
ContextManager[BinaryIO]: A context manager yielding a progress reader.
r� r� rq r� )r� r� r� r� r� r{ ry )r� r� r� r� r� r� r� r� )r� r� r� r� r� r� r{ ry r~ r� r� r� r� r� r� r� r� r� r� r> r� rL rL rM r� � sB 1���� �
�
c @ sL e Zd ZU dZdZded< ddd d
�Zdd d
�Zddd�Ze ddd��Z
dS )�ProgressColumnz3Base class for a widget to use in progress display.Nr| � max_refresh� table_column�Optional[Column]rN rO c C s || _ i | _d | _d S rY )�
_table_column�_renderable_cacheZ _update_time)rI r� rL rL rM rH s
zProgressColumn.__init__r6 c C s | j pt� S )z.Get a table column, used to build tasks table.)r� r6 r\ rL rL rM �get_table_column s z ProgressColumn.get_table_columnr� �'Task'r/ c C sp |� � }| jdur)|js)z
| j|j \}}W n ty Y n
w || j |kr)|S | �|�}||f| j|j< |S )a Called by the Progress object to return a renderable for the given task.
Args:
task (Task): An object containing information regarding the task.
Returns:
RenderableType: Anything renderable (including str).
N)r� r� rF r� �id�KeyError�render)rI r� � current_time� timestamp�
renderablerL rL rM �__call__ s �
zProgressColumn.__call__c C r� )z"Should return a renderable object.NrL �rI r� rL rL rM r� s zProgressColumn.renderrY )r� r� rN rO )rN r6 �r� r� rN r/ ) rk rl rm rn r� �__annotations__rH r� r r r� rL rL rL rM r� � s
r� c s6 e Zd ZdZ ddd�d� fd d
�Zddd�Z� ZS )�RenderableColumnz�A column to insert an arbitrary column.
Args:
renderable (RenderableType, optional): Any renderable. Defaults to empty string.
� N�r� r� r/ r� r� c � || _ t� j|d� d S �Nr )r� rG rH )rI r� r� rJ rL rM rH , � zRenderableColumn.__init__r� r� rN c C r� rY )r� r rL rL rM r� 2 s zRenderableColumn.render)r )r� r/ r� r� r �rk rl rm rn rH r� ro rL rL rJ rM r % s ��r c sH e Zd ZdZ d d � fdd�
Z d d dd�Zd!dd �Z� ZS )"�
SpinnerColumna� A column with a 'spinner' animation.
Args:
spinner_name (str, optional): Name of spinner animation. Defaults to "dots".
style (StyleType, optional): Style of spinner. Defaults to "progress.spinner".
speed (float, optional): Speed factor of spinner. Defaults to 1.0.
finished_text (TextType, optional): Text used when task is finished. Defaults to " ".
�dots�progress.spinner� �?� N� spinner_namerz r� �Optional[StyleType]�speedrC �
finished_textr9 r� r� c s< t |||d�| _t|t�rt�|�n|| _t� j|d� d S )N�r� r r ) r4 �spinner�
isinstancerz r8 � from_markupr rG rH )rI r r� r r r� rJ rL rM rH @ s ��zSpinnerColumn.__init__�
spinner_stylerN rO c C s t |||d�| _dS )a- Set a new spinner.
Args:
spinner_name (str): Spinner name, see python -m rich.spinner.
spinner_style (Optional[StyleType], optional): Spinner style. Defaults to "progress.spinner".
speed (float, optional): Speed factor of spinner. Defaults to 1.0.
r N)r4 r )rI r r r rL rL rM � set_spinnerP s
zSpinnerColumn.set_spinnerr� r� r/ c C s$ |j r| j}|S | j�|�� �}|S rY )�finishedr r r� r� )rI r� �textrL rL rM r� _ s ����zSpinnerColumn.render)r r
r r N)
r rz r� r r rC r r9 r� r� )r
r )r rz r r r rC rN rO r )rk rl rm rn rH r r� ro rL rL rJ rM r 6 s � �r c s8 e Zd ZdZ dd � fdd�
Zd dd�Z� ZS ) r� zA column containing text.�none�leftTN� text_formatrz r� r5 �justifyr. �markupr � highlighter�Optional[Highlighter]r� r� rN rO c s: || _ || _|| _|| _|| _t� j|ptdd�d� d S )NT��no_wrapr )r r r� r r! rG rH r6 )rI r r� r r r! r� rJ rL rM rH k s zTextColumn.__init__r� r� r8 c C sR | j j|d�}| jrtj|| j| jd�}n t|| j| jd�}| jr'| j�|� |S �N�r� )r� r ) r �formatr r8 r r� r r! � highlight)rI r� �_textr rL rL rM r� { s zTextColumn.render)r r TNN)r rz r� r5 r r. r r r! r" r� r� rN rO �r� r� rN r8 r
rL rL rJ rM r� h s �r� c s: e Zd ZdZ dd� fdd�
Zd dd�Z� ZS ) r� a Renders a visual progress bar.
Args:
bar_width (Optional[int], optional): Width of bar or None for full width. Defaults to 40.
style (StyleType, optional): Style for the bar background. Defaults to "bar.back".
complete_style (StyleType, optional): Style for the completed bar. Defaults to "bar.complete".
finished_style (StyleType, optional): Style for a finished bar. Defaults to "bar.finished".
pulse_style (StyleType, optional): Style for pulsing bars. Defaults to "bar.pulse".
�( rr rs rt ru N� bar_widthr� r� r5 r� r� r� r� r� rN rO c s0 || _ || _|| _|| _|| _t� j|d� d S r )r, r� r� r� r� rG rH )rI r, r� r� r� r� r� rJ rL rM rH � s zBarColumn.__init__r� r� r3 c C s^ t |jdur td|j�ndtd|j�| jdu rdntd| j�|j |�� | j| j| j | j
d� S )z&Gets a progress bar widget for a task.Nr r) ) r{ rF �widthZpulseZanimation_timer� r� r� r� ) r3 r{ �maxrF r, �startedr� r� r� r� r� r rL rL rM r� � s
�zBarColumn.render)r+ rr rs rt ru N)r, r� r� r5 r� r5 r� r5 r� r5 r� r� rN rO )r� r� rN r3 r
rL rL rJ rM r� � s �r� c @ � e Zd ZdZd dd�ZdS )
�TimeElapsedColumnzRenders time elapsed.r� r� rN r8 c C sJ |j r|jn|j}|du rtddd�S ttdt|��d�}tt|�dd�S )zShow time elapsed.N�-:--:--�progress.elapsed�r� r )�seconds)r �
finished_time�elapsedr8 r r. r} rz )rI r� r7 �deltarL rL rM r� � s
zTimeElapsedColumn.renderNr* �rk rl rm rn r� rL rL rL rM r1 � � r1 c sL e Zd ZdZ d$d%� fdd�
Zed&d d ��Zd'd"d#�Z� ZS )(r� a Show task progress as a percentage.
Args:
text_format (str, optional): Format for percentage display. Defaults to "[progress.percentage]{task.percentage:>3.0f}%".
text_format_no_percentage (str, optional): Format if percentage is unknown. Defaults to "".
style (StyleType, optional): Style of output. Defaults to "none".
justify (JustifyMethod, optional): Text justification. Defaults to "left".
markup (bool, optional): Enable markup. Defaults to True.
highlighter (Optional[Highlighter], optional): Highlighter to apply to output. Defaults to None.
table_column (Optional[Column], optional): Table Column to use. Defaults to None.
show_speed (bool, optional): Show speed if total is unknown. Defaults to False.
�-[progress.percentage]{task.percentage:>3.0f}%r r r TNFr rz �text_format_no_percentager� r5 r r. r r r! r" r� r� r� rN rO c s( || _ || _t� j||||||d� d S )N)r r� r r r! r� )r< r� rG rH ) rI r r< r� r r r! r� r� rJ rL rM rH � s
�zTaskProgressColumn.__init__r r| r8 c C sN |du r
t ddd�S t�t|�g d�d�\}}|| }t |d�|� d�dd�S ) z�Render the speed in iterations per second.
Args:
task (Task): A Task object.
Returns:
Text: Text object containing the task speed.
Nr zprogress.percentager4 )r u ×10³u ×10⁶u ×10⁹u ×10¹²�� z.1fz it/s)r8 r* �pick_unit_and_suffixr} )�clsr �unit�suffix�
data_speedrL rL rM � render_speed� s
�z TaskProgressColumn.render_speedr� r� c C s� |j d u r| jr| �|jp|j�S |j d u r| jn| j}|j|d�}| jr0t j
|| j | j d�}n t || j | j d�}| j
rB| j
�|� |S r% )r{ r� rC �finished_speedr r< r r' r r8 r r� r r! r( )rI r� r r) r rL rL rM r� � s � zTaskProgressColumn.render)r; r r r TNNF)r rz r< rz r� r5 r r. r r r! r" r� r� r� r rN rO )r r| rN r8 r* ) rk rl rm rn rH � classmethodrC r� ro rL rL rJ rM r� � s � r� c s8 e Zd ZdZdZ dd� fd
d �
Zddd�Z� ZS )r� a Renders estimated time remaining.
Args:
compact (bool, optional): Render MM:SS when time remaining is less than an hour. Defaults to False.
elapsed_when_finished (bool, optional): Render time elapsed when the task is finished. Defaults to False.
� �?FN�compactr r� r� r� c s || _ || _t� j|d� d S r )rG r� rG rH )rI rG r� r� rJ rL rM rH s z TimeRemainingColumn.__init__r� r� rN r8 c C s� | j r |jr |j}d}n|j}d}|jdu r td|d�S |du r.t| jr)d|d�S d|d�S tt|�d�\}}t|d�\}}| jrM|sM|d �d
|d ��}n
|d �d
|d �d
|d ��}t||d�S ) zShow time remaining.r3 zprogress.remainingNr r4 z--:--r2 �< Z02d�:�d) r� r r6 �time_remainingr{ r8 rG �divmodr} )rI r� Z task_timer� �minutesr5 �hours� formattedrL rL rM r� s
zTimeRemainingColumn.render)FFN)rG r r� r r� r� r* )rk rl rm rn r� rH r� ro rL rL rJ rM r� s �
r� c @ r0 )
�FileSizeColumnzRenders completed filesize.r� r� rN r8 c C s t �t|j��}t|dd�S )�Show data completed.zprogress.filesizer4 )r* �decimalr} rF r8 �rI r� � data_sizerL rL rM r� 7 s zFileSizeColumn.renderNr* r9 rL rL rL rM rP 4 r: rP c @ r0 )
�TotalFileSizeColumnzRenders total filesize.r� r� rN r8 c C s* |j dur
t�t|j ��nd}t|dd�S )rQ Nr zprogress.filesize.totalr4 )r{ r* rR r} r8 rS rL rL rM r� @ s zTotalFileSizeColumn.renderNr* r9 rL rL rL rM rU = r: rU c s. e Zd ZdZdd� fdd �
Zddd�Z� ZS )�MofNCompleteColumnaH Renders completed count/total, e.g. ' 10/1000'.
Best for bounded tasks with int quantities.
Space pads the completed count so that progress length does not change as task progresses
past powers of 10.
Args:
separator (str, optional): Text to separate completed and total values. Defaults to "/".
�/N� separatorrz r� r� c r r )rX rG rH )rI rX r� rJ rL rM rH R s zMofNCompleteColumn.__init__r� r� rN r8 c C sP t |j�}|jdurt |j�nd}tt|��}t||� d��| j� |� �dd�S )zShow completed/total.N�?rJ �progress.downloadr4 )r} rF r{ r� rz r8 rX )rI r� rF r{ � total_widthrL rL rM r� V s
�zMofNCompleteColumn.render)rW N)rX rz r� r� r* r
rL rL rJ rM rV F s rV c s0 e Zd ZdZ dd� fd
d �
Zddd�Z� ZS )r� z�Renders file size downloaded and total, e.g. '0.5/2.3 GB'.
Args:
binary_units (bool, optional): Use binary units, KiB, MiB etc. Defaults to False.
FN� binary_unitsr r� r� rN rO c r r )r\ rG rH )rI r\ r� rJ rL rM rH h r zDownloadColumn.__init__r� r� r8 c C s� t |j�}|jdurt |j�n|}| jr t�|g d�d�\}}n t�|g d�d�\}}|dkr1dnd}|| }|d|� d ��}|jdurVt |j�} | | }
|
d|� d ��} nd
} |� d | � d |� �} t| d
d�}
|
S )z.Calculate common unit for completed and total.N) r� ZKiBZMiBZGiBZTiBZPiBZEiBZZiBZYiBi ) r� ZkBZMBZGBZTBZPBZEBZZBZYBr= r) r z,.�frY rW r rZ r4 )r} rF r{ r\ r* r> r8 )rI r� rF Z unit_and_suffix_calculation_baser@ rA � precisionZcompleted_ratioZ
completed_strr{ � total_ratioZ total_strZdownload_statusZ
download_textrL rL rM r� n s2
�
��
zDownloadColumn.render)FN)r\ r r� r� rN rO r* r
rL rL rJ rM r� a s
�r� c @ r0 )
�TransferSpeedColumnz&Renders human readable transfer speed.r� r� rN r8 c C s@ |j p|j}|du rtddd�S t�t|��}t|� d�dd�S )zShow data transfer speed.NrY zprogress.data.speedr4 z/s)rD r r8 r* rR r} )rI r� r rB rL rL rM r� � s
zTransferSpeedColumn.renderNr* r9 rL rL rL rM r` � r: r` c @ s$ e Zd ZU dZded< ded< dS )�ProgressSamplez$Sample of progress for a given time.rC r� rF N)rk rl rm rn r rL rL rL rM ra � s
ra c @ sX e Zd ZU dZded< ded< ded< ded < d
ed < d Zded
< dZded< eed�Z ded< ed ddd�Z
ded< ed ddd�Z ded< d Z ded< edd� ddd�Z
d ed < eded �Zd ed < d5d"d#�Zed6d$d%��Zed7d&d'��Zed7d(d)��Zed6d*d+��Zed5d,d-��Zed7d.d/��Zed7d0d1��Zd8d3d4�Zd S )9�Taskz�Information regarding a progress task.
This object should be considered read-only outside of the :class:`~Progress` class.
r: r� rz ry r| r{ rC rF �GetTimeCallable� _get_timeNr6 Tr �visible)�default_factoryzDict[str, Any]�fieldsF)�default�init�repr�
start_time� stop_timerD c C s
t dd�S )Nr= )�maxlenr rL rL rL rM �<lambda>� s
z
Task.<lambda>)rf ri rj zDeque[ProgressSample]� _progress)rj rf r �_lockrN c C s | � � S )z(float: Get the current time, in seconds.)rd r\ rL rL rM r� � r� z
Task.get_timec C �
| j duS )z#bool: Check if the task as started.N)rk r\ rL rL rM r/ � �
z Task.startedc C s | j du rdS | j | j S )zPOptional[float]: Get the number of steps remaining, if a non-None total was set.N�r{ rF r\ rL rL rM � remaining� s
zTask.remainingc C s2 | j du rdS | jdur| j| j S | �� | j S )z]Optional[float]: Time elapsed since task was started, or ``None`` if the task hasn't started.N)rk rl r� r\ rL rL rM r7 � s
z Task.elapsedc C rq )z Check if the task has finished.N)r6 r\ rL rL rM r � rr z
Task.finishedc C s. | j sdS | j| j d }tdtd|��}|S )zOfloat: Get progress of task as a percentage. If a None total was set, returns 0� � Y@)r{ rF �minr. )rI rF rL rL rM �
percentage� s
zTask.percentagec C s� | j du rdS | j�D | j}|s W d � dS |d j|d j }|dkr0 W d � dS t|�}t|� tdd� |D ��}|| }|W d � S 1 sQw Y dS )z=Optional[float]: Get the estimated speed in steps per second.Nr� r c s � � | ]}|j V qd S rY r� )�.0�samplerL rL rM � <genexpr> � � z Task.speed.<locals>.<genexpr>)rk rp ro r� �iterr� r� )rI r> Z
total_timeZ
iter_progressZtotal_completedr rL rL rM r � s"
��$�z
Task.speedc C s: | j rdS | j}|s dS | j}|du rdS t|| �}|S )zJOptional[float]: Get estimated time to completion, or ``None`` if no data.ru N)r r rt r )rI r rt ZestimaterL rL rM rK s zTask.time_remainingrO c C s | j �� d| _d| _dS )zReset progress.N)ro �clearr6 rD r\ rL rL rM �_reset s
z Task._reset)rN rC r� )rN r| ri )rk rl rm rn r r6 re r �dictrg rk rl rD ro r rp r� r� r/ rt r7 r rx r rK r� rL rL rL rM rb � sZ
�
rb c @ s� e Zd ZdZddddddddddd�
d�dd�Zed�d d ��Zed�d d!��Zed�d#d$��Z ed�d&d'��Z
ed�d(d)��Z d�d*d+�Z d�d,d-�Z
d�d/d0�Zd�d7d8�Z 9 : ;d�d�dGdH�Z d�ddIdJ�d�dNdO�Zej P d�dddIdQ�d�dZd[��Zej P d�dddIdQ�d�d^d[��Z _ P d�dddIdQ�d�dbd[�Zd�ddde�Zd�dfdg�Zdddddddh�d�dodp�Zddd9dddq�d�dsdt�Zd�d�dvdw�Zd�dxdy�Zd�d{d|�Zd�d~d�Z d�d�d��Z d�d�d��Z � 9 d�d�d�d��Z d�d�d��Z dS )�r� a� 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 (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.
NTrq g >@F)
r� r~ r� �speed_estimate_periodr� �redirect_stdout�redirect_stderrr� r� �expandr� �Union[str, ProgressColumn]r� r� r~ r r� rC r� r� r� r� r� �Optional[GetTimeCallable]r� r� rN rO c
G s� |dksJ d��t � | _| p| �� | _|| _| | _|
| _i | _td�| _ t
|p)t � |||||| j d�| _
|p9| jj| _| jj| _| jj| _d S )Nr z refresh_per_second must be > 0)r� r~ r� r� r� r� �get_renderable)r rp �get_default_columnsr� r� r� r� �_tasksr: � _task_indexr2 r+ r� rS r� r� �print�log) rI r� r~ r� r� r� r� r� r� r� r� r� rL rL rM rH 5 s(
�
zProgress.__init__�Tuple[ProgressColumn, ...]c C s t d�t� t� t� fS )a� Get the default columns used for a new Progress instance:
- a text column for the description (TextColumn)
- the bar itself (BarColumn)
- a text column showing completion percentage (TextColumn)
- an estimated-time-remaining column (TimeRemainingColumn)
If the Progress instance is created without passing a columns argument,
the default columns defined here will be used.
You can also create a Progress instance using custom columns before
and/or after the defaults, as in this example:
progress = Progress(
SpinnerColumn(),
*Progress.get_default_columns(),
"Elapsed:",
TimeElapsedColumn(),
)
This code shows the creation of a Progress display, containing
a spinner to the left, the default columns, and a labeled elapsed
time column.
r� )r� r� r� r� )r? rL rL rM r� Y s
�z Progress.get_default_columnsr, c C r� rY )rS r� r\ rL rL rM r� x r� zProgress.console�
List[Task]c C �8 | j � t| j�� �W d � S 1 sw Y dS )z Get a list of Task instances.N)rp �listr� �valuesr\ rL rL rM �tasks| � $�zProgress.tasks� List[TaskID]c C r� )zA list of task IDs.N)rp r� r� �keysr\ rL rL rM �task_ids� r� zProgress.task_idsc C sZ | j � | js W d � dS tdd� | j�� D ��W d � S 1 s&w Y dS )z'Check if all tasks have been completed.NTc s ry rY )r )rz r� rL rL rM r| � r} z$Progress.finished.<locals>.<genexpr>)rp r� �allr� r\ rL rL rM r � s �$�zProgress.finishedc C s | j s | jjdd� dS dS )zStart the progress display.T)rP N)r� rS r[ r\ rL rL rM r[ � s �zProgress.startc C s0 | j �� | jjs| jjs| j�� dS dS dS )zStop the progress display.N)rS r� r� �is_interactive�
is_jupyterr� r\ rL rL rM r� � s
�z
Progress.stopr( c C rX rY rZ r\ rL rL rM r] � r^ zProgress.__enter__r_ r` ra rb rc rd c C r� rY )r� rg rL rL rM rh � r� zProgress.__exit__r rp rv rw rx r{ r| rF r} r@ �Optional[TaskID]ry rz rB c c s� � |du r
t t|��p d}|du r| j|||d�}n| j|||d� | jjrNt| ||��}|D ] }|V | jd7 _q/W d � dS 1 sGw Y dS | j} | j }
|D ]
}|V | |d� |
� qVdS )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.
Nrs r) )
rC r �add_taskrU rS r~ r= rF rQ rP ) rI rw r{ rF r@ ry rB Z track_thread�valuerQ rP rL rL rM r� � s( ��"�
�zProgress.trackr� )r@ ry r� r r� c C s� d}|dur |}n |dur&| j � | j| j}W d � n1 s!w Y |du r.td��|du r:| j||d�}n| j||d� t|| |dd�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� )rp r� r{ �
ValueErrorr� rU r� )rI r� r{ r@ ry � total_bytesrL rL rM r� � s ��zProgress.wrap_filer� )r{ r@ ry r� r� r� r� r� r� r� r� c
C r� rY rL �
rI r� r� r� r� r� r� r{ r@ ry rL rL rM r� � � z
Progress.open�"Union[Literal['r'], Literal['rt']]r# c
C r� rY rL r� rL rL rM r� r� r� r� �Union[BinaryIO, TextIO]c C s� d� t|dd��}
|
dvrtd|����|dk} |
dkr)|dkr)t�dt� d }n|
d
v r;|d kr5td ��|dkr;d }|d
u rDt|�j}|d
u rP| j| |d�}n| j ||d� t
j |d|d�} t | | |dd�}
|dv rut
j
|
|||| d�S |
S )a# Track progress while reading from a binary file.
Args:
path (Union[str, PathLike[str]]): The path to the file to read.
mode (str): The mode to use to open the file. Only supports "r", "rb" or "rt".
buffering (int): The buffering strategy to use, see :func:`io.open`.
encoding (str, optional): The encoding to use when reading in text mode, see :func:`io.open`.
errors (str, optional): The error handling strategy for decoding errors, see :func:`io.open`.
newline (str, optional): The strategy for handling newlines in text mode, see :func:`io.open`.
total (int, optional): Total number of bytes to read. If none given, os.stat(path).st_size is used.
task_id (TaskID): Task to track. Default is new task.
description (str, optional): Description of task, if new task is created.
Returns:
BinaryIO: A readable file-like object in binary mode.
Raises:
ValueError: When an invalid mode is given.
r F)�reverse)�br�rtr� z
invalid mode r) r� zaline buffering (buffering=1) isn't supported in binary mode, the default buffer size will be usedr� )r� r� r z can't have unbuffered text I/ONr� �rb)r� Tr� )r� r� )r� r� r� �line_buffering)rf �sortedr� �warnings�warn�RuntimeWarningr �st_sizer� rU �ior� r� �
TextIOWrapper)rI r� r� r� r� r� r� r{ r@ ry �_moder� r� r� rL rL rM r� s> !�
�r: c C sZ | j � | j| }|jdu r| �� |_W d � dS W d � dS 1 s&w Y dS )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)rp r� rk r� )rI r@ r� rL rL rM �
start_taskk s
�"�zProgress.start_taskc C sT | j � | j| }| �� }|jdu r||_||_W d � dS 1 s#w Y dS )z�Stop a task.
This will freeze the elapsed time on the task.
Args:
task_id (TaskID): ID of task.
N)rp r� r� rk rl )rI r@ r� r� rL rL rM � stop_tasky s
"�zProgress.stop_task)r{ rF rQ ry re rP rQ re �Optional[bool]rP rg r c K sH | j �� | j| } | j}
|dur || jkr || _| �� |dur'| j|7 _|dur.|| _|dur5|| _|dur<|| _| j�|� | j|
} | � � } | | j
}
| j }|j }|rk|d j
|
k rk|� |rk|d j
|
k s_| dkrw|�t| | �� | jdur�| j| jkr�| jdu r�| j| _W d � n1 s�w Y |r�| �� dS dS )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 )rp r� rF r{ r� ry re rg rU r� r� ro �popleftr� �appendra r6 r7 rP )rI r@ r{ rF rQ ry re rP rg r� �completed_start�update_completedr� �old_sample_timero r� rL rL rM rU � sD
�
� �" �zProgress.update)r[ r{ rF re ry r[ c
K s� | � � }| j�8 | j| } | �� |r|nd| _|dur || _|| _|dur)|| _|r.|| _|dur5|| _ d| _
W d � n1 sBw Y | � � dS )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) r� rp r� r� rk r{ rF re rg ry r6 rP )
rI r@ r[ r{ rF re ry rg r� r� rL rL rM �reset� s"
� zProgress.resetr) c
C s* | � � }| j�� | j| }|j}| j|7 _|j| }|| j }|j}|j} |r<|d j|k r<| � |r<|d j|k s0t|�dkrK| � t|�dksB|� t
||�� |j durs|j|j kr{|j du r�|j
|_ |j|_W d � dS W d � dS W d � dS W d � dS 1 s�w Y dS )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� rp r� rF r� ro r� r� r� r� ra r{ r6 r7 r rD )
rI r@ rQ r� r� r� r� r� ro r� rL rL rM rQ � s8
� �
���"�zProgress.advancec C s$ | j s| jjr| j�� dS dS dS )z*Refresh (render) the progress information.N)r� rS rT rP r\ rL rL rM rP
s �zProgress.refreshr/ c C s t | �� � }|S )z*Get a renderable for the progress display.)r- �get_renderables)rI r� rL rL rM r� s zProgress.get_renderable�Iterable[RenderableType]c c s � | � | j�}|V dS )z5Get a number of renderables for the progress display.N)�make_tasks_tabler� )rI �tablerL rL rM r� s �
zProgress.get_renderablesr� �Iterable[Task]r7 c sR dd� | j D �}tj|d| jd��}|D ]� � jr&|j� fdd�| 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�rtd d�n|�� �� V qdS )Tr# N)r rz r6 r� �copy)rz Z_columnrL rL rM r| " s � � �
�z,Progress.make_tasks_table.<locals>.<genexpr>)r r) )�paddingr� c 3 s. � | ]}t |t�r|j� d �n|� �V qdS )r& N)r rz r' )rz �columnr& rL rM r| / s � ��
�)r� r7 �gridr� re �add_row)rI r� Z
table_columnsr� rL r& rM r� s �
���
zProgress.make_tasks_tablec C s2 | j � | �� W d � S 1 sw Y dS )z+Makes the Progress class itself renderable.N)rp r� r\ rL rL rM �__rich__: s $�zProgress.__rich__rv c K s� | j �2 t| j|||||| j| j d�}|| j| j< |r!| �| j� | j}tt| j�d �| _W d � n1 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`.
)re rg rd rp r) N) rp rb r� r� r� r� r: r} rP ) rI ry r[ r{ rF re rg r� Znew_task_indexrL rL rM r� ? s& �
�zProgress.add_taskc C s4 | j �
| j|= W d � dS 1 sw Y dS )z]Delete a task if it exists.
Args:
task_id (TaskID): A task ID.
N)rp r� )rI r@ rL rL rM � remove_taskj s
"�zProgress.remove_task)r� r� r� r� r~ r r� rC r� rC r� r r� r r� r r� r� r� r r� r rN rO )rN r� )rN r, )rN r� )rN r� r� ri )rN r( rj )Nr Nrp rv )rw rx r{ r| rF r} r@ r� ry rz rB rC rN rx rY )
r� r r{ r� r@ r� ry rz rN r �r� NNN)r� r� r� r� r� r} r� r� r� r� r� r� r{ r� r@ r� ry rz rN r )r� r� r� r� r� r} r� r� r� r� r� r� r{ r� r@ r� ry rz rN r# �r� r� NNN)r� r� r� r� r� r} r� r� r� r� r� r� r{ r� r@ r� ry rz rN r� )r@ r: rN rO )r@ r: r{ r| rF r| rQ r| ry r� re r� rP r rg r rN rO )r@ r: r[ r r{ r| rF r} re r� ry r� rg r rN rO )r) )r@ r: rQ rC rN rO )rN r/ )rN r� )r� r� rN r7 )Trv r T)ry rz r[ r r{ r| rF r} re r rg r rN r: )!rk rl rm rn rH rE r� r� r� r� r� r r[ r� r] rh r� r� �typing�overloadr� r� r� rU r� rQ rP r� r� r� r� r� r� rL rL rL rM r� % s� �$
�0��*� �� �� �
M
�A� '
! �+r� �__main__)�Panel)�Rule)�Syntax)r7 a~ def loop_last(values: Iterable[T]) -> Iterable[Tuple[bool, T]]:
"""Iterate and generate a tuple with a flag for last value."""
iter_values = iter(values)
try:
previous_value = next(iter_values)
except StopIteration:
return
for value in iter_values:
yield False, previous_value
previous_value = value
yield True, previous_value�python)Z line_numbersZfooZbarZbaz�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...ZexamplezPretty printed)�typer z Syntax...zGive it a try!)�cycle)�record)r� r� z[red]Downloadingr= r� z[green]Processingz[yellow]ThinkingrF r� g333333�?g{�G�z�?�d )rp Nr TNFNrq rr rs rt ru rv FT)"rw rx ry rz r{ r| rF r} r~ r r� r� r� r r� r� r� rC r� r5 r� r5 r� r5 r� r5 rB rC r� r r� r rN rx ) r� r r{ r} ry rz r~ r r� r� r� r r� r� r� rC r� r5 r� r5 r� r5 r� r5 r� r rN r� r� )&r� r� r� r� r� r} r� r� r� r� r� r� r{ r� ry rz r~ r r� r� r� r r� r� r� rC r� r5 r� r5 r� r5 r� r5 r� r rN r� )&r� r� r� r� r� r} r� r� r� r� r� r� r{ r� ry rz r~ r r� r� r� r r� r� r� rC r� r5 r� r5 r� r5 r� r5 r� r rN r� r� )&r� r� r� r� r� r} r� r� r� r� r� r� r{ r� ry rz r~ r r� r� r� r r� r� r� rC r� r5 r� r5 r� r5 r� r5 r� r rN r� )��
__future__r r� r� r� �abcr r � collectionsr � dataclassesr r �datetimer r
r �mathr r
�operatorr �osr r � threadingr r r �typesr r r r r r r r r r r r r r! r" r# r$ r% r& r' Ztyping_extensionsr( r r* r+ r� r, r- r. r/ r! r0 �jupyterr1 rS r2 Z progress_barr3 r r4 r� r5 r� r6 r7 r r8 r9 r} r: r; rC rc r< r= r� r� r� r� r� r� r� r r r� r� r1 r� r� rP rU rV r� r` ra rb r� rk �random�time�panelr� �ruler� �syntaxr� r� Zprogress_renderables� itertoolsr� Zexamplesr� r> r� Ztask1Ztask2Ztask3r rU �sleep�randintr� r� rL rL rL rM �<module> s� T
* �Ng�A������V*2 * H0 1 }
T � �
����
�� $��