a s h@sddlmZddlZddlZddlZddlmZmZddlm Z ddl m Z m Z ddl mZddlmZmZddlmZdd lmZdd lmZdd lmZmZdd lmZmZmZdd lmZddlmZm 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/m0Z0m1Z1er&ddl2m3Z3ddl4m5Z5m6Z6ddl7m8Z8m9Z9m:Z:m;Z;ddlm?Z?ddl@mAZAddlBmCZCddlDmEZEddlFmGZGddlHmIZImJZJddlKmLZLmMZMe+deNZOe0dZPe"geQfZRe0de-e!ZSGdddeZTdd)d*d+d,d-d.d-d/d0d1d1d1d1d0d-d-d)d2d3d4ZUGd5d6d6ee!ZVGd7d8d8e#eSe&eSZWd9d!dd"dd#d$d%d&d'd"d: d;d,d*d-d.d-d/d0d1d1d1d1d-dd?ZXejYddd9d!dd"dd#d$d%d&d'd"dA dBdCd,dDdDdDdEd*d-d.d-d/d0d1d1d1d1d-dFdGdHdIZZejYddd9d!dd"dd#d$d%d&d'd"dA dBdJd,dDdDdDdEd*d-d.d-d/d0d1d1d1d1d-dd?Zdd d@dAZdBddCdDdEZdFddGdHdIZdJS)P_Readerz9A reader that tracks progress while it's being read from.Trr>r:rwrM)handler@task close_handlerOcCs"||_||_||_||_d|_dSNF)rr@rr_closed)rHrr@rrrKrKrLrGs z_Reader.__init__z '_Reader'rNcCs|j|SrW)rr[rZrKrKrLr[s z_Reader.__enter__r\r]r^r_cCs |dSrW)closererKrKrLrfsz_Reader.__exit__cCs|SrWrKrZrKrKrL__iter__sz_Reader.__iter__bytescCs$t|j}|jj|jt|d|SNrQ)nextrr@rQrlen)rHlinerKrKrL__next__s z_Reader.__next__cCs|jSrW)rrZrKrKrLclosedsz_Reader.closedrvcCs |jSrW)rfilenorZrKrKrLrsz_Reader.filenocCs |jSrW)risattyrZrKrKrLrsz_Reader.isattyrtcCs|jjSrW)rmoderZrKrKrLrsz _Reader.modecCs|jjSrW)rnamerZrKrKrLrsz _Reader.namecCs |jSrW)rreadablerZrKrKrLrsz_Reader.readablecCs |jSrW)rseekablerZrKrKrLrsz_Reader.seekablecCsdSrrKrZrKrKrLwritablesz_Reader.writable)sizerOcCs&|j|}|jj|jt|d|Sr)rreadr@rQrr)rHrblockrKrKrLrs z _Reader.readz"Union[bytearray, memoryview, mmap])bcCs"|j|}|jj|j|d|Sr)rreadintor@rQr)rHrnrKrKrLrs z_Reader.readintocCs&|j|}|jj|jt|d|Sr)rreadliner@rQrr)rHrrrKrKrLrs z_Reader.readlinez List[bytes])hintrOcCs,|j|}|jj|jttt|d|Sr)r readlinesr@rQrsummapr)rHrlinesrKrKrLrs z_Reader.readlinescCs|jr|jd|_dS)NT)rrrrrZrKrKrLr s z _Reader.closer)offsetwhencerOcCs$|j||}|jj|j|d|S)NrE)rseekr@rUr)rHrrposrKrKrLrsz _Reader.seekcCs |jSrW)rtellrZrKrKrLrsz _Reader.tellr)srOcCs tddS)Nwriter )rHrrKrKrLrsz _Reader.writez Iterable[Any])rrOcCs tddS)N writelinesr)rHrrKrKrLrsz_Reader.writelinesN)T)r)r)r)r)rgrhrirjrGr[rfrrpropertyrrrrrrrrrrrrrrrrrrKrKrKrLrs6 rc@sDeZdZdZddddddZddd d Zd d d ddddZdS) _ReadContextzEA utility class to handle a context for both a reader and a progress.r>r<rM)r@readerrOcCs||_||_dSrW)r@r)rHr@rrKrKrLrG sz_ReadContext.__init__rNcCs|j|jSrW)r@rYrr[rZrKrKrLr[$s z_ReadContext.__enter__r\r]r^r_cCs|j|j|||dSrW)r@stoprrfrerKrKrLrf(s z_ReadContext.__exit__N)rgrhrirjrGr[rfrKrKrKrLrsr Reading...) rzr|r}r~rrrrrrrrzContextManager[BinaryIO])filer{rzr|r}r~rrrrrrrrOc  Csh|rtdgng} | t|| | | dttft| |||||pDd| d}|j|||d}t||S)aRead 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. rrrmr)r{rz)rrrDownloadColumnrr wrap_filer)rr{rzr|r}r~rrrrrrrrr@rrKrKrLr2s0%  rr) r{rzr|r}r~rrrrrrr"Union[str, 'PathLike[str]', bytes]z"Union[Literal['rt'], Literal['r']] Optional[str] Optional[int]zContextManager[TextIO])rr bufferingencodingerrorsnewliner{rzr|r}r~rrrrrrrrOc CsdSrWrKrrrrrrr{rzr|r}r~rrrrrrrrKrKrLopenssr Literal['rb']c CsdSrWrKrrKrKrLrsr1Union[Literal['rb'], Literal['rt'], Literal['r']]z7Union[ContextManager[BinaryIO], ContextManager[TextIO]]c  Csr|rtdgng}|t| |||dttft||| | | | pDd|d}|j||||||||d}t||S)aRead 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. rrrmr)rrrrrr{rz)rrrrrrrr)rrrrrrr{rzr|r}r~rrrrrrrrr@rrKrKrLrsB1   c@sbeZdZUdZdZded<dddddd Zd d d d ZdddddZe dddddZ dS)ProgressColumnz3Base class for a widget to use in progress display.Nru max_refreshOptional[Column]rM) table_columnrOcCs||_i|_d|_dSrW) _table_column_renderable_cacheZ _update_time)rHrrKrKrLrGszProgressColumn.__init__r6rNcCs |jp tS)z.Get a table column, used to build tasks table.)rr6rZrKrKrLget_table_columnszProgressColumn.get_table_column'Task'r/rrOcCsp|}|jdurR|jsRz|j|j\}}Wnty>Yn0||j|krR|S||}||f|j|j<|S)aCalled 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)rrrEridKeyErrorrender)rHr current_time timestamp renderablerKrKrL__call__ s   zProgressColumn.__call__cCsdS)z"Should return a renderable object.NrKrHrrKrKrLr szProgressColumn.render)N) rgrhrirjr__annotations__rGrrrrrKrKrKrLrs  rcs@eZdZdZddddddfdd Zd dd d d ZZS)RenderableColumnzA column to insert an arbitrary column. Args: renderable (RenderableType, optional): Any renderable. Defaults to empty string. Nrr/r)rrcs||_tj|ddSNr)rrFrG)rHrrrIrKrLrG,szRenderableColumn.__init__rrcCs|jSrW)rrrKrKrLr2szRenderableColumn.render)rrgrhrirjrGrrkrKrKrIrLr%s rcsVeZdZdZdddd d d d fd d Zdddd ddddZdddddZZS) SpinnerColumnaA 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? NrtzOptional[StyleType]r?r9r) spinner_namerspeed finished_textrcs<t|||d|_t|tr$t|n||_tj|ddS)Nrrr) r4spinner isinstancertr8 from_markuprrFrG)rHrrrrrrIrKrLrG@s  zSpinnerColumn.__init__rM)r spinner_stylerrOcCst|||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. rN)r4r)rHrrrrKrKrL set_spinnerPs zSpinnerColumn.set_spinnerrr/rcCs |jr |jn|j|}|SrW)finishedrrrr)rHrtextrKrKrLr_s zSpinnerColumn.render)rrrrN)rr)rgrhrirjrGrrrkrKrKrIrLr6s rc sDeZdZdZddddd d d d d fdd ZdddddZZS)rzA column containing text.noneleftTNrtr5r.rwOptional[Highlighter]rrM) text_formatrjustifymarkup highlighterrrOcs:||_||_||_||_||_tj|p0tddddS)NTZno_wrapr)rrrrrrFrGr6)rHrrrrrrrIrKrLrGks zTextColumn.__init__rr8rcCsR|jj|d}|jr*tj||j|jd}nt||j|jd}|jrN|j||SNr)rr) rformatrr8rrrr highlight)rHr_textrrKrKrLr{s zTextColumn.render)rrTNNrrKrKrIrLrhs rc sDeZdZdZddd d d d d d d fd d ZdddddZZS)raRenders 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". (rnrorprqNrr5rrM) bar_widthrrrrrrOcs0||_||_||_||_||_tj|ddSr)r rrrrrFrG)rHr rrrrrrIrKrLrGs zBarColumn.__init__rr3rc Cs^t|jdurtd|jndtd|j|jdur2dn td|j|j ||j|j|j |j d S)z&Gets a progress bar widget for a task.Nrr)) r{rEwidthZpulseZanimation_timerrrr) r3r{maxrEr startedrrrrrrrKrKrLrs zBarColumn.render)r rnrorprqNrrKrKrIrLrs  rc@s eZdZdZdddddZdS)TimeElapsedColumnzRenders time elapsed.rr8rcCsJ|jr |jn|j}|dur&tdddSttdt|d}tt|ddS)zShow time elapsed.N-:--:--progress.elapsedrr)seconds)r finished_timeelapsedr8r r rvrt)rHrrdeltarKrKrLrs  zTimeElapsedColumn.renderNrgrhrirjrrKrKrKrLrsrc s\eZdZdZdd d d d d d dd dd fdd ZedddddZdddddZZS)raShow 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}%rrrTNFrtr5r.rwrrrM) rtext_format_no_percentagerrrrrrrOc s(||_||_tj||||||ddS)N)rrrrrr)rrrFrG) rHrrrrrrrrrIrKrLrGs zTaskProgressColumn.__init__rur8)rrOcCsN|durtdddStt|gdd\}}||}t|d|dddS) zRender the speed in iterations per second. Args: task (Task): A Task object. Returns: Text: Text object containing the task speed. Nrzprogress.percentager)ru×10³u×10⁶u×10⁹u×10¹²z.1fz it/s)r8r*pick_unit_and_suffixrv)clsrunitsuffix data_speedrKrKrL render_speeds  zTaskProgressColumn.render_speedrrcCs|jdur"|jr"||jp|jS|jdur2|jn|j}|j|d}|jr`t j ||j |j d}nt ||j |j d}|j r|j ||Sr)r{rrfinished_speedrrrrrr8rrrrr)rHrrrrrKrKrLrs  zTaskProgressColumn.render)rrrrTNNF) rgrhrirjrG classmethodrrrkrKrKrIrLrs$rcs@eZdZdZdZdddddfdd Zd d d d dZZS)raRenders 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. ?FNrwr)compactrrcs||_||_tj|ddSr)r#rrFrG)rHr#rrrIrKrLrGszTimeRemainingColumn.__init__rr8rcCs|jr|jr|j}d}n |j}d}|jdur8td|dS|durVt|jrLdnd|dStt|d\}}t|d\}}|jr|s|d d |d }n|d d |d d |d }t||dS) zShow time remaining.rzprogress.remainingNrrz--:--r<Z02d:d) rrrtime_remainingr{r8r#divmodrv)rHrZ task_timerminutesrhours formattedrKrKrLrs    zTimeRemainingColumn.render)FFN)rgrhrirjrrGrrkrKrKrIrLrs rc@s eZdZdZdddddZdS)FileSizeColumnzRenders completed filesize.rr8rcCstt|j}t|ddS)Show data completed.zprogress.filesizer)r*decimalrvrEr8rHr data_sizerKrKrLr7szFileSizeColumn.renderNrrKrKrKrLr,4sr,c@s eZdZdZdddddZdS)TotalFileSizeColumnzRenders total filesize.rr8rcCs*|jdurtt|jnd}t|ddS)r-Nrzprogress.filesize.totalr)r{r*r.rvr8r/rKrKrLr@szTotalFileSizeColumn.renderNrrKrKrKrLr1=sr1cs:eZdZdZddddfdd Zd d d d d ZZS)MofNCompleteColumnaHRenders 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 "/". /Nrtr) separatorrcs||_tj|ddSr)r4rFrG)rHr4rrIrKrLrGRszMofNCompleteColumn.__init__rr8rcCsPt|j}|jdurt|jnd}tt|}t||d|j|ddS)zShow completed/total.N?r&progress.downloadr)rvrEr{rrtr8r4)rHrrEr{Z total_widthrKrKrLrVs  zMofNCompleteColumn.render)r3NrrKrKrIrLr2Fs r2cs<eZdZdZdddddfdd Zd d d d dZZS)rzRenders 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. FNrwrrM) binary_unitsrrOcs||_tj|ddSr)r7rFrG)rHr7rrIrKrLrGhszDownloadColumn.__init__rr8rcCst|j}|jdurt|jn|}|jr@t|gdd\}}nt|gdd\}}|dkrbdnd}||}|d|d }|jdurt|j} | |} | d|d } nd } |d | d |} t| d d} | S)z.Calculate common unit for completed and total.N) rZKiBZMiBZGiBZTiBZPiBZEiBZZiBZYiBi) rZkBZMBZGBZTBZPBZEBZZBZYBrr)rz,.fr5r3rr6r)rvrEr{r7r*rr8)rHrrEZ unit_and_suffix_calculation_baserrZ precisionZcompleted_ratioZ completed_strr{Z total_ratioZ total_strZdownload_statusZ download_textrKrKrLrns2     zDownloadColumn.render)FNrrKrKrIrLrasrc@s eZdZdZdddddZdS)TransferSpeedColumnz&Renders human readable transfer speed.rr8rcCs@|jp |j}|dur tdddStt|}t|dddS)zShow data transfer speed.Nr5zprogress.data.speedrz/s)r rr8r*r.rv)rHrrrrKrKrLrs   zTransferSpeedColumn.renderNrrKrKrKrLr9sr9c@s"eZdZUdZded<ded<dS)ProgressSamplez$Sample of progress for a given time.r?rrEN)rgrhrirjrrKrKrKrLr:s r:c@sdeZdZUdZded<ded<ded<ded <d ed <d Zded <dZded<eedZ ded<ed dddZ ded<ed dddZ ded<d Z ded<edddddZ ded<ededZded <dd!d"d#Zedd!d$d%Zedd!d&d'Zedd!d(d)Zedd!d*d+Zedd!d,d-Zedd!d.d/Zedd!d0d1Zd2d!d3d4Zd S)5TaskzInformation regarding a progress task. This object should be considered read-only outside of the :class:`~Progress` class. r:rrtrzrur{r?rEGetTimeCallable _get_timeNrTrwvisible)default_factoryzDict[str, Any]fieldsF)defaultinitrepr start_time stop_timer cCs tddS)Nr)maxlenrrKrKrKrLz Task.)r?rBrCzDeque[ProgressSample] _progress)rCr?r_lockrNcCs|S)z(float: Get the current time, in seconds.)r=rZrKrKrLrsz Task.get_timecCs |jduS)z#bool: Check if the task as started.N)rDrZrKrKrLr sz Task.startedcCs|jdurdS|j|jS)zPOptional[float]: Get the number of steps remaining, if a non-None total was set.Nr{rErZrKrKrL remainings zTask.remainingcCs2|jdurdS|jdur$|j|jS||jS)z]Optional[float]: Time elapsed since task was started, or ``None`` if the task hasn't started.N)rDrErrZrKrKrLrs    z Task.elapsedcCs |jduS)zCheck if the task has finished.N)rrZrKrKrLrsz Task.finishedcCs.|js dS|j|jd}tdtd|}|S)zOfloat: Get progress of task as a percentage. If a None total was set, returns 0Y@)r{rEminr )rHrErKrKrL percentages zTask.percentagecCs|jdurdS|j|j}|s0WddS|dj|dj}|dkr\WddSt|}t|tdd|D}||}|WdS1s0YdS)z=Optional[float]: Get the estimated speed in steps per second.Nrrcss|] }|jVqdSrWr).0samplerKrKrL rHzTask.speed..)rDrJrIriterrr)rHr@Z total_timeZ iter_progressZtotal_completedrrKrKrLrs z Task.speedcCs:|jr dS|j}|sdS|j}|dur*dSt||}|S)zJOptional[float]: Get estimated time to completion, or ``None`` if no data.rMN)rrrLr )rHrrLZestimaterKrKrLr's zTask.time_remainingrMcCs|jd|_d|_dS)zReset progress.N)rIclearrr rZrKrKrL_resets z Task._reset)rgrhrirjrrr>rdictr@rDrEr rIrrJrrr rLrrrPrr'rVrKrKrKrLr;s@      r;c@seZdZdZddddddddddd dd d d d d d d d d d d d ddZeddddZeddddZeddddZ eddddZ ed dddZ d dd d!Z d dd"d#Z d$dd%d&Zd'd(d)d d*d+d,Zdwd0d1d2d3d4d d0d5d6d7Zdxdd8d9d:d;d3d4d:d<d=d>Zejdyddd8d@dAdBd2dCdCdCd;d3d4d:dD dEdFZejdzddd8d@dAdGd2dCdCdCd;d3d4dHdD dIdFZd{ddd8d@dAdKd2dCdCdCd;d3d4dLdD dMdFZdNd dOdPdQZdNd dOdRdSZdddddddTdNd1d1d1dCdUd dVd dW dXdYZddd-dddZdNd d1d2dUdCdVd d[d\d]Zd|dNd d d_d`daZd ddbdcZddddedfZdgddhdiZdjdkdldmdnZddddodpZd}d4d d1d2d dVdNdrdsdtZdNd dOdudvZ dS)~raRenders an auto-updating progress bar(s). Args: console (Console, optional): Optional Console instance. Defaults to an internal Console instance writing to stdout. auto_refresh (bool, optional): Enable auto refresh. If disabled, you will need to call `refresh()`. refresh_per_second (Optional[float], optional): Number of times per second to refresh the progress information or None to use default (10). Defaults to None. speed_estimate_period: (float, optional): Period (in seconds) used to calculate the speed estimate. Defaults to 30. transient: (bool, optional): Clear the progress on exit. Defaults to False. redirect_stdout: (bool, optional): Enable redirection of stdout, so ``print`` may be used. Defaults to True. redirect_stderr: (bool, optional): Enable redirection of stderr. Defaults to True. get_time: (Callable, optional): A callable that gets the current time, or None to use Console.get_time. Defaults to None. disable (bool, optional): Disable progress display. Defaults to False expand (bool, optional): Expand tasks table to fit width. Defaults to False. NTrmg>@F) r}r|rspeed_estimate_periodr~redirect_stdoutredirect_stderrrrexpandzUnion[str, ProgressColumn]rxrwr?zOptional[GetTimeCallable]rM) rr}r|rrXr~rYrZrrr[rOc Gs|dksJdt|_| p"||_||_| |_| |_i|_td|_ t |pRt ||||||j d|_ |pr|jj|_|jj|_|jj|_dS)Nrzrefresh_per_second must be > 0)r}r|rr~rYrZget_renderable)rrJget_default_columnsrrXrr[_tasksr: _task_indexr2r+r\rSr}rprintlog) rHr}r|rrXr~rYrZrrr[rrKrKrLrG5s(   zProgress.__init__zTuple[ProgressColumn, ...]rNcCstdtttfS)aGet the default columns used for a new Progress instance: - a text column for the description (TextColumn) - the bar itself (BarColumn) - a text column showing completion percentage (TextColumn) - an estimated-time-remaining column (TimeRemainingColumn) If the Progress instance is created without passing a columns argument, the default columns defined here will be used. You can also create a Progress instance using custom columns before and/or after the defaults, as in this example: progress = Progress( SpinnerColumn(), *Progress.get_default_columns(), "Elapsed:", TimeElapsedColumn(), ) This code shows the creation of a Progress display, containing a spinner to the left, the default columns, and a labeled elapsed time column. r)rrrr)rrKrKrLr]Ys zProgress.get_default_columnsr,cCs|jjSrW)rSr}rZrKrKrLr}xszProgress.consolez List[Task]cCs8|jt|jWdS1s*0YdS)zGet a list of Task instances.N)rJlistr^valuesrZrKrKrLtasks|szProgress.tasksz List[TaskID]cCs8|jt|jWdS1s*0YdS)zA list of task IDs.N)rJrbr^keysrZrKrKrLtask_idsszProgress.task_idscCsX|j>|jsWddStdd|jDWdS1sJ0YdS)z'Check if all tasks have been completed.NTcss|] }|jVqdSrW)r)rQrrKrKrLrSrHz$Progress.finished..)rJr^allrcrZrKrKrLrszProgress.finishedcCs|js|jjdddS)zStart the progress display.T)rPN)rrSrYrZrKrKrLrYszProgress.startcCs(|j|jjs$|jjs$|jdS)zStop the progress display.N)rSrr}Zis_interactiveZ is_jupyterr`rZrKrKrLrs z Progress.stopr(cCs ||SrWrXrZrKrKrLr[szProgress.__enter__r\r]r^r_cCs |dSrW)rrerKrKrLrfszProgress.__exit__rrlrrrsrurvzOptional[TaskID]rt)ryr{rErArzrBrOc cs|durtt|pd}|dur2|j|||d}n|j|||d|jjrt|||.}|D]}|V|jd7_q\Wdq1s0Yn,|j} |j } |D]}|V| |d| qdS)aCTrack progress by iterating over a sequence. You can also track progress of an iterable, which might require that you additionally specify ``total``. Args: sequence (Iterable[ProgressType]): Values you want to iterate over and track progress. total: (float, optional): Total number of steps. Default is len(sequence). completed (int, optional): Number of steps completed so far. Defaults to 0. task_id: (TaskID): Task to track. Default is new task. description: (str, optional): Description of task, if new task is created. update_period (float, optional): Minimum time (in seconds) between calls to update(). Defaults to 0.1. Returns: Iterable[ProgressType]: An iterable of values taken from the provided sequence. NrKr)) r?radd_taskrUrSr|r=rErQrP) rHryr{rErArzrBZ track_threadvaluerQrPrKrKrLrs 0 zProgress.trackr)rArzrr)rr{rArzrOcCsd}|dur|}n:|durL|j|j|j}Wdn1sB0Y|dur\td|durt|j||d}n|j||dt|||ddS)ajTrack 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)rJr^r{ ValueErrorrhrUr)rHrr{rArz total_bytesrKrKrLrs*zProgress.wrap_filer)r{rArzrrr) rrrrrrr{rArzrOc CsdSrWrK rHrrrrrrr{rArzrKrKrLrsz Progress.openz"Union[Literal['r'], Literal['rt']]r#c CsdSrWrKrnrKrKrLrsrrzUnion[BinaryIO, TextIO]cCsdt|dd} | dvr(td||dk} | dkrR|dkrRtdtd }n&| d vrx|d krltd n |dkrxd }|d urt|j}|d ur|j| |d}n|j ||dt j |d|d} t | ||dd} |dvrt 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. rF)reverse)brrtrz invalid mode r)rpzaline buffering (buffering=1) isn't supported in binary mode, the default buffer size will be usedr)rqrrzcan't have unbuffered text I/ONrjrb)rTrk)rrq)rrrline_buffering)rdsortedrlwarningswarnRuntimeWarningrst_sizerhrUiorr TextIOWrapper)rHrrrrrrr{rArz_modersrrrKrKrLrs>!  r:)rArOcCsH|j.|j|}|jdur&||_Wdn1s:0YdS)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)rJr^rDr)rHrArrKrKrL start_taskks   zProgress.start_taskcCsR|j8|j|}|}|jdur*||_||_Wdn1sD0YdS)zStop a task. This will freeze the elapsed time on the task. Args: task_id (TaskID): ID of task. N)rJr^rrDrE)rHrArrrKrKrL stop_taskys   zProgress.stop_task)r{rErQrzr>rPzOptional[bool]r) rAr{rErQrzr>rPr@rOcKs@|j|j|} | j} |dur:|| jkr:|| _| |durP| j|7_|dur^|| _|durl|| _|durz|| _| j|| j| } | } | |j } | j }|j }|r|dj | kr|q| dkr|t| | | jdur| j| jkr| jdur| j| _Wdn1s$0Y|r<|dS)aUpdate 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)rJr^rEr{rVrzr>r@rUrrXrIpopleftrappendr:rrrP)rHrAr{rErQrzr>rPr@rcompleted_startupdate_completedrold_sample_timerIr~rKrKrLrUsB      (zProgress.update)rYr{rEr>rz)rArYr{rEr>rzr@rOc Ks|}|jp|j|} | |r*|nd| _|dur>|| _|| _|durR|| _|r\|| _|durj|| _ d| _ Wdn1s0Y| dS)aReset 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) rrJr^rVrDr{rEr>r@rzrrP) rHrArYr{rEr>rzr@rrrKrKrLresets  $zProgress.resetr))rArQrOc Cs|}|j|j|}|j}|j|7_|j|}||j}|j}|j} |rh|dj|krh| qNt|dkr|| qh| t |||j dur|j|j kr|j dur|j |_ |j|_Wdn1s0YdS)zAdvance task by a number of steps. Args: task_id (TaskID): ID of task. advance (float): Number of steps to advance. Default is 1. rrN)rrJr^rErXrIr~rrrr:r{rrrr ) rHrArQrrrrrrIr~rKrKrLrQs,     zProgress.advancecCs|js|jjr|jdS)z*Refresh (render) the progress information.N)rrSrTrPrZrKrKrLrP szProgress.refreshr/cCst|}|S)z*Get a renderable for the progress display.)r-get_renderables)rHrrKrKrLr\s zProgress.get_renderablezIterable[RenderableType]ccs||j}|VdS)z5Get a number of renderables for the progress display.N)make_tasks_tablerd)rHtablerKrKrLrs zProgress.get_renderableszIterable[Task]r7)rdrOcsRdd|jD}tj|d|jd}|D]$jr(|jfdd|jDq(|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. css.|]&}t|trtddn |VqdS)TrN)rrtr6rcopy)rQZ_columnrKrKrLrS"s z,Progress.make_tasks_table..)rr))paddingr[c3s,|]$}t|tr|jdn|VqdS)rN)rrtr)rQcolumnrrKrLrS/s)rr7Zgridr[r>add_row)rHrdZ table_columnsrrKrrLrs   zProgress.make_tasks_tablecCs2|j|WdS1s$0YdS)z+Makes the Progress class itself renderable.N)rJr\rZrKrKrL__rich__:szProgress.__rich__rN)rzrYr{rEr>r@rOc Ks|jdt|j||||||j|jd}||j|j<|rB||j|j}tt|jd|_Wdn1sp0Y||S)aAdd 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=rJr)N) rJr;r_rr^r|r:rvrP) rHrzrYr{rEr>r@rZnew_task_indexrKrKrLrh?s$  2zProgress.add_taskcCs2|j|j|=Wdn1s$0YdS)z]Delete a task if it exists. Args: task_id (TaskID): A task ID. N)rJr^)rHrArKrKrL remove_taskjszProgress.remove_task)NrNrlrr)N)rNNN)rNNN)rrNNN)r))TrNrT)!rgrhrirjrGr!r]rr}rdrfrrYrr[rfrrtypingoverloadrr|r}rUrrQrPr\rrrrhrrKrKrKrLr%s($ 0* & & $M"A '!+r__main__)Panel)Rule)Syntax)r7a~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)Z line_numbersZfoobarZbaz123z:Text may be printed while the progress bars are rendering.z(In fact, [i]any[/i] renderable will workzSuch as [magenta]tables[/]...zPretty printed structures...ZexamplezPretty printed)typerz Syntax...zGive it a try!)cycle)record)r}r~z[red]Downloadingrrjz[green]Processingz[yellow]Thinkingr"rg333333?g{Gz?d)rlNrTNFNrmrnrorprqrrFT)rNNN)rNNN)rrNNN) __future__rryrruabcrr collectionsrZ dataclassesrrdatetimer r r mathr r operatorrosrr threadingrrrtypesrrrrrrrrrrrrr r!r"r#r$r%r&r'Ztyping_extensionsr(rr*r+r}r,r-r.r/rr0Zjupyterr1rSr2 progress_barr3rr4rr5rr6r7rr8r9rvr:r;r?r<r<r=rrrrrrrrrrrrrrr,r1r2rr9r:r;rrgrandomtimeZpanelrZrulerZsyntaxrrZprogress_renderables itertoolsrZexamplesr]r@rhZtask1Ztask2Ztask3rrUsleeprandintrarrKrKrKrLsv       T         *0Ng,A886V*2* H0  1  }T