U
ʗReb @ 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 n d dl2m1Z1 ddl3m4Z4m5Z5 ddl6m7Z7m8Z8m9Z9m:Z: ddl;mZ> ddl?m@Z@ ddlAmBZB ddlCmDZD ddlEmFZF ddlGmHZHmIZI ddlJmKZKmLZL e(deMZNe.d ZOe g ePf ZQe.d e+e ZRG d d d eZSde/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 d2d3d4ZYejZddd0d!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\ejZddd0d!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\ddd0d!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 dAeZ]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`krd dlnZnd dloZoddalpmqZq ddblrmsZs ddcltmuZu dddlGmIZI eudedfd!dgZteIdhdidjZGeGvdkdldm dneqdodpeGdqdrdsdtduetesdvg Zwd dwlxmyZy eyewZze7d!dxZ6ele_ fel{ eb fe6d"dyZ|e|j}dzd{d|Z~e|j}d}d{d|Ze|j}d~dd|Ze|jse|je~dd e|jedd eod end ddk re|eez qW 5 Q R X dS ) N)ABCabstractmethoddeque)Sized) dataclassfield) timedelta) RawIOBaseUnsupportedOperation)ceil)mmap)PathLikestat)EventRLockThread)
TracebackType)AnyBinaryIOCallableContextManagerDequeDictGenericIterableList
NamedTupleNewTypeOptionalSequenceTextIOTupleTypeTypeVarUnion) )Literal )filesize get_console)ConsoleGroup
JustifyMethodRenderableType) Highlighter) JupyterMixin)Live) ProgressBar)Spinner) StyleType)ColumnTable)TextTextTypeTaskID ProgressType_Ic sj e Zd ZdZdded fdd Zddd d
Zd dd d Zee e
ee
ee dd
ddZ Z
S ) _TrackThreadz)A thread to periodically update progress.Progressr: )progresstask_id
update_periodc s. || _ || _|| _t | _d| _t d S )Nr )r? r@ rA r done completedsuper__init__)selfr? r@ rA __class__ /builddir/build/BUILDROOT/alt-python38-pip-22.2.1-2.el8.x86_64/opt/alt/python38/lib/python3.8/site-packages/pip/_vendor/rich/progress.pyrE B s z_TrackThread.__init__Nreturnc 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 last_completedrO rC rI rI rJ runK s z_TrackThread.runc C s | | S NstartrF rI rI rJ __enter__Y s z_TrackThread.__enter__exc_typeexc_valexc_tbrL c C s | j | d S rS )rB setjoinrF rY rZ r[ rI rI rJ __exit__] s
z_TrackThread.__exit__)__name__
__module__ __qualname____doc__floatrE rR rW r r#
BaseExceptionr r_
__classcell__rI rI rG rJ r= ? s
r=
Working...TF
bar.back bar.complete bar.finished bar.pulse皙?)sequence descriptiontotal auto_refreshconsole transientget_timerefresh_per_secondstylecomplete_stylefinished_style pulse_stylerA disable
show_speedrL c c s~ |rt dgng }|t|| |
| dt|dt f t||||||pHd|
d}| |j| ||| dE dH W 5 Q R X 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.done".
pulse_style (StyleType, optional): Style for pulsing bars. Defaults to "bar.pulse".
update_period (float, optional): Minimum time (in seconds) between calls to update(). Defaults to 0.1.
disable (bool, optional): Disable display of progress.
show_speed (bool, optional): Show speed if total isn't known. Defaults to True.
Returns:
Iterable[ProgressType]: An iterable of the values in the sequence.
([progress.description]{task.description}rv rw rx ry )r{ rh rq rr rs rt ru rz )rp ro rA N)
TextColumnextend BarColumnTaskProgressColumnTimeRemainingColumnr> track)rn ro rp rq rr rs rt ru rv rw rx ry rA rz r{ columnsr? rI rI rJ r g s: (
r c @ sr e Zd ZdZd7edeeddddZd dd d
Ze e
e e e e e dd d d
Z
edddZedddZeedddZedddZedddZeedddZedddZedd d Zedd d Zd8eed!d"d#Ze e e e f d$d%d&Z d9eed!d'd(Z!d:ee"e d)d*d+Z#ddd,d-Z$d;eeed/d0d1Z%edd2d3Z&e'ed4d5d6Z(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 rS )r rW rV rI rI rJ rW s
z_Reader.__enter__rX c C s | d S rS )closer^ rI rI rJ r_ s z_Reader.__exit__c C s | S rS rI rV rI rI rJ __iter__ s z_Reader.__iter__c C s$ t | j}| jj| jt|d |S NrN )nextr r? rN r len)rF linerI rI rJ __next__ s
z_Reader.__next__c C s | j S rS )r rV rI rI rJ closed s z_Reader.closedc C s
| j S rS )r filenorV rI rI rJ r s z_Reader.filenoc C s
| j S rS )r isattyrV rI rI rJ r s z_Reader.isattyc C s | j jS rS )r namerV rI rI rJ r s z _Reader.namec C s
| j S rS )r readablerV rI rI rJ r s z_Reader.readablec C s
| j S rS )r seekablerV rI rI rJ r s z_Reader.seekablec C s dS r rI rV 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 summapr )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 )offsetwhencerL c C s$ | j ||}| jj| j|d |S )NrC )r seekr? rP r )rF r r posrI rI rJ r s z _Reader.seekc C s
| j S rS )r tellrV rI rI rJ r s z _Reader.tell)srL c C s t dd S )Nwrite)r )rF r rI rI rJ r s z
_Reader.write)T)r )r )r )r ))r` ra rb rc r r: boolrE rW r r# re r r_ r bytesr propertyr intr r strr r r r r r% bytearray
memoryviewr
r r r r r r r r r rI rI rI rJ r sD
r c @ sT e Zd ZdZdeddddZeddd 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 rS )r? r )rF r? r rI rI rJ rE s z_ReadContext.__init__rK c C s | j | j S rS )r? rU r rW rV rI rI rJ rW s
z_ReadContext.__enter__rX c C s | j | j||| d S rS )r? stopr r_ r^ rI rI rJ r_ s
z_ReadContext.__exit__) r` ra rb rc r< rE rW r r# re r r_ rI rI rI rJ r
s
r
Reading...) ro rq rr rs rt ru rv rw rx ry rz )filerp ro rq rr rs rt ru rv rw rx ry rz rL c C sh |rt dgng }
|
t|| |
| dt 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.done".
pulse_style (StyleType, optional): Style for pulsing bars. Defaults to "bar.pulse".
disable (bool, optional): Disable display of progress.
Returns:
ContextManager[BinaryIO]: A context manager yielding a progress reader.
r| r} rh r~ )rp ro )r r r DownloadColumnr r> wrap_filer )r rp ro rq rr rs rt ru rv rw rx ry rz r r? r rI rI rJ r " s0 %
r r ) rp ro rq rr rs rt ru rv rw rx ry rz
PathLike[str]rtr)r mode bufferingencodingerrorsnewlinerp ro rq rr rs rt ru rv rw rx ry rz rL c C s d S rS rI r r r r r r rp ro rq rr rs rt ru rv rw rx ry rz rI rI rJ openc s r rbc C s d S rS rI r rI rI rJ r | s c
C sr |rt dgng }|t|
|||dt 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.done".
pulse_style (StyleType, optional): Style for pulsing bars. Defaults to "bar.pulse".
disable (bool, optional): Disable display of progress.
encoding (str, optional): The encoding to use when reading in text mode.
Returns:
ContextManager[BinaryIO]: A context manager yielding a progress reader.
r| r} rh r~ )r r r r r rp ro )r r r r r r> r r )r r r r r r rp ro rq rr rs rt ru rv rw rx ry rz r r? r rI rI rJ r sB 1
c @ sj e Zd ZU dZdZee ed< dee ddddZ eddd Z
d
e d d d
Z e
d
e d ddZdS )ProgressColumnz3Base class for a widget to use in progress display.N max_refresh) table_columnrL c C s || _ i | _d | _d S rS )
_table_column_renderable_cache _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 rV rI rI rJ get_table_column s z ProgressColumn.get_table_columnTaskr rL c C sr | }| jdk rT|jsTz| j|j \}}W n tk
r@ Y nX || j |krT|S | |}||f| j|j< |S )a Called by the Progress object to return a renderable for the given task.
Args:
task (Task): An object containing information regarding the task.
Returns:
RenderableType: Anything renderable (including str).
N)rt r rC r idKeyErrorrender)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` ra rb rc r r rd __annotations__r6 rE r r/ r r r rI rI rI rJ r s
r c sD e Zd ZdZd ddeee d fddZded d
d Z Z S )
RenderableColumnzA column to insert an arbitrary column.
Args:
renderable (RenderableType, optional): Any renderable. Defaults to empty string.
Nr )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 rS )r r rI rI rJ r " s zRenderableColumn.render)r )
r` ra rb rc r/ r r6 rE r rf rI rI rG rJ r s r c sb e Zd ZdZdeee eeee d fdd
Z
deee edd
d d Z d
e dddZ
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 " ".
dotsprogress.spinner ? N) spinner_namerv speed
finished_textr c s< t |||d| _t|tr$t|n|| _t j|d d S )Nrv r r ) r4 spinner
isinstancer r8 from_markupr rD rE )rF r rv r r r rG rI rJ rE 0 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_spinner@ s
zSpinnerColumn.set_spinnerr r c C s |j r | jn| j| }|S rS )finishedr r r rt )rF r textrI rI rJ r O s
zSpinnerColumn.render)r r r r N)r r )r` ra rb rc r r r5 rd r9 r6 rE r r/ r rf rI rI rG rJ r & s, r c sL e Zd ZdZd
eeeeee ee
dd fdd
Z d e d
d d Z
ZS )r zA column containing text.noneleftTN) text_formatrv justifymarkup highlighterr rL c s: || _ || _|| _|| _|| _t j|p0tddd d S )NTno_wrapr )r r rv r r rD rE r6 )rF r rv 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 Nr )rv r ) r formatr r8 r rv r r highlight)rF r _textr rI rI rJ r k s zTextColumn.render)r r TNN)r` ra rb rc r r5 r. r r r0 r6 rE r8 r rf rI rI rG rJ r X s r c sL e Zd ZdZdee eeeeee dd fd d
Zd e d d
dZ
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.done".
pulse_style (StyleType, optional): Style for pulsing bars. Defaults to "bar.pulse".
( ri rj rk rl N) bar_widthrv rw rx ry r rL c s0 || _ || _|| _|| _|| _t j|d d S r )r rv rw rx ry rD rE )rF r rv rw rx ry r rG rI rJ rE s zBarColumn.__init__r r c C s^ t |jdk rtd|jndtd|j| jdkr2dn
td| j|j | | j| j| j | j
d S )z&Gets a progress bar widget for a task.Nr r) ) rp rC widthpulseanimation_timerv rw rx ry ) r3 rp maxrC r startedrt rv rw rx ry r rI rI rJ r s
zBarColumn.render)r ri rj rk rl N) r` ra rb rc r r r5 r6 rE r3 r rf rI rI rG rJ r v s" r c @ s e Zd ZdZdedddZdS )TimeElapsedColumnzRenders time elapsed.r r c C sD |j r |jn|j}|dkr&tdddS tt|d}tt|ddS )Show time remaining.N-:--:--progress.elapsedrv )seconds)r
finished_timeelapsedr8 r r r )rF r r
deltarI rI rJ r s
zTimeElapsedColumn.renderNr` ra rb rc r8 r rI rI rI rJ r s r c sh e Zd ZdZdeeeeeee ee
edd fd
d
Z e ee
ed d
dZdedddZ 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_percentagerv r r r r r{ rL c s( || _ || _t j||||||d d S )N)r rv r r r r )r r{ rD rE ) rF r r rv r r r r r{ rG rI rJ rE s zTaskProgressColumn.__init__)r rL c C sT |dkrt dddS tt|dddddgd \}}|| }t |d
| d ddS ) zRender the speed in iterations per second.
Args:
task (Task): A Task object.
Returns:
Text: Text object containing the task speed.
Nr zprogress.percentager u ×10³u ×10⁶u ×10⁹u ×10¹² z.1fz it/s)r8 r* pick_unit_and_suffixr )clsr unitsuffix
data_speedrI rI rJ render_speed s
z TaskProgressColumn.render_speedr r c C s |j d kr"| jr"| |jp |jS |j d kr2| jn| j}|j|d}| jr`t j
|| j | j d}nt || j | j d}| j
r| j
| |S r )rp r{ r finished_speedr r r r r r8 r rv r r r )rF r r r r rI rI rJ r s zTaskProgressColumn.render)r
r r r TNNF)r` ra rb rc r r5 r. r r r0 r6 rE classmethodrd r8 r r rf rI rI rG rJ r s. r c 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)compactelapsed_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 c C s | j r|jr|j}d}n
|j}d}|jdkr8td|dS |dkrVt| jrLdnd|dS tt|d\}}t|d\}}| jr|s|d d
|d }n|d d
|d d
|d }t||dS ) r r zprogress.remainingNr r z--:--r < 02d:d) r r r time_remainingrp r8 r divmodr )rF r task_timerv minutesr hours formattedrI rI rJ r
s
zTimeRemainingColumn.render)FFN) r` ra rb rc r r r r6 rE r8 r rf rI rI rG rJ r s
r c @ s e Zd ZdZdedddZdS )FileSizeColumnzRenders completed filesize.r r c C s t t|j}t|ddS )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 ZdZdedddZdS )TotalFileSizeColumnzRenders total filesize.r r c C s* |j dk rtt|j nd}t|ddS )r& Nr zprogress.filesize.totalr )rp r* r' r r8 r( rI rI rJ r 1 s zTotalFileSizeColumn.renderNr rI rI rI rJ r* . s r* c s> e Zd ZdZd eee d fdd
Zdedd 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 C s zMofNCompleteColumn.__init__r r c C sP t |j}|jdk r t |jnd}tt|}t|| d| j | ddS )zShow completed/total.N?r progress.downloadr )r rC rp r r r8 r- )rF r rC rp total_widthrI rI rJ r G s
zMofNCompleteColumn.render)r, N) r` ra rb rc r r r6 rE r8 r rf rI rI rG rJ r+ 7 s r+ c s@ e Zd ZdZd eee dd fdd
Zdedd d
Z Z
S ) r zRenders 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 )r1 rD rE )rF r1 r rG rI rJ rE Y s zDownloadColumn.__init__r r c C s t |j}|jdk r t |jn|}| jrNt|dddddddd d
g d \}}n$t|dd d
ddddddg d\}}|dkr~dnd}|| }|d| d}|jdk rt |j} | | }
|
d| d} nd} | d| d| } t| d d }
|
S ) z.Calculate common unit for completed and total.Nr KiBMiBGiBTiBPiBEiBZiBYiBi kBMBGBTBPBEBZBYBr r) r z,.fr. r, r r/ r )r rC rp r1 r* r r8 )rF r rC unit_and_suffix_calculation_baser r precisioncompleted_ratio
completed_strrp total_ratio total_strdownload_status
download_textrI rI rJ r _ s2
zDownloadColumn.render)FN) r` ra rb rc r r r6 rE r8 r rf rI rI rG rJ r R s r c @ s e Zd ZdZdedddZdS )TransferSpeedColumnz&Renders human readable transfer speed.r r c C s@ |j p
|j}|dkr tdddS tt|}t| dddS )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 rK s rK c @ s" e Zd ZU dZeed< eed< dS )ProgressSamplez$Sample of progress for a given time.r rC N)r` ra rb rc rd r rI rI rI rJ rL s
rL 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
dZee ed< e
dd
d
dZee ed< dZee ed< e
dd d
d
dZee ed< e
d
edZeed< edddZee ddd Z eee dd d Z eee dd d Z ee dd!d"Z eedd#d$Z eee dd%d&Z!eee dd'd(Z"ddd)d*Z#dS )+r zInformation regarding a progress task.
This object should be considered read-only outside of the :class:`~Progress` class.
r ro rp rC _get_timeNr Tvisible)default_factoryfieldsF)defaultinitrepr
start_time stop_timer c C s
t ddS )Nr )maxlenr rI rI rI rJ z
Task.)rO rR rS _progress)rS rO _lockrK c C s | S )z(float: Get the current time, in seconds.)rM rV rI rI rJ rt s z
Task.get_timec C s
| j dk S )z#bool: Check if the task as started.N)rT rV rI rI rJ r s z Task.startedc C s | j dkrdS | j | j S )zPOptional[float]: Get the number of steps remaining, if a non-None total was set.N)rp rC rV rI rI rJ remaining s
zTask.remainingc C s2 | j dkrdS | jdk r$| j| j S | | j S )z]Optional[float]: Time elapsed since task was started, or ``None`` if the task hasn't started.N)rT rU rt rV rI rI rJ r
s
z Task.elapsedc C s
| j dk S )z Check if the task has finished.N)r rV 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@)rp rC minr )rF rC rI rI rJ
percentage s
zTask.percentagec
C s | j dkrdS | j~ | j}|s.W 5 Q R dS |d j|d j }|dkrXW 5 Q R dS t|}t| tdd |D }|| }|W 5 Q R S Q R X dS )z=Optional[float]: Get the estimated speed in steps per second.Nr r c s s | ] }|j V qd S rS r ).0samplerI rI rJ s z Task.speed..)rT rZ rY r iterr r )rF r?
total_time
iter_progresstotal_completedr rI rI rJ r s
z
Task.speedc C s: | j r
dS | j}|sdS | j}|dkr*dS t|| }|S )zJOptional[float]: Get estimated time to completion, or ``None`` if no data.r\ N)r r r[ r )rF r r[ estimaterI rI rJ r s zTask.time_remainingc C s | j d| _d| _dS )zReset progress.N)rY clearr r rV rI rI rJ _reset s
z Task._reset)$r` ra rb rc r: r r r rd GetTimeCallabler rN r r dictrP r r rT rU r rY r rL r rZ rt r r r[ r
r r_ r r ri rI rI rI rJ r sD
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
dZeed ddZeee d ddZeee d ddZee d ddZdd ddZdd ddZd 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/d0Z*e&j'd[ddd%d+eed,e(f ee)d1 e)d2 f e$ee ee ee ee$ ee ee+d.
d3d0Z*d\ddd%d+eed,e(f ee)d- e)d2 e)d1 f e$ee ee ee ee$ ee eee#e+f d.
d4d0Z*edd5d6d7Z,edd5d8d9Z-ddddddd:eee
ee
ee
ee ee e e.dd; dddd?ee ee
e$ee ee e.dd@dAdBZ0d]ee
ddDdEdFZ1dd dGdHZ2e3d dIdJZ4e e3 d dKdLZ5e e e6dMdNdOZ7e3d dPdQZ8d^ee ee
e$e e.edSdTdUZ9edd5dVdWZ: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.
NTrh g >@F)
rr rq ru speed_estimate_periodrs redirect_stdoutredirect_stderrrt rz expand) r rr rq ru rl rs rm rn rt rz ro rL c
G s |dkst dt | _| p"| | _|| _| | _|
| _i | _t d| _
t |pRt |||||| j
d| _|pr| jj| _| jj| _| jj| _d S )Nr z refresh_per_second must be > 0)rr rq ru rs rm rn get_renderable)AssertionErrorr rZ get_default_columnsr rl rz ro _tasksr: _task_indexr2 r+ rp liverr rt printlog) rF rr rq ru rl rs rm rn rt rz ro r rI rI rJ rE & s(
zProgress.__init__.rK c C s t dt 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 rr J s
z Progress.get_default_columnsc C s | j jS rS )ru rr rV rI rI rJ rr i s zProgress.consolec
C s, | j t| j W 5 Q R S Q R X dS )z Get a list of Task instances.N)rZ listrs valuesrV rI rI rJ tasksm s zProgress.tasksc
C s, | j t| j W 5 Q R S Q R X dS )zA list of task IDs.N)rZ rx rs keysrV rI rI rJ task_idss s zProgress.task_idsc
C sJ | j : | js W 5 Q R dS tdd | j D W 5 Q R S Q R X dS )z'Check if all tasks have been completed.Tc s s | ] }|j V qd S rS )r )r` r rI rI rJ rb s z$Progress.finished..N)rZ rs allry rV rI rI rJ r y s zProgress.finishedc C s | j s| jjdd dS )zStart the progress display.T)rM N)rz ru rU rV rI rI rJ rU s zProgress.startc C s | j | jjs | j dS )zStop the progress display.N)ru r rr is_interactiverv rV rI rI rJ r s
z
Progress.stopc C s | | S rS rT rV rI rI rJ rW s zProgress.__enter__rX c C s | d S rS )r r^ rI rI rJ r_ s zProgress.__exit__rg rm )rn rp r@ ro rA rL c c s d}|dkr$t |tr(tt|}n|}|dkr@| j||d}n| j||d | jjrt| ||$}|D ]}|V | j d7 _ qhW 5 Q R X n,| j
} | j }
|D ]}|V | |d |
qdS )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.
Nrp r) ) r r rd r add_taskrP ru rq r= rC rN rM ) rF rn rp r@ ro rA
task_total track_threadvaluerN rM rI rI rJ r s&
zProgress.trackr )r@ ro )r rp r@ ro rL c C s~ d}|dk r|}n&|dk r8| j | j| j}W 5 Q R X |dkrHtd|dkr`| j||d}n| j||d t|| |ddS )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 Fr )rZ rs rp
ValueErrorr rP r )rF r rp r@ ro total_bytesrI rI rJ r s zProgress.wrap_filer )rp r@ ro r r )
r r r r r r rp r@ ro rL c
C s d S rS rI
rF r r r r r r rp r@ ro rI rI rJ r s z
Progress.openr r c
C s d S rS rI r rI rI rJ r s c C s d t|dd}
|
dkr(td||dk} |
dkrR|dkrRtdt d }n.|
d
ksb|
d kr|d krttd
n |dkrd }|dkrt|j}|dkr| j | |d}n| j
||d t j |d|d} t
| | |dd}
|d ks|d
krt j|
|||| dS |
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 warningswarnRuntimeWarningr st_sizer rP ior r
TextIOWrapper)rF r r r r r r rp r@ ro _moder r r rI rI rJ r s> !
)r@ rL c C s4 | j $ | j| }|jdkr&| |_W 5 Q R X dS )zStart 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)rZ rs rT rt )rF r@ r rI rI rJ
start_task] s
zProgress.start_taskc C s> | j . | j| }| }|jdkr*||_||_W 5 Q R X dS )zStop a task.
This will freeze the elapsed time on the task.
Args:
task_id (TaskID): ID of task.
N)rZ rs rt rT rU )rF r@ r r rI rI rJ stop_taskk s
zProgress.stop_task)rp rC rN ro rN rM ) r@ rp rC rN ro rN rM rP rL c K s* | j
| j| } | j}
|dk r:|| jkr:|| _| |dk rP| j|7 _|dk r^|| _|dk rl|| _|dk rz|| _| j| | j|
} | } | | j
}
| j }|j }|r|d j
|
k r| q| dkr|t| | | jdk r| j| jkr| jdkr| j| _W 5 Q R X |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 )rZ rs rC rp ri ro rN rP rP rt rl rY popleftr appendrL r r
rM )rF r@ rp rC rN ro rN rM rP r completed_startupdate_completedr old_sample_timerY r rI rI rJ rP z sB
zProgress.updater )rU rp rC rN ro )r@ rU rp rC rN ro rP rL c
K s | }| jf | j| } | |r*|nd| _|dk r>|| _|| _|dk rR|| _|r\|| _|dk rj|| _ d| _
W 5 Q R X | 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) rt rZ rs ri rT rp rC rN rP ro r rM )
rF r@ rU rp rC rN ro rP 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 dk r|j|j kr|j dkr|j
|_ |j|_W 5 Q R X dS )zAdvance task by a number of steps.
Args:
task_id (TaskID): ID of task.
advance (float): Number of steps to advance. Default is 1.
r r N)rt rZ rs rC rl rY r r r r rL rp r r
r r )
rF r@ rN r r r r r rY r rI rI rJ rN s,
zProgress.advancec C s | j s| jjr| j dS )z*Refresh (render) the progress information.N)rz ru
is_startedrM rV 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 rp s zProgress.get_renderablec c s | | j}|V dS )z5Get a number of renderables for the progress display.N)make_tasks_tablerz )rF tablerI rI rJ r s zProgress.get_renderables)rz rL c sR dd | j D }tj|d| jd}|D ]$ jr(|j fdd| j D q(|S )zGet 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 |trtd dn
| V qdS )Tr N)r r r6 r copy)r` _columnrI rI rJ rb s z,Progress.make_tasks_table..)r r) )paddingro c 3 s, | ]$}t |tr |j d n| V qdS )r N)r r r )r` columnr rI rJ rb ! s )r r7 gridro rN add_row)rF rz
table_columnsr rI r rJ r s
zProgress.make_tasks_tablec
C s& | j | W 5 Q R S Q R X dS )z+Makes the Progress class itself renderable.N)rZ rp rV rI rI rJ __rich__, s zProgress.__rich__r] )ro rU rp rC rN rP rL c K sr | j Z t| j|||||| j| j d}|| j| j< |rB| | j | j}tt| jd | _W 5 Q R X | |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`.
)rN rP rM rZ r) ) rZ r rt rt rs r r: r rM ) rF ro rU rp rC rN rP r new_task_indexrI rI rJ r 1 s$
zProgress.add_taskc C s | j | j|= W 5 Q R X dS )z]Delete a task if it exists.
Args:
task_id (TaskID): A task ID.
N)rZ rs )rF r@ rI rI rJ remove_task\ s zProgress.remove_task)NNrg rm )N)r NNN)r NNN)r r NNN)r) )Tr] r T);r` ra rb rc r% r r r r, r rd rj rE r r" rr r rr r r rz r: r| r rU r rW r# re r r_ r r; r r r r r typingoverloadr r( r r! r r r rP r rN rM r/ rp r r7 r r r r rI rI rI rJ r> sn
$
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_valuepython) line_numbersZfoobarZbaz123z: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)rr rs z[red]Downloadingr r z[green]Processingz[yellow]Thinkingr r g333333?g{Gz?d )rg NTNFNrh ri rj rk rl rm FT)r NNN)r NNN)r r NNN)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+ rr r, r- r. r/ r r0 jupyterr1 ru r2 progress_barr3 r r4 rv r5 r r6 r7 r r8 r9 r r: r; rd rj r< r= r r r r r r r r r r r r r r r r r r% r* r+ r rK rL r r> r` randomtimepanelr ruler syntaxr r Zprogress_renderables itertoolsr Zexamplesrr r? r Ztask1Ztask2Ztask3r rP sleeprandintrw r rI rI rI rJ s, P
* F` A V*2 * I0 1 } U