| Server IP : 127.0.0.1 / Your IP : 216.73.216.109 Web Server : Apache/2.4.54 (Win64) OpenSSL/1.1.1q PHP/8.1.10 System : Windows NT DESKTOP-E5T4RUN 10.0 build 19045 (Windows 10) AMD64 User : SERVERWEB ( 0) PHP Version : 8.1.10 Disable Function : NONE MySQL : OFF | cURL : ON | WGET : OFF | Perl : OFF | Python : OFF | Sudo : OFF | Pkexec : OFF Directory : C:/cygwin64/lib/python3.9/site-packages/pip/_vendor/rich/__pycache__/ |
Upload File : |
a
X��e:� � @ s d dl Z d dlZd dlZd dlZd dlmZmZ d dlmZ d dl m
Z
m Z d dl m
Z
d dl mZmZ d dlmZ d dlmZ d d lmZ d d
lmZmZ d d lmZmZmZ d d l m Z d d
lm Z m Z m Z m!Z!m"Z"m#Z#m$Z$m%Z%m&Z&m'Z'm(Z(m)Z)m*Z*m+Z+m,Z,m-Z-m.Z.m/Z/ ej0dk�r&d dlm1Z1 n d dl2m1Z1 ddl3m4Z4m5Z5 ddl6m7Z7m8Z8m9Z9m:Z: ddl;m<Z< ddl=m>Z> ddl?m@Z@ ddlAmBZB ddlCmDZD ddlEmFZF ddlGmHZHmIZI ddlJmKZKmLZL e(deM�ZNe.d �ZOe g ePf ZQe�.d e+e �ZRG d d � d e�ZSd�e/e*eO e%eO f eTe)eP eUe)e7 eUe)e g ePf ePeFeFeFeFePeUeUe%eO d)�d*d+�ZVG d,d-� d-ee �ZWG d.d/� d/e!eR e$eR �ZXd0d!dd"dd#d$d%d&d'd"d1� e eMeTeUe)e7 eUe)e g ePf ePeFeFeFeFeUe!e d2�d3d4�ZYejZd�dd0d!dd"dd#d$d%d&d'd"d6� e/eTd7e[f e/e1d8 e1d9 f eMe)eT e)eT e)eT e)eM eTeUe)e7 eUe)e g ePf ePeFeFeFeFeUe!e+ d:�d;d<��Z\ejZd�dd0d!dd"dd#d$d%d&d'd"d6� e/eTd7e[f e1d= eMe)eT e)eT e)eT e)eM eTeUe)e7 eUe)e g ePf ePeFeFeFeFeUe!e d:�d>d<��Z\d�dd0d!dd"dd#d$d%d&d'd"d6� e/eTd7e[f e/e1d= e1d8 e1d9 f eMe)eT e)eT e)eT e)eM eTeUe)e7 eUe)e g ePf ePeFeFeFeFeUe/e!e e!e+ f d:�d?d<�Z\G d@dA� dAe�Z]G dBdC� dCe]�Z^G dDdE� dEe]�Z_G dFdG� dGe]�Z`G dHdI� dIe]�ZaG dJdK� dKe]�ZbG dLdM� dMe`�ZcG dNdO� dOe]�ZdG dPdQ� dQe]�ZeG dRdS� dSe]�ZfG dTdU� dUe]�ZgG dVdW� dWe]�ZhG dXdY� dYe]�ZiG dZd[� d[e'�Zje
G d\d]� d]��ZkG d^d_� d_e>�Zlemd`k�r
d dlnZnd dloZoddalpmqZq ddblrmsZs ddcltmuZu dddlGmIZI eudedfd!dg�ZteIdhdidj�ZGeG�vdkdldm� dneqdo�dpeGdqdrdsdt�duetesdv�g Zwd dwlxmyZy eyew�Zze7d!dx�Z6ele_� gel�{� �eb� �R e6d"dy����Z|e|j}dzd{d|�Z~e|j}d}d{d|�Ze|j}d~dd|�Z�e|j��s�e|j�e~dd�� e|j�ed�d�� eo��d�� en��d d��dk �r�e|��e�ez�� �q�W d � n1 �s 0 Y dS )�� N)�ABC�abstractmethod��deque)� dataclass�field)� timedelta)� RawIOBase�UnsupportedOperation)�ceil)�mmap)� length_hint)�PathLike�stat)�Event�RLock�Thread)�
TracebackType)�Any�BinaryIO�Callable�ContextManager�Deque�Dict�Generic�Iterable�List�
NamedTuple�NewType�Optional�Sequence�TextIO�Tuple�Type�TypeVar�Union)� � )�Literal� )�filesize� get_console)�Console�Group�
JustifyMethod�RenderableType)� Highlighter)� JupyterMixin)�Live)� ProgressBar)�Spinner)� StyleType)�Column�Table)�Text�TextType�TaskID� ProgressType�_Ic sj e Zd ZdZdded�� fdd� Zdd�d d
�Zd d�d d �Zee e
ee
ee dd
�dd�Z � Z
S )� _TrackThreadz)A thread to periodically update progress.�Progressr: )�progress�task_id�
update_periodc s. || _ || _|| _t� | _d| _t� �� d S )Nr )r? r@ rA r �done� completed�super�__init__)�selfr? r@ rA �� __class__� �=/usr/lib/python3.9/site-packages/pip/_vendor/rich/progress.pyrE B s z_TrackThread.__init__N��returnc C sd | j }| jj}| j}d}| jj}||�sJ| j}||kr |||| � |}q | jj| j | jdd� d S )Nr T)rC �refresh)r@ r? �advancerA rB �waitrC �update)rF r@ rN rA Zlast_completedrO rC rI rI rJ �runK s z_TrackThread.runc C s | � � | S �N��start�rF rI rI rJ � __enter__Y s z_TrackThread.__enter__��exc_type�exc_val�exc_tbrL c C s | j �� | �� d S rR )rB �set�join�rF rX rY rZ rI rI rJ �__exit__] s
z_TrackThread.__exit__)�__name__�
__module__� __qualname__�__doc__�floatrE rQ rV r r# �
BaseExceptionr r^ �
__classcell__rI rI rG rJ r= ? s
�r= �
Working...TF�
�bar.back� bar.complete� bar.finished� bar.pulse皙�����?)�sequence� description�total� auto_refresh�console� transient�get_time�refresh_per_second�style�complete_style�finished_style� pulse_stylerA �disable�
show_speedrL c c s� |rt d�gng }|�t|| |
| d�t|d�tdd�f� t||||||pLd|
d��}|�( |j| ||| d�E d H W d � n1 s�0 Y d S )
a� Track progress by iterating over a sequence.
Args:
sequence (Iterable[ProgressType]): A sequence (must support "len") you wish to iterate over.
description (str, optional): Description of task show next to progress bar. Defaults to "Working".
total: (float, optional): Total number of steps. Default is len(sequence).
auto_refresh (bool, optional): Automatic refresh, disable to force a refresh after each iteration. Default is True.
transient: (bool, optional): Clear the progress on exit. Defaults to False.
console (Console, optional): Console to write to. Default creates internal Console instance.
refresh_per_second (float): Number of times per second to refresh the progress information. Defaults to 10.
style (StyleType, optional): Style for the bar background. Defaults to "bar.back".
complete_style (StyleType, optional): Style for the completed bar. Defaults to "bar.complete".
finished_style (StyleType, optional): Style for a finished bar. Defaults to "bar.finished".
pulse_style (StyleType, optional): Style for pulsing bars. Defaults to "bar.pulse".
update_period (float, optional): Minimum time (in seconds) between calls to update(). Defaults to 0.1.
disable (bool, optional): Disable display of progress.
show_speed (bool, optional): Show speed if total isn't known. Defaults to True.
Returns:
Iterable[ProgressType]: An iterable of the values in the sequence.
�([progress.description]{task.description}�ru rv rw rx )rz T)�elapsed_when_finishedrg �rp rq rr rs rt ry )ro rn rA N)�
TextColumn�extend� BarColumn�TaskProgressColumn�TimeRemainingColumnr> �track)rm rn ro rp rq rr rs rt ru rv rw rx rA ry rz �columnsr? rI rI rJ r� g s4 (���� �
�r� c @ s� e Zd ZdZd9edeedd�dd�Zd d�d d
�Ze e
e e e e e dd �d d
�Z
ed�dd�Zed�dd�Zeed�dd��Zed�dd�Zed�dd�Zeed�dd��Zeed�dd��Zed�d d �Zed�d d �Zed�d d!�Zd:eed#�d$d%�Z e e e e f d&�d'd(�Z!d;eed#�d)d*�Z"d<ee#e d+�d,d-�Z$dd�d.d/�Z%d=eeed1�d2d3�Z&ed�d4d5�Z'e(ed6�d7d8�Z)dS )>�_Readerz9A reader that tracks progress while it's being read from.Tr> N)�handler? �task� close_handlerL c C s" || _ || _|| _|| _d| _d S �NF)r� r? r� r� �_closed)rF r� r? r� r� rI rI rJ rE � s
z_Reader.__init__rK c C s | j �� | S rR )r� rV rU rI rI rJ rV � s
z_Reader.__enter__rW c C s | � � d S rR )�closer] rI rI rJ r^ � s z_Reader.__exit__c C s | S rR rI rU rI rI rJ �__iter__� s z_Reader.__iter__c C s$ t | j�}| jj| jt|�d� |S �N�rN )�nextr� r? rN r� �len)rF �linerI rI rJ �__next__� s
z_Reader.__next__c C s | j S rR )r� rU rI rI rJ �closed� s z_Reader.closedc C s
| j �� S rR )r� �filenorU rI rI rJ r� � s z_Reader.filenoc C s
| j �� S rR )r� �isattyrU rI rI rJ r� � s z_Reader.isattyc C s | j jS rR )r� �moderU rI rI rJ r� � s z _Reader.modec C s | j jS rR )r� �namerU rI rI rJ r� � s z _Reader.namec C s
| j �� S rR )r� �readablerU rI rI rJ r� � s z_Reader.readablec C s
| j �� S rR )r� �seekablerU rI rI rJ r� � s z_Reader.seekablec C s dS r� rI rU rI rI rJ �writable� s z_Reader.writable���)�sizerL c C s& | j �|�}| jj| jt|�d� |S r� )r� �readr? rN r� r� )rF r� �blockrI rI rJ r� � s z _Reader.read)�bc C s" | j �|�}| jj| j|d� |S r� )r� �readintor? rN r� )rF r� �nrI rI rJ r� � s z_Reader.readintoc C s& | j �|�}| jj| jt|�d� |S r� )r� �readliner? rN r� r� )rF r� r� rI rI rJ r� � s z_Reader.readline)�hintrL c C s, | j �|�}| jj| jttt|��d� |S r� )r� � readlinesr? rN r� �sum�mapr� )rF r� �linesrI rI rJ r� � s z_Reader.readlinesc C s | j r| j�� d| _d S )NT)r� r� r� r� rU rI rI rJ r� s
z
_Reader.closer )�offset�whencerL c C s$ | j �||�}| jj| j|d� |S )N�rC )r� �seekr? rP r� )rF r� r� �posrI rI rJ r� s z _Reader.seekc C s
| j �� S rR )r� �tellrU rI rI rJ r�
s z _Reader.tell)�srL c C s t d��d S )N�write)r
)rF r� rI rI rJ r�
s z
_Reader.write)T)r� )r� )r� )r )*r_ r` ra rb r r: �boolrE rV r r# rd r r^ r� �bytesr� �propertyr� �intr� r� �strr� r� r� r� r� r� r% � bytearray�
memoryviewr r� r� r r� r� r� r� r r� rI rI rI rJ r� � sH ��
� r� c @ sT e Zd ZdZdedd�dd�Zed�dd �Zeee ee ee
dd
�d d �Z dS )
� _ReadContextzEA utility class to handle a context for both a reader and a progress.r> N)r? �readerrL c C s || _ || _d S rR )r? r� )rF r? r� rI rI rJ rE s z_ReadContext.__init__rK c C s | j �� | j�� S rR )r? rT r� rV rU rI rI rJ rV s
z_ReadContext.__enter__rW c C s | j �� | j�|||� d S rR )r? �stopr� r^ r] rI rI rJ r^ s
z_ReadContext.__exit__) r_ r` ra rb r< rE rV r r# rd r r^ rI rI rI rJ r� s
�r� �
Reading...) rn rp rq rr rs rt ru rv rw rx ry )�filero rn rp rq rr rs rt ru rv rw rx ry rL c C sh |rt d�gng }
|
�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| rg r~ )ro rn )r r� r� �DownloadColumnr� r> � wrap_filer� )r� ro rn rp rq rr rs rt ru rv rw rx ry r� r? r� rI rI rJ r� & s0 %���� �
r� r� ) ro rn rp rq rr rs rt ru rv rw rx ry �
PathLike[str]�rt�r)r� r� � buffering�encoding�errors�newlinero rn rp rq rr rs rt ru rv rw rx ry rL c C s d S rR rI �r� r� r� r� r� r� ro rn rp rq rr rs rt ru rv rw rx ry rI rI rJ �openg s r� �rbc C s d S rR rI r� rI rI rJ r� � s c
C sr |rt d�gng }|�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| rg r~ )r� r� r� r� r� ro rn )r r� r� r� r� r> r� r� )r� r� r� r� r� r� ro rn rp rq rr rs rt ru rv rw rx ry r� r? r� rI rI rJ r� � sB 1���� �
�
c @ sj e Zd ZU dZdZee ed< dee dd�dd�Z ed�dd �Z
d
e d �d d
�Z e
d
e d �dd��ZdS )�ProgressColumnz3Base class for a widget to use in progress display.N� max_refresh)� table_columnrL c C s || _ i | _d | _d S rR )�
_table_column�_renderable_cacheZ _update_time)rF r� rI rI rJ rE � s zProgressColumn.__init__rK c C s | j p
t� S )z.Get a table column, used to build tasks table.)r� r6 rU rI rI rJ �get_table_column� s z ProgressColumn.get_table_column�Task�r� rL c C sp |� � }| jdurR|jsRz| j|j \}}W n ty> Y n0 || j |krR|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)rs r� rC r� �id�KeyError�render)rF r� � current_time� timestamp�
renderablerI rI rJ �__call__� s
zProgressColumn.__call__c C s dS )z"Should return a renderable object.NrI �rF r� rI rI rJ r� s zProgressColumn.render)N)r_ r` ra rb r� r rc �__annotations__r6 rE r� r/ r� r r� rI rI rI rJ r� � s
r� c sD e Zd ZdZd dd�eee d�� fdd�Zded �d
d �Z� Z S )
�RenderableColumnz�A column to insert an arbitrary column.
Args:
renderable (RenderableType, optional): Any renderable. Defaults to empty string.
� N�r� )r� r� c s || _ t� j|d� d S �Nr� )r� rD rE )rF r� r� rG rI rJ rE s zRenderableColumn.__init__r� r� c C s | j S rR )r� r� rI rI rJ r� & s zRenderableColumn.render)r� )
r_ r` ra rb r/ r r6 rE r� re rI rI rG rJ r� s ���r� c sb e Zd ZdZdeee eeee d�� fdd �
Z
deee edd
�d d �Z d
e d�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_nameru �speed�
finished_textr� c s< t |||d�| _t|t�r$t�|�n|| _t� j|d� d S )N�ru r� r� ) r4 �spinner�
isinstancer� r8 � from_markupr� rD rE )rF r� ru r� r� r� rG rI rJ rE 4 s � �zSpinnerColumn.__init__)r� �
spinner_styler� rL 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� )rF r� r� r� rI rI rJ � set_spinnerD s
zSpinnerColumn.set_spinnerr� r� c C s |j r | jn| j�|�� �}|S rR )�finishedr� r� r� rs )rF r� �textrI rI rJ r� S s
��zSpinnerColumn.render)r� r� r� r� N)r� r� )r_ r` ra rb r� r r5 rc r9 r6 rE r� r/ r� re rI rI rG rJ r� * s, �� �� r� c sL e Zd ZdZd
eeeeee ee
dd�� fdd�
Z d e d
�d d �Z
� ZS )r zA column containing text.�none�leftTN)� text_formatru �justify�markup� highlighterr� rL c s: || _ || _|| _|| _|| _t� j|p0tdd�d� d S )NT�Zno_wrapr� )r� r� ru r� r� rD rE r6 )rF r� ru r� r� r� r� rG rI rJ rE _ s zTextColumn.__init__r� r� c C sR | j j|d�}| jr*tj|| j| jd�}nt|| j| jd�}| jrN| j�|� |S �N�r� )ru r� ) r� �formatr� r8 r� ru r� r� � highlight)rF r� �_textr� rI rI rJ r� o s zTextColumn.render)r� r� TNN)r_ r` ra rb r� r5 r. r� r r0 r6 rE r8 r� re rI rI rG rJ r \ s ��r c sL e Zd ZdZdee eeeeee dd�� fd d
�
Zd e d �d
d�Z
� Z S )r� a Renders a visual progress bar.
Args:
bar_width (Optional[int], optional): Width of bar or None for full width. Defaults to 40.
style (StyleType, optional): Style for the bar background. Defaults to "bar.back".
complete_style (StyleType, optional): Style for the completed bar. Defaults to "bar.complete".
finished_style (StyleType, optional): Style for a finished bar. Defaults to "bar.finished".
pulse_style (StyleType, optional): Style for pulsing bars. Defaults to "bar.pulse".
�( rh ri rj rk N)� bar_widthru rv rw rx r� rL c s0 || _ || _|| _|| _|| _t� j|d� d S r� )r� ru rv rw rx rD rE )rF r� ru rv rw rx r� rG rI rJ rE � s zBarColumn.__init__r� r� c C s^ t |jdurtd|j�ndtd|j�| jdu r2dn
td| j�|j |�� | j| j| j | j
d� S )z&Gets a progress bar widget for a task.Nr r) ) ro rC �widthZpulseZanimation_timeru rv rw rx ) r3 ro �maxrC r� �startedrs ru rv rw rx r� rI rI rJ r� � s
�zBarColumn.render)r� rh ri rj rk N) r_ r` ra rb r r� r5 r6 rE r3 r� re rI rI rG rJ r� z s" ��r� c @ s e Zd ZdZded�dd�ZdS )�TimeElapsedColumnzRenders time elapsed.r� r� c C sD |j r |jn|j}|du r&tddd�S tt|�d�}tt|�dd�S )zShow time elapsed.N�-:--:--�progress.elapsed�ru )�seconds)r� �
finished_time�elapsedr8 r r� r� )rF r� r ZdeltarI rI rJ r� � s
zTimeElapsedColumn.renderN�r_ r` ra rb r8 r� rI rI rI rJ r� � s r� c sh e Zd ZdZdeeeeeee ee
edd � � fd
d �
Z e ee
ed �d
d��Zded�dd�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� TNF) r� �text_format_no_percentageru r� r� r� r� rz rL c s( || _ || _t� j||||||d� d S )N)r� ru r� r� r� r� )r rz rD rE ) rF r� r ru r� r� r� r� rz rG rI rJ rE � s �zTaskProgressColumn.__init__)r� rL c C sN |du rt 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.percentager )r� u ×10³u ×10⁶u ×10⁹u ×10¹²�� z.1fz it/s)r8 r* �pick_unit_and_suffixr� )�clsr� �unit�suffix�
data_speedrI rI rJ � render_speed� s
�z TaskProgressColumn.render_speedr� r� c C s� |j d u r"| jr"| �|jp |j�S |j d u r2| jn| j}|j|d�}| jr`t j
|| j | j d�}nt || j | j d�}| j
r�| j
�|� |S r� )ro rz r �finished_speedr� r r� r� r� r8 r� ru r� r� r� )rF r� r� r� r� rI rI rJ r� � s � zTaskProgressColumn.render)r r� r� r� TNNF)r_ r` ra rb r� r5 r. r� r r0 r6 rE � classmethodrc r8 r r� re rI rI rG rJ r� � s. ��r� c sD e Zd ZdZdZd eeee d�� fdd�
Zde d �d
d �Z
� Z S )
r� a Renders estimated time remaining.
Args:
compact (bool, optional): Render MM:SS when time remaining is less than an hour. Defaults to False.
elapsed_when_finished (bool, optional): Render time elapsed when the task is finished. Defaults to False.
� �?FN)�compactr} r� c s || _ || _t� j|d� d S r� )r r} rD rE )rF r r} r� rG rI rJ rE s z TimeRemainingColumn.__init__r� r� c C s� | j r|jr|j}d}n
|j}d}|jdu r8td|d�S |du rVt| jrLdnd|d�S tt|�d�\}}t|d�\}}| jr�|s�|d �d
|d ��}n|d �d
|d �d
|d ��}t||d�S ) zShow time remaining.r zprogress.remainingNr� r z--:--r �< Z02d�:�d) r} r� r �time_remainingro r8 r �divmodr� )rF r� Z task_timeru Zminutesr Zhours� formattedrI rI rJ r� s
zTimeRemainingColumn.render)FFN) r_ r` ra rb r� r� r r6 rE r8 r� re rI rI rG rJ r� � s ��
r� c @ s e Zd ZdZded�dd�ZdS )�FileSizeColumnzRenders completed filesize.r� r� c C s t �t|j��}t|dd�S )�Show data completed.zprogress.filesizer )r* �decimalr� rC r8 �rF r� � data_sizerI rI rJ r� , s zFileSizeColumn.renderNr rI rI rI rJ r ) s r c @ s e Zd ZdZded�dd�ZdS )�TotalFileSizeColumnzRenders total filesize.r� r� c C s* |j durt�t|j ��nd}t|dd�S )r Nr� zprogress.filesize.totalr )ro r* r r� r8 r rI rI rJ r� 5 s zTotalFileSizeColumn.renderNr rI rI rI rJ r 2 s r c s> e Zd ZdZd eee d�� fdd�
Zded�d d
�Z � Z
S ) �MofNCompleteColumnaH Renders completed count/total, e.g. ' 10/1000'.
Best for bounded tasks with int quantities.
Space pads the completed count so that progress length does not change as task progresses
past powers of 10.
Args:
separator (str, optional): Text to separate completed and total values. Defaults to "/".
�/N)� separatorr� c s || _ t� j|d� d S r� )r" rD rE )rF r" r� rG rI rJ rE G s zMofNCompleteColumn.__init__r� r� c C sP t |j�}|jdur t |j�nd}tt|��}t||� d��| j� |� �dd�S )zShow completed/total.N�?r �progress.downloadr )r� rC ro r� r� r8 r" )rF r� rC ro Z total_widthrI rI rJ r� K s
�zMofNCompleteColumn.render)r! N) r_ r` ra rb r� r r6 rE r8 r� re rI rI rG rJ r ; s r c s@ e Zd ZdZd eee dd�� fdd�
Zded�d d
�Z � Z
S ) r� z�Renders file size downloaded and total, e.g. '0.5/2.3 GB'.
Args:
binary_units (bool, optional): Use binary units, KiB, MiB etc. Defaults to False.
FN)� binary_unitsr� rL c s || _ t� j|d� d S r� )r% rD rE )rF r% r� rG rI rJ rE ] s zDownloadColumn.__init__r� r� c C s� t |j�}|jdur t |j�n|}| jr@t�|g d�d�\}}nt�|g d�d�\}}|dkrbdnd}|| }|d|� d ��}|jdur�t |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,.�fr# r! r� r$ r )r� rC ro r% r* r
r8 )rF r� rC Z unit_and_suffix_calculation_baser r
Z precisionZcompleted_ratioZ
completed_strro Z total_ratioZ total_strZdownload_statusZ
download_textrI rI rJ r� c s2
��
�
zDownloadColumn.render)FN) r_ r` ra rb r� r r6 rE r8 r� re rI rI rG rJ r� V s ��r� c @ s e Zd ZdZded�dd�ZdS )�TransferSpeedColumnz&Renders human readable transfer speed.r� r� c C s@ |j p
|j}|du r tddd�S t�t|��}t|� d�dd�S )zShow data transfer speed.Nr# zprogress.data.speedr z/s)r r� r8 r* r r� )rF r� r� r rI rI rJ r� � s
zTransferSpeedColumn.renderNr rI rI rI rJ r' � s r' c @ s" e Zd ZU dZeed< eed< dS )�ProgressSamplez$Sample of progress for a given time.r� rC N)r_ r` ra rb rc r� rI rI rI rJ r( � s
r( c @ s� e Zd ZU dZeed< eed< ee ed< eed< e ed< dZ
ee ed< d Z e ed
< e
ed �Zeeef ed < e
dd
d
d�Zee ed< e
dd
d
d�Zee ed< dZee ed< e
dd� d
d
d�Zee ed< e
d
ed�Zeed< ed�dd�Zee d�dd ��Z eee d�d d ��Z eee d�d d ��Z ee d�d!d"��Z eed�d#d$��Z eee d�d%d&��Z!eee d�d'd(��Z"dd�d)d*�Z#dS )+r� z�Information regarding a progress task.
This object should be considered read-only outside of the :class:`~Progress` class.
r� rn ro rC � _get_timeNr T�visible)�default_factory�fieldsF)�default�init�repr�
start_time� stop_timer c C s
t dd�S )Nr )�maxlenr rI rI rI rJ �<lambda>� � z
Task.<lambda>)r+ r. r/ � _progress)r/ r+ �_lockrK c C s | � � S )z(float: Get the current time, in seconds.)r) rU rI rI rJ rs � s z
Task.get_timec C s
| j duS )z#bool: Check if the task as started.N)r0 rU rI rI rJ r� � s 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)ro rC rU rI rI rJ � 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)r0 r1 rs rU rI rI rJ r � s
z Task.elapsedc C s
| j duS )z Check if the task has finished.N)r rU rI rI rJ r� � s z
Task.finishedc C s. | j s
dS | j| j d }tdtd|��}|S )zOfloat: Get progress of task as a percentage. If a None total was set, returns 0� � Y@)ro rC �minr� )rF rC rI rI rJ �
percentage� s
zTask.percentagec C s� | j du rdS | j�� | j}|s0W d � dS |d j|d j }|dkr\W d � dS t|�}t|� tdd� |D ��}|| }|W d � S 1 s�0 Y dS )z=Optional[float]: Get the estimated speed in steps per second.Nr� r c s s | ] }|j V qd S rR r� )�.0ZsamplerI rI rJ � <genexpr> r4 z Task.speed.<locals>.<genexpr>)r0 r6 r5 r� �iterr� r� )rF r? Z
total_timeZ
iter_progressZtotal_completedr� rI rI rJ r� � s
z
Task.speedc C s: | j r
dS | j}|sdS | j}|du r*dS t|| �}|S )zJOptional[float]: Get estimated time to completion, or ``None`` if no data.r8 N)r� r� r7 r )rF r� r7 ZestimaterI rI rJ r s zTask.time_remainingc C s | j �� d| _d| _dS )zReset progress.N)r5 �clearr r rU rI rI rJ �_reset s
z Task._reset)$r_ r` ra rb r: r� r� r rc �GetTimeCallabler r* r� r �dictr, r r r0 r1 r r5 r r( r r6 rs r� r� r7 r r� r; r� r r@ rI rI rI rJ r� � s@
�
r� c @ s� e Zd ZdZddddddddddd�
eeef ee e e
e
e e e ee e e dd� d d
�Z e
eed f d �d
d��Zeed �dd��Zeee d �dd��Zeee d �dd��Zee d �dd��Zdd �dd�Zdd �dd�Zd d �dd �Zeee ee ee dd �d d �Z dXee e e!e f ee
ee ee
e e d"�d#d$�Z"dYdd%d&�e#ee$ ee ee#d'�d(d)�Z%e&j'dZddd%d+�eed,e(f e)d- e$ee ee ee ee$ ee ee#d.�
d/d0��Z*e&j'd[ddd%d+�eed,e(f ee)d1 e)d2 f e$ee ee ee ee$ ee ee+d.�
d3d0��Z*d\ddd%d+�eed,e(f ee)d- e)d2 e)d1 f e$ee ee ee ee$ ee eee#e+f d.�
d4d0�Z*edd5�d6d7�Z,edd5�d8d9�Z-ddddddd:�eee
ee
ee
ee ee e e.dd;� d<d=�Z/ddd>ddd?�ee ee
e$ee ee e.dd@�dAdB�Z0d]ee
ddD�dEdF�Z1dd �dGdH�Z2e3d �dIdJ�Z4e e3 d �dKdL�Z5e e e6dM�dNdO�Z7e3d �dPdQ�Z8d^ee ee
e$e e.edS�dTdU�Z9edd5�dVdW�Z:dS )_r> a� Renders an auto-updating progress bar(s).
Args:
console (Console, optional): Optional Console instance. Default will an internal Console instance writing to stdout.
auto_refresh (bool, optional): Enable auto refresh. If disabled, you will need to call `refresh()`.
refresh_per_second (Optional[float], optional): Number of times per second to refresh the progress information or None to use default (10). Defaults to None.
speed_estimate_period: (float, optional): Period (in seconds) used to calculate the speed estimate. Defaults to 30.
transient: (bool, optional): Clear the progress on exit. Defaults to False.
redirect_stdout: (bool, optional): Enable redirection of stdout, so ``print`` may be used. Defaults to True.
redirect_stderr: (bool, optional): Enable redirection of stderr. Defaults to True.
get_time: (Callable, optional): A callable that gets the current time, or None to use Console.get_time. Defaults to None.
disable (bool, optional): Disable progress display. Defaults to False
expand (bool, optional): Expand tasks table to fit width. Defaults to False.
NTrg g >@F)
rq rp rt �speed_estimate_periodrr �redirect_stdout�redirect_stderrrs ry �expand) r� rq rp rt rC rr rD rE rs ry rF rL c
G s� |dksJ d��t � | _| p"| �� | _|| _| | _|
| _i | _td�| _ t
|pRt � |||||| j d�| _
|pr| jj| _| jj| _| jj| _d S )Nr z refresh_per_second must be > 0)rq rp rt rr rD rE �get_renderable)r r6 �get_default_columnsr� rC ry rF �_tasksr: � _task_indexr2 r+ rG �liverq rs �print�log) rF rq rp rt rC rr rD rE rs ry rF r� rI rI rJ rE * s(
�
zProgress.__init__.rK 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.default_columns(),
"Elapsed:",
TimeElapsedColumn(),
)
This code shows the creation of a Progress display, containing
a spinner to the left, the default columns, and a labeled elapsed
time column.
r{ )r r� r� r� )r rI rI rJ rH N s
�z Progress.get_default_columnsc C s | j jS rR )rK rq rU rI rI rJ rq m s zProgress.consolec C s8 | j � t| j�� �W d � S 1 s*0 Y dS )z Get a list of Task instances.N)r6 �listrI �valuesrU rI rI rJ �tasksq s zProgress.tasksc C s8 | j � t| j�� �W d � S 1 s*0 Y dS )zA list of task IDs.N)r6 rN rI �keysrU rI rI rJ �task_idsw s zProgress.task_idsc C sX | j �> | js W d � dS tdd� | j�� D ��W d � S 1 sJ0 Y dS )z'Check if all tasks have been completed.NTc s s | ] }|j V qd S rR )r� )r< r� rI rI rJ r= � r4 z$Progress.finished.<locals>.<genexpr>)r6 rI �allrO rU rI rI rJ r� } s zProgress.finishedc C s | j s| jjdd� dS )zStart the progress display.T)rM N)ry rK rT rU rI rI rJ rT � s zProgress.startc C s | j �� | jjs | j�� dS )zStop the progress display.N)rK r� rq Zis_interactiverL rU rI rI rJ r� � s
z
Progress.stopc C s | � � | S rR rS rU rI rI rJ rV � s zProgress.__enter__rW c C s | � � d S rR )r� r] rI rI rJ r^ � s zProgress.__exit__rf rl )rm ro r@ rn rA rL c
c s� |du rt t|��pd}|du r0| j||d�}n| j||d� | jjr�t| ||��.}|D ]}|V | jd7 _qXW d � q�1 s�0 Y n,| j}| j } |D ]}|V ||d� | � q�dS )a� Track progress by iterating over a sequence.
Args:
sequence (Sequence[ProgressType]): A sequence of values you want to iterate over and track progress.
total: (float, optional): Total number of steps. Default is len(sequence).
task_id: (TaskID): Task to track. Default is new task.
description: (str, optional): Description of task, if new task is created.
update_period (float, optional): Minimum time (in seconds) between calls to update(). Defaults to 0.1.
Returns:
Iterable[ProgressType]: An iterable of values taken from the provided sequence.
N�ro r) )
rc r
�add_taskrP rK rp r= rC rN rM )
rF rm ro r@ rn rA Z track_thread�valuerN rM rI rI rJ r� � s 0
zProgress.trackr� )r@ rn )r� ro r@ rn rL c C s� d}|dur|}n:|durL| j � | j| j}W d � n1 sB0 Y |du r\td��|du rt| 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'rT F�r� )r6 rI ro �
ValueErrorrU rP r� )rF r� ro r@ rn Z total_bytesrI rI rJ r� � s *�zProgress.wrap_filer� )ro r@ rn r� r� )
r� r� r� r� r� r� ro r@ rn rL c
C s d S rR rI �
rF r� r� r� r� r� r� ro r@ rn rI rI rJ r� � s z
Progress.openr� r� c
C s d S rR rI rY rI rI rJ r� � s c C s� d� t|dd��}
|
dvr(td�|���|dk} |
dkrR|dkrRt�dt� d }n&|
d
v rx|d krltd ��n |dkrxd }|d
u r�t|�j}|d
u r�| j | |d�}n| j
||d� t j |d|d�} t
| | |dd�}
|dv r�t j|
|||| d�S |
S )a# Track progress while reading from a binary file.
Args:
path (Union[str, PathLike[str]]): The path to the file to read.
mode (str): The mode to use to open the file. Only supports "r", "rb" or "rt".
buffering (int): The buffering strategy to use, see :func:`io.open`.
encoding (str, optional): The encoding to use when reading in text mode, see :func:`io.open`.
errors (str, optional): The error handling strategy for decoding errors, see :func:`io.open`.
newline (str, optional): The strategy for handling newlines in text mode, see :func:`io.open`.
total (int, optional): Total number of bytes to read. If none given, os.stat(path).st_size is used.
task_id (TaskID): Task to track. Default is new task.
description (str, optional): Description of task, if new task is created.
Returns:
BinaryIO: A readable file-like object in binary mode.
Raises:
ValueError: When an invalid mode is given.
r� F)�reverse)�brr� r� zinvalid mode {!r}r) r[ zaline buffering (buffering=1) isn't supported in binary mode, the default buffer size will be usedr� )r� r� r z can't have unbuffered text I/ONrT r� )r� TrW )r� r� )r� r� r� �line_buffering)r\ �sortedrX r� �warnings�warn�RuntimeWarningr �st_sizerU rP �ior� r� �
TextIOWrapper)rF r� r� r� r� r� r� ro r@ rn �_moder\ r� r� rI rI rJ r� s> !�
�)r@ rL c C sH | j �. | j| }|jdu r&| �� |_W d � n1 s:0 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)r6 rI r0 rs )rF r@ r� rI rI rJ �
start_task\ s
zProgress.start_taskc C sR | j �8 | j| }| �� }|jdu r*||_||_W d � n1 sD0 Y dS )z�Stop a task.
This will freeze the elapsed time on the task.
Args:
task_id (TaskID): ID of task.
N)r6 rI rs r0 r1 )rF r@ r� r� rI rI rJ � stop_taskj s
zProgress.stop_task)ro rC rN rn r* rM ) r@ ro rC rN rn r* rM r, rL c K s@ | j �� | j| } | j}
|dur:|| jkr:|| _| �� |durP| j|7 _|dur^|| _|durl|| _|durz|| _| j�|� | j|
} | � � } | | j
}
| j }|j }|r�|d j
|
k r�|� q�| dkr�|�t| | �� | jdu�r| j| jk�r| jdu �r| j| _W d � n1 �s$0 Y |�r<| �� 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 )r6 rI rC ro r@ rn r* r, rP rs rC r5 �popleftr� �appendr( r r rM )rF r@ ro rC rN rn r* rM r, r� �completed_start�update_completedr� �old_sample_timer5 rg rI rI rJ rP y sB
�
��(zProgress.updater )rT ro rC r* rn )r@ rT ro rC r* rn r, rL c
K s� | � � }| j�p | j| } | �� |r*|nd| _|dur>|| _|| _|durR|| _|r\|| _|durj|| _ d| _
W d � n1 s�0 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) rs r6 rI r@ r0 ro rC r* r, rn r rM )
rF r@ rT ro rC r* rn r, r� r� rI rI rJ �reset� s
$zProgress.resetr) )r@ rN rL c
C s� | � � }| j�� | j| }|j}| j|7 _|j| }|| j }|j}|j} |rh|d j|k rh| � qNt|�dkr|| � qh|� t
||�� |j dur�|j|j kr�|j du r�|j
|_ |j|_W d � n1 s�0 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)rs r6 rI rC rC r5 rg r� r� rh r( ro r r r� r )
rF r@ rN r� r� ri rj rk r5 rg rI rI rJ rN � s,
�
��zProgress.advancec C s | j s| jjr| j�� dS )z*Refresh (render) the progress information.N)ry rK Z
is_startedrM rU rI rI rJ rM � s zProgress.refreshc C s t | �� � }|S )z*Get a renderable for the progress display.)r- �get_renderables)rF r� rI rI rJ rG s zProgress.get_renderablec c s | � | j�}|V dS )z5Get a number of renderables for the progress display.N)�make_tasks_tablerP )rF �tablerI rI rJ rm s zProgress.get_renderables)rP rL 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 s. | ]&}t |t�rtd d�n
|�� �� V qdS )Tr� N)r� r� r6 r� �copy)r< Z_columnrI rI rJ r= s �� z,Progress.make_tasks_table.<locals>.<genexpr>)r r) )ZpaddingrF c 3 s, | ]$}t |t�r |j� d �n|� �V qdS )r� N)r� r� r� )r< �columnr� rI rJ r= s ��)r� r7 ZgridrF r* �add_row)rF rP Z
table_columnsro rI r� rJ rn
s �
��
zProgress.make_tasks_tablec C s2 | j � | �� W d � S 1 s$0 Y dS )z+Makes the Progress class itself renderable.N)r6 rG rU rI rI rJ �__rich__+ s zProgress.__rich__r9 )rn rT ro rC r* r, rL c K s� | j �d t| j|||||| j| j d�}|| j| j< |rB| �| j� | j}tt| j�d �| _W d � n1 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) r6 r) N) r6 r� rJ rs rI re r: r� rM ) rF rn rT ro rC r* r, r� Znew_task_indexrI rI rJ rU 0 s$ �
2zProgress.add_taskc C s2 | j � | j|= W d � n1 s$0 Y dS )z]Delete a task if it exists.
Args:
task_id (TaskID): A task ID.
N)r6 rI )rF r@ rI rI rJ � remove_task[ s zProgress.remove_task)NNrf rl )N)r� NNN)r� NNN)r� r� NNN)r) )Tr9 r T);r_ r` ra rb r% r� r� r r, r� rc rA rE r r" rH r� rq r r� rP r: rR r� rT r� rV r# rd r r^ r r; r r� r r� r� �typing�overloadr� r( r� r! re rf r rP rl rN rM r/ rG rm r7 rn rs rU rt rI rI rI rJ r> sn �
� $
� �� , ��� * � � � � � � � �
� M�� A�� ' ! �� +r> �__main__)�Panel)�Rule)�Syntax)r7 a~ def loop_last(values: Iterable[T]) -> Iterable[Tuple[bool, T]]:
"""Iterate and generate a tuple with a flag for last value."""
iter_values = iter(values)
try:
previous_value = next(iter_values)
except StopIteration:
return
for value in iter_values:
yield False, previous_value
previous_value = value
yield True, previous_valueZpython)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)rq rr z[red]Downloadingr rT z[green]Processingz[yellow]Thinkingr r� g333333�?g{�G�z�?�d )rf NTNFNrg rh ri rj rk rl FT)r� NNN)r� NNN)r� r� NNN)�rb �sysru r^ �abcr r � collectionsr Z dataclassesr r Zdatetimer r r
Zmathr r �operatorr
�osr r � threadingr r r �typesr r r r r r r r r r r r r r r! r" r# r$ r% � version_infor( Z pip._vendor.typing_extensionsr� r* r+ rq r, r- r. r/ r� r0 Zjupyterr1 rK r2 Z progress_barr3 r� r4 ru r5 ro r6 r7 r� r8 r9 r� r: r; rc rA r< r= r� r� r� r� r� r� rv r� r� r� r� r� r r� r� r� r� r r r r� r' r( r� r> r_ Zrandom�timeZpanelrx Zrulery Zsyntaxrz rr Zprogress_renderables� itertoolsr ZexamplesrH r? rU Ztask1Ztask2Ztask3r� rP �sleepZrandintrM r� rI rI rI rJ �<module> s. P
* �� Fd�� A �� � �� � �� � V*2 * I0 1 } P
� �
����