a )j@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:rxrM)handler@task close_handlerOcCs"||_||_||_||_d|_dSNF)rr@rr_closed)rHrr@rrrKrKrLrGs z_Reader.__init__z '_Reader'rNcCs|j|SrX)rr\r[rKrKrLr\s z_Reader.__enter__r]r^r_r`cCs |dSrX)closerfrKrKrLrgsz_Reader.__exit__cCs|SrXrKr[rKrKrL__iter__sz_Reader.__iter__bytescCs$t|j}|jj|jt|d|SNrQ)nextrr@rQrlen)rHlinerKrKrL__next__s z_Reader.__next__cCs|jSrX)rr[rKrKrLclosedsz_Reader.closedrwcCs |jSrX)rfilenor[rKrKrLrsz_Reader.filenocCs |jSrX)risattyr[rKrKrLrsz_Reader.isattyrucCs|jjSrX)rmoder[rKrKrLrsz _Reader.modecCs|jjSrX)rnamer[rKrKrLrsz _Reader.namecCs |jSrX)rreadabler[rKrKrLrsz_Reader.readablecCs |jSrX)rseekabler[rKrKrLrsz_Reader.seekablecCsdSrrKr[rKrKrLwritablesz_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)rrrrr[rKrKrLr s z _Reader.closer)offsetwhencerOcCs$|j||}|jj|j|d|S)NrE)rseekr@rUr)rHrrposrKrKrLrsz _Reader.seekcCs |jSrX)rtellr[rKrKrLrsz _Reader.tellr)srOcCs tddS)Nwriter )rHrrKrKrLrsz _Reader.writez Iterable[Any])rrOcCs tddS)N writelinesr)rHrrKrKrLrsz_Reader.writelinesN)T)r)r)r)r)rhrirjrkrGr\rgrrpropertyrrrrrrrrrrrrrrrrrrKrKrKrLrs6 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||_||_dSrX)r@r)rHr@rrKrKrLrG sz_ReadContext.__init__rNcCs|j|jSrX)r@rZrr\r[rKrKrLr\$s z_ReadContext.__enter__r]r^r_r`cCs|j|j|||dSrX)r@stoprrgrfrKrKrLrg(s z_ReadContext.__exit__N)rhrirjrkrGr\rgrKrKrKrLrsr Reading...) r{r}r~rrrrrrrrrzContextManager[BinaryIO])filer|r{r}r~rrrrrrrrrOc  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. rrrnr)r|r{)rrrDownloadColumnrr wrap_filer)rr|r{r}r~rrrrrrrrrr@rrKrKrLr2s0%  rr) r|r{r}r~rrrrrrrr"Union[str, 'PathLike[str]', bytes]z"Union[Literal['rt'], Literal['r']] Optional[str] Optional[int]zContextManager[TextIO])rr bufferingencodingerrorsnewliner|r{r}r~rrrrrrrrrOc CsdSrXrKrrrrrrr|r{r}r~rrrrrrrrrKrKrLopenssr Literal['rb']c CsdSrXrKrrKrKrLrsr1Union[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. rrrnr)rrrrrr|r{)rrrrrrrr)rrrrrrr|r{r}r~rrrrrrrrrr@rrKrKrLrsB1   c@sbeZdZUdZdZded<dddddd Zd d d d ZdddddZe dddddZ dS)ProgressColumnz3Base class for a widget to use in progress display.Nrv max_refreshOptional[Column]rM) table_columnrOcCs||_i|_d|_dSrX) _table_column_renderable_cache _update_time)rHrrKrKrLrGszProgressColumn.__init__r6rNcCs |jp tS)z.Get a table column, used to build tasks table.)rr6r[rKrKrLget_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) rhrirjrkr__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|jSrX)rrrKrKrLr2szRenderableColumn.render)rrhrirjrkrGrrlrKrKrIrLr%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? NruzOptional[StyleType]r?r9r) spinner_namerspeed finished_textrcs<t|||d|_t|tr$t|n||_tj|ddS)Nrrr) r4spinner isinstancerur8 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|}|SrX)finishedrrrr)rHrtextrKrKrLr_s zSpinnerColumn.render)rrrrN)rr)rhrirjrkrGrrrlrKrKrIrLr6s rc sDeZdZdZddddd d d d d fdd ZdddddZZS)rzA column containing text.noneleftTNrur5r.rxOptional[Highlighter]rrM) text_formatrjustifymarkup highlighterrrOcs:||_||_||_||_||_tj|p0tddddS)NTno_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". (rorprqrrNrr5rrM) 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|rEwidthpulseanimation_timerrrr) r3r|maxrEr startedrrrrrrrKrKrLrs zBarColumn.render)r rorprqrrNrrKrKrIrLrs  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 rrwru)rHrrdeltarKrKrLrs  zTimeElapsedColumn.renderNrhrirjrkrrKrKrKrLrsrc 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}%rrrTNFrur5r.rxrrrM) rtext_format_no_percentagerrrrrrrOc s(||_||_tj||||||ddS)N)rrrrrr)rrrFrG) rHrrrrrrrrrIrKrLrGs zTaskProgressColumn.__init__rvr8)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_suffixrw)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|rr$finished_speedrrrr rr8rrrrr )rHrrr rrKrKrLrs  zTaskProgressColumn.render)rrrrTNNF) rhrirjrkrG classmethodr$rrlrKrKrIrLrs$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. ?FNrxr)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<02d:d) rrrtime_remainingr|r8r(divmodrw)rHr task_timerminutesrhours formattedrKrKrLrs    zTimeRemainingColumn.render)FFN)rhrirjrkrrGrrlrKrKrIrLrs rc@s eZdZdZdddddZdS)FileSizeColumnzRenders completed filesize.rr8rcCstt|j}t|ddS)Show data completed.zprogress.filesizer)r*decimalrwrEr8rHr data_sizerKrKrLr7szFileSizeColumn.renderNrrKrKrKrLr34sr3c@s eZdZdZdddddZdS)TotalFileSizeColumnzRenders total filesize.rr8rcCs*|jdurtt|jnd}t|ddS)r4Nrzprogress.filesize.totalr)r|r*r5rwr8r6rKrKrLr@szTotalFileSizeColumn.renderNrrKrKrKrLr8=sr8cs: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 "/". /Nrur) separatorrcs||_tj|ddSr)r;rFrG)rHr;rrIrKrLrGRszMofNCompleteColumn.__init__rr8rcCsPt|j}|jdurt|jnd}tt|}t||d|j|ddS)zShow completed/total.N?r,progress.downloadr)rwrEr|rrur8r;)rHrrEr| total_widthrKrKrLrVs  zMofNCompleteColumn.render)r:NrrKrKrIrLr9Fs r9cs<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. FNrxrrM) binary_unitsrrOcs||_tj|ddSr)r?rFrG)rHr?rrIrKrLrGhszDownloadColumn.__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) rKiBMiBGiBTiBPiBEiBZiBYiBi) rkBMBGBTBPBEBZBYBrr)rz,.fr<r:rr=r)rwrEr|r?r*rr8)rHrrE unit_and_suffix_calculation_baser!r" precisioncompleted_ratio completed_strr| total_ratio total_strdownload_status download_textrKrKrLrns2     zDownloadColumn.render)FNrrKrKrIrLrasrc@s eZdZdZdddddZdS)TransferSpeedColumnz&Renders human readable transfer speed.rr8rcCs@|jp |j}|dur tdddStt|}t|dddS)zShow data transfer speed.Nr<zprogress.data.speedrz/s)r%rr8r*r5rw)rHrrr#rKrKrLrs   zTransferSpeedColumn.renderNrrKrKrKrLrYsrYc@s"eZdZUdZded<ded<dS)ProgressSamplez$Sample of progress for a given time.r?rrEN)rhrirjrkrrKrKrKrLrZs rZc@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:rrur{rvr|r?rEGetTimeCallable _get_timeNrTrxvisible)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]r[rKrKrLrsz Task.get_timecCs |jduS)z#bool: Check if the task as started.N)rdr[rKrKrLrsz Task.startedcCs|jdurdS|j|jS)zPOptional[float]: Get the number of steps remaining, if a non-None total was set.Nr|rEr[rKrKrL 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)rdrerr[rKrKrLrs    z Task.elapsedcCs |jduS)zCheck if the task has finished.N)rr[rKrKrLrsz 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|] }|jVqdSrXr).0samplerKrKrL rhzTask.speed..)rdrjririterrr)rHr@ total_time iter_progresstotal_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 )rHrrlestimaterKrKrLr-s zTask.time_remainingrMcCs|jd|_d|_dS)zReset progress.N)riclearrr%r[rKrKrL_resets z Task._reset)rhrirjrkrrr^rdictr`rdrer%rirrjrrrrlrrrprr-rzrKrKrKrLr[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)~radRenders 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 (float, optional): Number of times per second to refresh the progress information. Defaults to 10. 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. NTrng>@F) r~r}rspeed_estimate_periodrredirect_stdoutredirect_stderrrrexpandzUnion[str, ProgressColumn]ryrxr?zOptional[GetTimeCallable]rM) rr~r}rr|rr}r~rrrrOc Gs|dksJdt|_| p"||_||_| |_| |_i|_td|_ t |pRt ||||||j d|_ |pr|jj|_|jj|_|jj|_dS)Nrzrefresh_per_second must be > 0)r~r}rrr}r~get_renderable)rrjget_default_columnsrr|rr_tasksr: _task_indexr2r+rrSr~rprintlog) rHr~r}rr|rr}r~rrrrrKrKrLrG5s(   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)r rKrKrLrYs zProgress.get_default_columnsr,cCs|jjSrX)rSr~r[rKrKrLr~xszProgress.consolez List[Task]cCs8|jt|jWdS1s*0YdS)zGet a list of Task instances.N)rjlistrvaluesr[rKrKrLtasks|szProgress.tasksz List[TaskID]cCs8|jt|jWdS1s*0YdS)zA list of task IDs.N)rjrrkeysr[rKrKrLtask_idsszProgress.task_idscCsX|j>|jsWddStdd|jDWdS1sJ0YdS)z'Check if all tasks have been completed.NTcss|] }|jVqdSrX)r)rqrrKrKrLrsrhz$Progress.finished..)rjrallrr[rKrKrLrszProgress.finishedcCs|js|jjdddS)zStart the progress display.T)rPN)rrSrZr[rKrKrLrZszProgress.startcCs.|js*|j|jjs*|jjs*|jdS)zStop the progress display.N)rrSrr~is_interactive is_jupyterrr[rKrKrLrs z Progress.stopr(cCs ||SrXrYr[rKrKrLr\szProgress.__enter__r]r^r_r`cCs |dSrX)rrfrKrKrLrgszProgress.__exit__rrmrsrtrvrwzOptional[TaskID]ru)rzr|rErAr{rBrOc 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) rHrzr|rErAr{rB track_threadvaluerQrPrKrKrLrs 0 zProgress.trackr)rAr{rr)rr|rAr{rOcCsd}|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)rjrr| ValueErrorrrUr)rHrr|rAr{ total_bytesrKrKrLrs*zProgress.wrap_filer)r|rAr{rrr) rrrrrrr|rAr{rOc CsdSrXrK rHrrrrrrr|rAr{rKrKrLrsz Progress.openz"Union[Literal['r'], Literal['rt']]r#c CsdSrXrKrrKrKrLrsrrzUnion[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)rzaline buffering (buffering=1) isn't supported in binary mode, the default buffer size will be usedr)rrrzcan't have unbuffered text I/ONrrb)rTr)rr)rrrline_buffering)resortedrwarningswarnRuntimeWarningrst_sizerrUiorr TextIOWrapper)rHrrrrrrr|rAr{_moderrrrKrKrLrs>!  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)rjrrdr)rHrArrKrKrL start_taskls   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)rjrrrdre)rHrArrrKrKrL stop_taskzs   zProgress.stop_task)r|rErQr{r^rPzOptional[bool]r) rAr|rErQr{r^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)rjrrEr|rzr{r^r`rUrr|ripopleftrappendrZrrrP)rHrAr|rErQr{r^rPr`rcompleted_startupdate_completedrold_sample_timerirrKrKrLrUsB      (zProgress.update)rZr|rEr^r{)rArZr|rEr^r{r`rOc Ks|}|jp|j|} | |r*|nd| _|dur>|| _|| _|durR|| _|r\|| _|durj|| _ d| _ Wdn1s0Y| dS)axReset 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): Set visible flag if not None. description (str, optional): Change task description if not None. Defaults to None. **fields (str): Additional data fields required for rendering. N) rrjrrzrdr|rEr^r`r{rrP) rHrArZr|rEr^r{r`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)rrjrrEr|rirrrrrZr|rrrr%) rHrArQrrrrrrirrKrKrLrQs,     zProgress.advancecCs|js|jjr|jdS)z*Refresh (render) the progress information.N)rrSrTrPr[rKrKrLrP szProgress.refreshr/cCst|}|S)z*Get a renderable for the progress display.)r-get_renderables)rHrrKrKrLrs zProgress.get_renderablezIterable[RenderableType]ccs||j}|VdS)z5Get a number of renderables for the progress display.N)make_tasks_tabler)rHtablerKrKrLrs zProgress.get_renderableszIterable[Task]r7)rrOcsRdd|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)rrur6rcopy)rq_columnrKrKrLrs#s z,Progress.make_tasks_table..)rr))paddingrc3s,|]$}t|tr|jdn|VqdS)rN)rrur )rqcolumnrrKrLrs0s)rr7gridrr^add_row)rHr table_columnsrrKrrLrs   zProgress.make_tasks_tablecCs2|j|WdS1s$0YdS)z+Makes the Progress class itself renderable.N)rjrr[rKrKrL__rich__;szProgress.__rich__rn)r{rZr|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[rrrrr:rwrP) rHr{rZr|rEr^r`rnew_task_indexrKrKrLr@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_taskkszProgress.remove_task)NrNrmrs)N)rNNN)rNNN)rrNNN)r))TrnrT)!rhrirjrkrGr&rrr~rrrrZrr\rgrrtypingoverloadrrrrUrrQrPrrrrrrrKrKrKrLr%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) 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~rz[red]Downloadingrrz[green]Processingz[yellow]Thinkingr'rg333333?g{Gz?d)rmNrTNFNrnrorprqrrrsFT)rNNN)rNNN)rrNNN) __future__rrrrabcrr collectionsr dataclassesrrdatetimer r r mathr r operatorrosrr threadingrrrtypesrrrrrrrrrrrrr r!r"r#r$r%r&r'Ztyping_extensionsr(rr*r+r~r,r-r.r/rr0jupyterr1rSr2 progress_barr3rr4rr5rr6r7rr8r9rwr:r;r?r\r<r=rrrrrrrrrrrrrrr3r8r9rrYrZr[rrhrandomtimepanelrrulersyntaxrrZprogress_renderables itertoolsrZexamplesrr@rZtask1Ztask2Ztask3rrUsleeprandintrrrKrKrKrLsv       T         *0Ng,A886V*2* H0  1  }U