File: //usr/local/lib/python3.10/site-packages/pip/_vendor/rich/__pycache__/progress.cpython-310.pyc
o
��i�� � + @ s d dl Z d dlZd dlZd dlZd dlmZmZ d dlmZ d dl m
Z
d dl m Z m
Z
d dlmZ d dl mZmZ 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/ ej0dkr�d dlm1Z1 nd 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�ZS ! " # $ % & ' ( " !d�d)e/e*eO e%eO f d*eTd+e)eP d,eUd-e)e7 d.eUd/e)e g ePf d0ePd1eFd2eFd3eFd4eFd5ePd6eUd7eUd8e%eO f d9d:�ZVG d;d<� d<ee �ZWG d=d>� d>e!eR e$eR �ZXd?d!dd"dd#d$d%d&d'd"d@� dAe d+eMd*eTd,eUd-e)e7 d.eUd/e)e g ePf d0ePd1eFd2eFd3eFd4eFd6eUd8e!e f dBdC�ZYejZ D d�dd?d!dd"dd#d$d%d&d'd"dE� dAe/eTdFe[f dGe/e1dH e1dI f dJeMdKe)eT dLe)eT dMe)eT d+e)eM d*eTd,eUd-e)e7 d.eUd/e)e g ePf d0ePd1eFd2eFd3eFd4eFd6eUd8e!e+ f&dNdO��Z\ejZ D d�dd?d!dd"dd#d$d%d&d'd"dE� dAe/eTdFe[f dGe1dP dJeMdKe)eT dLe)eT dMe)eT d+e)eM d*eTd,eUd-e)e7 d.eUd/e)e g ePf d0ePd1eFd2eFd3eFd4eFd6eUd8e!e f&dQdO��Z\ I D d�dd?d!dd"dd#d$d%d&d'd"dE� dAe/eTdFe[f dGe/e1dP e1dH e1dI f dJeMdKe)eT dLe)eT dMe)eT d+e)eM d*eTd,eUd-e)e7 d.eUd/e)e g ePf d0ePd1eFd2eFd3eFd4eFd6eUd8e/e!e e!e+ f f&dRdO�Z\G dSdT� dTe�Z]G dUdV� dVe]�Z^G dWdX� dXe]�Z_G dYdZ� dZe]�Z`G d[d\� d\e]�ZaG d]d^� d^e]�ZbG d_d`� d`e`�ZcG dadb� dbe]�ZdG dcdd� dde]�ZeG dedf� dfe]�ZfG dgdh� dhe]�ZgG didj� dje]�ZhG dkdl� dle]�ZiG dmdn� dne'�Zje G dodp� dp��ZkG dqdr� dre>�Zlemdsk�r�d dlnZnd dloZoddtlpmqZq ddulrmsZs ddvltmuZu ddwlGmIZI eudxdyd!dz�ZteId{d|d}�ZGeG�vd~dd�� d�eqd��d�eGd�d�d�d��d�etesd��g Zwd d�lxmyZy eyew�Zze7d!d��Z6ele_� gel�{� �eb� �R e6d"d����QZ|e|j}d�d�d��Z~e|j}d�d�d��Ze|j}d�dd��Z�e|j��s�e|j�e~d�d�� e|j�ed�d�� eo��d�� en��d d��dk �r�e|��e�ez�� e|j��r�W d � dS W d � dS 1 �s�w Y dS dS )�� N)�ABC�abstractmethod��deque)�Sized)� dataclass�field)� timedelta)� RawIOBase�UnsupportedOperation)�ceil)�mmap)�PathLike�stat)�Event�RLock�Thread)�
TracebackType)�Any�BinaryIO�Callable�ContextManager�Deque�Dict�Generic�Iterable�List�
NamedTuple�NewType�Optional�Sequence�TextIO�Tuple�Type�TypeVar�Union)� � )�Literal� )�filesize� get_console)�Console�Group�
JustifyMethod�RenderableType)� Highlighter)� JupyterMixin)�Live)� ProgressBar)�Spinner)� StyleType)�Column�Table)�Text�TextType�TaskID� ProgressType�_Ic sl e Zd ZdZdddddef� fdd� Zdd d �Zdd
d�Zdee e
dee
dee d d
fdd�Z � Z
S )� _TrackThreadz)A thread to periodically update progress.�progress�Progress�task_idr: �
update_periodc s. || _ || _|| _t� | _d| _t� �� d S )Nr )r> r@ rA r �done� completed�super�__init__)�selfr> r@ rA �� __class__� �D/usr/local/lib/python3.10/site-packages/pip/_vendor/rich/progress.pyrE B s z_TrackThread.__init__�returnNc C sj | j }| jj}| j}d}| jj}||�s(| j}||kr$|||| � |}||�r| jj| j | jdd� d S )Nr T)rC �refresh)r@ r> �advancerA rB �waitrC �update)rF r@ rM rA �last_completedrN rC rI rI rJ �runK s �z_TrackThread.runc C � | � � | S �N��start�rF rI rI rJ � __enter__Y � z_TrackThread.__enter__�exc_type�exc_val�exc_tbc C s | j �� | �� d S rS )rB �set�join�rF rY rZ r[ rI rI rJ �__exit__] s
z_TrackThread.__exit__�rK N)rK r= )�__name__�
__module__� __qualname__�__doc__�floatrE rQ rW r r# �
BaseExceptionr r_ �
__classcell__rI rI rG rJ r= ? s
����r= �
Working...TF�
�bar.back� bar.complete� bar.finished� bar.pulse皙�����?�sequence� description�total� auto_refresh�console� transient�get_time�refresh_per_second�style�complete_style�finished_style� pulse_stylerA �disable�
show_speedrK c c s� � |rt d�gng }|�t|| |
| d�t|d�t� f� t||||||p%d|
d��}|� |j| ||| d�E dH W d � dS 1 sDw Y dS )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}�rw rx ry rz )r| ri �rr rs rt ru rv r{ )rq rp rA N)�
TextColumn�extend� BarColumn�TaskProgressColumn�TimeRemainingColumnr? �track)ro rp rq rr rs rt ru rv rw rx ry rz rA r{ r| �columnsr> rI rI rJ r� g s8 �(���� �
�"�r� c @ s� e Zd ZdZ d?dedddededd f
d
d �Zd@d d
�Zde e
e de e de e dd fdd�Z
defdd�Zdefdd�Zedefdd��Zdefdd�Zdefdd �Zedefd d ��Zedefd d ��Zdefd!d"�Zdefd#d$�Zdefd%d&�ZdAd(edefd)d*�Z d+e e e e f fd,d-�Z!dAd(edefd.d/�Z"dAd0ede#e fd1d2�Z$dBd3d4�Z%dCd6ed7edefd8d9�Z&defd:d;�Z'd<e(defd=d>�Z)d S )D�_Readerz9A reader that tracks progress while it's being read from.T�handler> r? �task� close_handlerK Nc C s" || _ || _|| _|| _d| _d S �NF)r� r> r� r� �_closed)rF r� r> r� r� rI rI rJ rE � s
z_Reader.__init__c C s | j �� | S rS )r� rW rV rI rI rJ rW � s
z_Reader.__enter__rY rZ r[ c C � | � � d S rS )�closer^ rI rI rJ r_ � � z_Reader.__exit__c C s | S rS rI rV rI rI rJ �__iter__� � z_Reader.__iter__c C s$ t | j�}| jj| jt|�d� |S �N�rM )�nextr� r> rM r� �len)rF �linerI rI rJ �__next__� s
z_Reader.__next__c C � | j S rS )r� rV rI rI rJ �closed� s z_Reader.closedc C �
| j �� S rS )r� �filenorV rI rI rJ r� � �
z_Reader.filenoc C r� rS )r� �isattyrV rI rI rJ r� � r� z_Reader.isattyc C � | j jS rS )r� �moderV rI rI rJ r� � � z _Reader.modec C r� rS )r� �namerV rI rI rJ r� � r� z _Reader.namec C r� rS )r� �readablerV rI rI rJ r� � r� z_Reader.readablec C r� rS )r� �seekablerV rI rI rJ r� � r� z_Reader.seekablec C � dS r� rI rV rI rI rJ �writable� r� z_Reader.writable����sizec C �& | j �|�}| jj| jt|�d� |S r� )r� �readr> rM r� r� )rF r� �blockrI rI rJ r� � � z _Reader.read�bc C s" | j �|�}| jj| j|d� |S r� )r� �readintor> rM r� )rF r� �nrI rI rJ r� � s z_Reader.readintoc C r� r� )r� �readliner> rM r� r� )rF r� r� rI rI rJ r� � r� z_Reader.readline�hintc C s, | j �|�}| jj| jttt|��d� |S r� )r� � readlinesr> rM r� �sum�mapr� )rF r� �linesrI rI rJ r� � s z_Reader.readlinesc C s | j r| j�� d| _d S )NT)r� r� r� r� rV rI rI rJ r� s
z
_Reader.closer �offset�whencec C s$ | j �||�}| jj| j|d� |S )N�rC )r� �seekr> rO r� )rF r� r� �posrI rI rJ r� s z _Reader.seekc C r� rS )r� �tellrV rI rI rJ r�
r� z _Reader.tell�sc C s t d��)N�write)r )rF r� rI rI rJ r�
s z
_Reader.write)T)rK r� )r� r` )r )*ra rb rc rd r r: �boolrE rW r r# rf r r_ r� �bytesr� �propertyr� �intr� r� �strr� r� r� r� r� r� r% � bytearray�
memoryviewr
r� r� r r� r� r� r� r r� rI rI rI rJ r� � sZ �����
�
���
�
r� c @ s^ e Zd ZdZdddeddfdd�Zdefd d
�Zd eee d ee d
ee
ddfdd�Z dS )� _ReadContextzEA utility class to handle a context for both a reader and a progress.r> r? �readerrK Nc C s || _ || _d S rS )r> r� )rF r> r� rI rI rJ rE s
z_ReadContext.__init__c C s | j �� | j�� S rS )r> rU r� rW rV rI rI rJ rW s
z_ReadContext.__enter__rY rZ r[ c C s | j �� | j�|||� d S rS )r> �stopr� r_ r^ rI rI rJ r_ s
z_ReadContext.__exit__) ra rb rc rd r< rE rW r r# rf r r_ rI rI rI rJ r� s
����r� �
Reading...) rp rr rs rt ru rv rw rx ry rz r{ �filec 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~ ri r )rq rp )r� r� r� �DownloadColumnr� r? � wrap_filer� )r� rq rp rr rs rt ru rv rw rx ry rz r{ r� r> r� rI rI rJ r� & s0 %���� �
r� r� ) rq rp rr rs rt ru rv rw rx ry rz r{ �
PathLike[str]r� �rt�r� buffering�encoding�errors�newlinec C � d S rS rI �r� r� r� r� r� r� rq rp rr rs rt ru rv rw rx ry rz r{ rI rI rJ �openg � r� �rbc C r� rS rI r� rI rI rJ r� � r� 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~ ri r )r� r� r� r� r� rq rp )r� r� r� r� r� r? r� r� )r� r� r� r� r� r� rq rp rr rs rt ru rv rw rx ry rz r{ r� r> r� rI rI rJ r� � sB 1���� �
�
c @ sp e Zd ZU dZdZee ed< ddee ddfdd�Z defdd �Z
d
d de fd d
�Z e
d
d de fdd��ZdS )�ProgressColumnz3Base class for a widget to use in progress display.N� max_refresh� table_columnrK c C s || _ i | _d | _d S rS )�
_table_column�_renderable_cache� _update_time)rF r� rI rI rJ rE � s
zProgressColumn.__init__c C s | j pt� S )z.Get a table column, used to build tasks table.)r� r6 rV rI rI rJ �get_table_column� s z ProgressColumn.get_table_columnr� �Taskc 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)ru r� rC r� �id�KeyError�render)rF r� � current_time� timestamp�
renderablerI rI rJ �__call__� s �
zProgressColumn.__call__c C r� )z"Should return a renderable object.NrI �rF r� rI rI rJ r� s zProgressColumn.renderrS )ra rb rc rd r� r re �__annotations__r6 rE r� r/ r� r r� rI rI rI rJ r� � s
r� c sJ e Zd ZdZ ddd�dedee f� fdd�Zd d
d efd d
�Z� Z S )�RenderableColumnz�A column to insert an arbitrary column.
Args:
renderable (RenderableType, optional): Any renderable. Defaults to empty string.
� N�r� r� r� c � || _ t� j|d� d S �Nr� )r� rD rE )rF r� r� rG rI rJ rE � zRenderableColumn.__init__r� r� rK c C r� rS )r� r� rI rI rJ r� & s zRenderableColumn.render)r� )
ra rb rc rd r/ r r6 rE r� rg rI rI rG rJ r� s ����r� c s� e Zd ZdZ ddedee d ed
ed ee f
� fd d
�
Z
ddedee d eddfdd�Z ddde fdd�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_namerw �speed�
finished_textr� c s< t |||d�| _t|t�rt�|�n|| _t� j|d� d S )N�rw r� r� ) r4 �spinner�
isinstancer� r8 � from_markupr� rD rE )rF r� rw r� r� r� rG rI rJ rE 4 s ��zSpinnerColumn.__init__�
spinner_stylerK 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| j}|S | j�|�� �}|S rS )�finishedr� r� r� ru )rF r� �textrI rI rJ r� S s ����zSpinnerColumn.render)r� r� r� r� N)r� r� )ra rb rc rd r� r r5 re r9 r6 rE r� r/ r� rg rI rI rG rJ r� * s< ����������
�r� c sd e Zd ZdZ ddededed ed
ee d ee
d df� fd
d�
Z ddd e fdd�Z
� ZS )r� zA column containing text.�none�leftTN� text_formatrw �justify�markup� highlighterr� rK c s: || _ || _|| _|| _|| _t� j|ptdd�d� d S )NT��no_wrapr� )r r rw r r rD rE r6 )rF r rw r r r r� rG rI rJ rE _ s zTextColumn.__init__r� r� c C sR | j j|d�}| jrtj|| j| jd�}n t|| j| jd�}| jr'| j�|� |S �N�r� )rw r ) r �formatr r8 r� rw r r � highlight)rF r� �_textr� rI rI rJ r� o s zTextColumn.render)r� r� TNN)ra rb rc rd r� r5 r. r� r r0 r6 rE r8 r� rg rI rI rG rJ r� \ s. ��������r� c sf e Zd ZdZ ddee d ed
ed ed ed
ee ddf� fdd�
Zddde fdd�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".
�( rj rk rl rm N� bar_widthrw rx ry rz r� rK c s0 || _ || _|| _|| _|| _t� j|d� d S r� )r rw rx ry rz rD rE )rF r rw rx ry rz r� rG rI rJ rE � s zBarColumn.__init__r� r� 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) ) rq rC �width�pulse�animation_timerw rx ry rz ) r3 rq �maxrC r �startedru rw rx ry rz r� rI rI rJ r� � s
�zBarColumn.render)r rj rk rl rm N) ra rb rc rd r r� r5 r6 rE r3 r� rg rI rI rG rJ r� z s0 ��������r� c @ �" e Zd ZdZdddefdd�ZdS )�TimeElapsedColumnzRenders time elapsed.r� r� rK c C sD |j r|jn|j}|du rtddd�S tt|�d�}tt|�dd�S )�Show time remaining.N�-:--:--�progress.elapsed�rw )�seconds)r� �
finished_time�elapsedr8 r r� r� )rF r� r �deltarI rI rJ r� � s
zTimeElapsedColumn.renderN�ra rb rc rd r8 r� rI rI rI rJ r � � r c s� e Zd ZdZ dd ed
ed ed ed
edee dee
deddf� fdd�
Z e dee
defdd��Zdddefdd�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 �text_format_no_percentagerw r r r r� r| rK c s( || _ || _t� j||||||d� d S )N)r rw r r r r� )r r| rD rE ) rF r r rw r r r r� r| rG rI rJ rE � s
�zTaskProgressColumn.__init__r� 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.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 r| jn| j}|j|d�}| jr0t j
|| j | j d�}n t || j | j d�}| j
rB| j
�|� |S r )rq r| r& �finished_speedr� r r r r r8 r� rw r r r )rF r� r r
r� rI rI rJ r� � s � zTaskProgressColumn.render)r r� r� r� TNNF)ra rb rc rd r� r5 r. r� r r0 r6 rE � classmethodre r8 r& r� rg rI rI rG rJ r� � s@ �������� �
�r� c sP e Zd ZdZdZ ddededee f� fdd �
Zd
d d e fd
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�compact�elapsed_when_finishedr� c s || _ || _t� j|d� d S r� )r* r+ rD rE )rF r* r+ r� rG rI rJ rE s z TimeRemainingColumn.__init__r� r� rK c C s� | j r |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 ) r r zprogress.remainingNr� r z--:--r �< �02d�:�d) r+ r� r �time_remainingrq r8 r* �divmodr� )rF r� � task_timerw �minutesr �hours� formattedrI rI rJ r� s
zTimeRemainingColumn.render)FFN) ra rb rc rd r� r� r r6 rE r8 r� rg rI rI rG rJ r� � s ����
r� c @ r )�FileSizeColumnzRenders completed filesize.r� r� rK 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 r6 ) r r6 c @ r )�TotalFileSizeColumnzRenders total filesize.r� r� rK c C s* |j dur
t�t|j ��nd}t|dd�S )r7 Nr� zprogress.filesize.totalr )rq r* r8 r� r8 r9 rI rI rJ r� 5 s zTotalFileSizeColumn.renderNr rI rI rI rJ r; 2 r r; c sB e Zd ZdZd
dedee f� fdd�
Zdd d
efd d �Z � Z
S )�MofNCompleteColumnaH Renders completed count/total, e.g. ' 10/1000'.
Best for bounded tasks with int quantities.
Space pads the completed count so that progress length does not change as task progresses
past powers of 10.
Args:
separator (str, optional): Text to separate completed and total values. Defaults to "/".
�/N� separatorr� c r� r� )r> rD rE )rF r> r� rG rI rJ rE G s zMofNCompleteColumn.__init__r� r� rK c C sP t |j�}|jdurt |j�nd}tt|��}t||� d��| j� |� �dd�S )zShow completed/total.N�?r/ �progress.downloadr )r� rC rq r� r� r8 r> )rF r� rC rq � total_widthrI rI rJ r� K s
�zMofNCompleteColumn.render)r= N) ra rb rc rd r� r r6 rE r8 r� rg rI rI rG rJ r< ; s r< c sH e Zd ZdZ d
dedee ddf� fdd�
Zd d
defd d �Z � Z
S )r� z�Renders file size downloaded and total, e.g. '0.5/2.3 GB'.
Args:
binary_units (bool, optional): Use binary units, KiB, MiB etc. Defaults to False.
FN� binary_unitsr� rK c r� r� )rB rD rE )rF rB r� rG rI rJ rE ] r� zDownloadColumn.__init__r� r� 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� �KiB�MiB�GiB�TiB�PiB�EiB�ZiB�YiBi ) r� �kB�MB�GB�TB�PB�EB�ZB�YBr r) r z,.�fr? r= r� r@ r )r� rC rq rB r* r! r8 )rF r� rC � unit_and_suffix_calculation_baser# r$ � precision�completed_ratio�
completed_strrq � total_ratio� total_str�download_status�
download_textrI rI rJ r� c s2
�
��
zDownloadColumn.render)FN) ra rb rc rd r� r r6 rE r8 r� rg rI rI rG rJ r� V s ����r� c @ r )�TransferSpeedColumnz&Renders human readable transfer speed.r� r� rK c C s@ |j p|j}|du rtddd�S t�t|��}t|� d�dd�S )zShow data transfer speed.Nr? zprogress.data.speedr z/s)r' r� r8 r* r8 r� )rF r� r� r% rI rI rJ r� � s
zTransferSpeedColumn.renderNr rI rI rI rJ r\ � r r\ c @ s$ e Zd ZU dZeed< eed< dS )�ProgressSamplez$Sample of progress for a given time.r� rC N)ra rb rc rd re 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< defdd�Zede fdd ��Z edee fd d ��Z edee fd d ��Z ede fd!d"��Z edefd#d$��Z edee fd%d&��Z!edee fd'd(��Z"d+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� rp rq 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>� s
z
Task.<lambda>)r` rc rd � _progress)rd r` �_lockrK c C s | � � S )z(float: Get the current time, in seconds.)r^ rV rI rI rJ ru � r� z
Task.get_timec C �
| j duS )z#bool: Check if the task as started.N)re rV rI rI rJ 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)rq rC rV 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)re rf ru rV rI rI rJ r � s
z Task.elapsedc C rk )z Check if the task has finished.N)r rV rI rI rJ r� � rl 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@)rq rC �minr )rF rC rI rI rJ �
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 rS r� )�.0�samplerI rI rJ � <genexpr> � � z Task.speed.<locals>.<genexpr>)re rj ri r� �iterr� r� )rF r> �
total_time�
iter_progress�total_completedr� rI rI rJ 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.rn N)r� r� rm r )rF r� rm �estimaterI rI rJ r0 s zTask.time_remainingc C s | j �� d| _d| _dS )zReset progress.N)ri �clearr r' rV rI rI rJ �_reset s
z Task._resetr` )$ra rb rc rd r: r� r� r re �GetTimeCallabler r_ r� r �dictra r r re rf r' ri r r] r rj ru r� r rm r r� rq r� r0 r} rI rI rI rJ r� � sZ
�
r� c @ sp e Zd ZdZddddddddddd�
deeef d ee d
e d e
d e
d
e de de dee de de ddfdd�Z e
deedf fdd��Zedefdd��Zedee fdd ��Zedee fd d ��Zede fd d ��Zdmd!d"�Zdmd#d$�Zdnd%d&�Zd'eee d(ee d)ee ddfd*d+�Z , -dod.ee e e!e f d/ee
d0ee d1ed2e
de e f d3d4�Z" dpdd5d6�d7e#d/ee$ d0ee d1ede#f
d8d9�Z%e&j' : dqddd5d;�d7eed<e(f d=e)d> d?e$d@ee dAee dBee d/ee$ d0ee d1ede#fdCdD��Z*e&j' : dqddd5d;�d7eed<e(f d=ee)dE e)dF f d?e$d@ee dAee dBee d/ee$ d0ee d1ede+fdGdD��Z* E : drddd5d;�d7eed<e(f d=ee)d> e)dF e)dE f d?e$d@ee dAee dBee d/ee$ d0ee d1edee#e+f fdHdD�Z*d0eddfdIdJ�Z,d0eddfdKdL�Z-dddddddM�d0ed/ee
dNee
dOee
d1ee dPee dQe dRe.ddfdSdT�Z/dddUdddV�d0edWe d/ee
dNe$dPee d1ee dRe.ddfdXdY�Z0dsd0edOe
ddfd[d\�Z1dmd]d^�Z2de3fd_d`�Z4de e3 fdadb�Z5dce e de6fddde�Z7de3fdfdg�Z8 h U dtd1edWe d/ee
dNe$dPe dRe.defdidj�Z9d0eddfdkdl�Z:dS )ur? a� Renders an auto-updating progress bar(s).
Args:
console (Console, optional): Optional Console instance. Default will an internal Console instance writing to stdout.
auto_refresh (bool, optional): Enable auto refresh. If disabled, you will need to call `refresh()`.
refresh_per_second (Optional[float], optional): Number of times per second to refresh the progress information or None to use default (10). Defaults to None.
speed_estimate_period: (float, optional): Period (in seconds) used to calculate the speed estimate. Defaults to 30.
transient: (bool, optional): Clear the progress on exit. Defaults to False.
redirect_stdout: (bool, optional): Enable redirection of stdout, so ``print`` may be used. Defaults to True.
redirect_stderr: (bool, optional): Enable redirection of stderr. Defaults to True.
get_time: (Callable, optional): A callable that gets the current time, or None to use Console.get_time. Defaults to None.
disable (bool, optional): Disable progress display. Defaults to False
expand (bool, optional): Expand tasks table to fit width. Defaults to False.
NTri g >@F)
rs rr rv �speed_estimate_periodrt �redirect_stdout�redirect_stderrru r{ �expandr� rs rr rv r� rt r� r� ru r{ r� rK 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)rs rr rv rt r� r� �get_renderable)r rj �get_default_columnsr� r� r{ r� �_tasksr: � _task_indexr2 r+ r� �livers ru �print�log) rF rs rr rv r� rt r� r� ru r{ r� r� rI rI rJ rE * s(
�
zProgress.__init__.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 r� N s
�z Progress.get_default_columnsc C r� rS )r� rs rV rI rI rJ rs m r� zProgress.consolec C �8 | j � t| j�� �W d � S 1 sw Y dS )z Get a list of Task instances.N)rj �listr� �valuesrV rI rI rJ �tasksq � $�zProgress.tasksc C r� )zA list of task IDs.N)rj r� r� �keysrV rI rI rJ �task_idsw 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 rr rS )r� )rs r� rI rI rJ ru � rv z$Progress.finished.<locals>.<genexpr>)rj r� �allr� rV rI rI rJ r� } s �$�zProgress.finishedc C s | j s | jjdd� dS dS )zStart the progress display.T)rL N)r{ r� rU rV rI rI rJ rU � s �zProgress.startc C s$ | j �� | jjs| j�� dS dS )zStop the progress display.N)r� r� rs �is_interactiver� rV rI rI rJ r� � s
�z
Progress.stopc C rR rS rT rV rI rI rJ rW � rX zProgress.__enter__rY rZ r[ c C r� rS )r� r^ rI rI rJ r_ � r� zProgress.__exit__rh rn ro rq r@ rp rA c c s� � d}|du rt |t�rtt|��}n|}|du r!| j||d�}n| j||d� | jjrTt| ||��}|D ] }|V | j d7 _ q5W d � dS 1 sMw Y dS | 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�rq r) ) r� r re r� �add_taskrO r� rr r= rC rM rL ) rF ro rq r@ rp rA �
task_total� track_thread�valuerM rL rI rI rJ r� � s0 �
��"�
�zProgress.trackr� )r@ rp 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� )rj r� rq �
ValueErrorr� rO r� )rF r� rq r@ rp � total_bytesrI rI rJ r� � s ��zProgress.wrap_filer� )rq r@ rp r� r� r� r� r� r� r� c
C r� rS rI �
rF r� r� r� r� r� r� rq r@ rp rI rI rJ r� � � z
Progress.openr� r� c
C r� rS rI r� rI rI rJ r� r� c C s� d� t|dd��}
|
dvrtd�|���|dk} |
dkr)|dkr)t�dt� d }n|
d
ks1|
d kr?|d kr9td
��|dkr?d }|du rHt|�j}|du rT| j | |d�}n| j
||d� t j |d|d�} t
| | |dd�}
|d kss|d
kr}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/ONr� r� )r� Tr� )r� r� r� �line_buffering)r] �sortedr� r �warnings�warn�RuntimeWarningr �st_sizer� rO �ior� r� �
TextIOWrapper)rF r� r� r� r� r� r� rq r@ rp �_moder� r� r� rI rI rJ r� s> !�
�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)rj r� re ru )rF r@ r� rI rI rJ �
start_taska 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)rj r� ru re rf )rF r@ r� r� rI rI rJ � stop_tasko s
"�zProgress.stop_task)rq rC rM rp r_ rL rC rM r_ rL ra 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 )rj r� rC rq r} rp r_ ra rO ru r� ri �popleftr� �appendr] r r rL )rF r@ rq rC rM rp r_ rL ra r� �completed_start�update_completedr� �old_sample_timeri r� rI rI rJ rO ~ sD
�
� �" �zProgress.updater )rU rq rC r_ rp rU 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) ru rj r� r} re rq rC r_ ra rp r rL )
rF r@ rU rq rC r_ rp ra r� r� rI rI rJ �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)ru rj r� rC r� ri r� r� r� r� r] rq r r r� r' )
rF r@ rM r� r� r� r� r� ri r� rI rI rJ rM � s8
� �
���"�zProgress.advancec C s$ | j s| jjr| j�� dS dS dS )z*Refresh (render) the progress information.N)r{ r� �
is_startedrL rV rI rI rJ rL s �zProgress.refreshc C s t | �� � }|S )z*Get a renderable for the progress display.)r- �get_renderables)rF r� rI rI rJ r� s zProgress.get_renderablec c s � | � | j�}|V dS )z5Get a number of renderables for the progress display.N)�make_tasks_tabler� )rF �tablerI rI rJ r�
s �
zProgress.get_renderablesr� 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� r� r6 r� �copy)rs �_columnrI rI rJ ru 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� r� r )rs �columnr rI rJ ru % s � ��
�)r� r7 �gridr� r_ �add_row)rF r� �
table_columnsr� rI r rJ r� s �
���
zProgress.make_tasks_tablec C s2 | j � | �� W d � S 1 sw Y dS )z+Makes the Progress class itself renderable.N)rj r� rV rI rI rJ �__rich__0 s $�zProgress.__rich__ro 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`.
)r_ ra r^ rj r) N) rj r� r� ru r� r� r: r� rL ) rF rp rU rq rC r_ ra r� �new_task_indexrI rI rJ r� 5 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)rj r� )rF r@ rI rI rJ � remove_task` s
"�zProgress.remove_taskr` )rK r? )NNrh rn rS �r� NNN�r� r� NNN)r) )Tro r T);ra rb rc rd r% r� r� r r, r� re r~ rE r( r" r� r� rs r r� r� r: r� r� rU r� rW r# rf r r_ r r; r r� r r� r� �typing�overloadr� r( r� r! r� r� r rO r� rM rL r/ r� r� r7 r� r� r� r� rI rI rI rJ r? s �
������� �
� � �
�$
���
� ������
�1������
�*� � ������ �
� � �� � ������ �
� � �� � ������ �
� �
�M������� �
�
�A������� �
�'
!�������
�+r? �__main__)�Panel)�Rule)�Syntax)r7 a~ def loop_last(values: Iterable[T]) -> Iterable[Tuple[bool, T]]:
"""Iterate and generate a tuple with a flag for last value."""
iter_values = iter(values)
try:
previous_value = next(iter_values)
except StopIteration:
return
for value in iter_values:
yield False, previous_value
previous_value = value
yield True, previous_value�python)� line_numbersZfoo�barZbaz�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)rs rt z[red]Downloadingr r� z[green]Processingz[yellow]Thinkingr) r� g333333�?g{�G�z�?�d )rh NTNFNri rj rk rl rm rn FTr� r� )�r� �sysr� r� �abcr r � collectionsr �collections.abcr � dataclassesr r �datetimer r
r �mathr r
�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+ rs r, r- r. r/ r r0 �jupyterr1 r� r2 � progress_barr3 r� r4 rw r5 r� r6 r7 r� r8 r9 r� r: r; re r~ r< r= r� r� r� r� r� r� r� r� r� r� r� r� r� r� r r� r� r6 r; r< r� r\ r] r� r? ra �random�time�panelr� �ruler� �syntaxr� r� Zprogress_renderables� itertoolsr� Zexamplesr� r> r� Ztask1Ztask2Ztask3r� rO �sleep�randintr� r� rI rI rI rJ �<module> s� P
*��������� �
� � �
���
�Fd�������� �
� � �
��
�A�� ������� �
� � �
������� ��� ������� �
� � �
������� ��� ������� �
� � �
�������
�V*2 * I0 1 }
U � �
����
�� $��