o Rh+@s*ddlZddlZddlZddlZddlmZmZddlmZddl m Z m Z ddl m Z ddlmZmZddlmZddlmZdd lmZdd lmZmZdd lmZmZmZdd lmZdd lmZmZm 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/ej0dkrddlm1Z1nddl2m1Z1ej0dkrddlm3Z3nddl2m3Z3ddl4m5Z5m6Z6ddl7m8Z8m9Z9m:Z:m;Z;ddlm?Z?ddl@mAZAddlBmCZCddlDmEZEddlFmGZGddlHmIZImJZJddlKmLZLmMZMe(deNZOe.dZPe geQfZRe.de+eZSGd d!d!eZT "  #  $  % & ' ( ) * $ #dd+e/e*ePe%ePfd,eUd-e)eQd.eNd/eVd0e)e8d1eVd2e)e geQfd3eQd4eGd5eGd6eGd7eGd8eQd9eVd:eVd;e%ePf"dd?d?eeZXGd@dAdAe!eSe$eSZYdBd#dd$dd%d&d'd(d)d$dC dDed-eNd,eUd/eVd0e)e8d1eVd2e)e geQfd3eQd4eGd5eGd6eGd7eGd9eVd;e!efdEdFZZej[ G   dddBd#dd$dd%d&d'd(d)d$dH dDe/eUdIe\fdJe/e1dKe1dLfdMeNdNe)eUdOe)eUdPe)eUd-e)eNd,eUd/eVd0e)e8d1eVd2e)e geQfd3eQd4eGd5eGd6eGd7eGd9eVd;e!e+f&dQdRZ]ej[ G   dddBd#dd$dd%d&d'd(d)d$dH dDe/eUdIe\fdJe1dSdMeNdNe)eUdOe)eUdPe)eUd-e)eNd,eUd/eVd0e)e8d1eVd2e)e geQfd3eQd4eGd5eGd6eGd7eGd9eVd;e!ef&dTdRZ] L G   dddBd#dd$dd%d&d'd(d)d$dH dDe/eUdIe\fdJe/e1dSe1dKe1dLfdMeNdNe)eUdOe)eUdPe)eUd-e)eNd,eUd/eVd0e)e8d1eVd2e)e geQfd3eQd4eGd5eGd6eGd7eGd9eVd;e/e!ee!e+ff&dUdRZ]GdVdWdWeZ^GdXdYdYe^Z_GdZd[d[e^Z`Gd\d]d]e^ZaGd^d_d_e^ZbGd`dadae^ZcGdbdcdceaZdGdddedee^ZeGdfdgdge^ZfGdhdidie^ZgGdjdkdke^ZhGdldmdme^ZiGdndodoe^ZjGdpdqdqe'Zke GdrdsdsZlGdtdudue?ZmendvkrddloZoddlpZpddwlqmrZrddxlsmtZtddylumvZvddzlHmJZJevd{d|d#d}ZueJd~ddZHeHwdddderddeHdddddeuetdg ZxddlymzZzezexZ{e8d#dZ7eme`gem|ecRe7d$dQZ}e}j~dddZe}j~dddZe}j~dddZe}jse}jedde}jeddepdeodddkre}ee{e}jrWddSWddS1s wYdSdS)N)ABCabstractmethoddeque) dataclassfield) timedelta) RawIOBaseUnsupportedOperation)ceil)mmap) length_hint)PathLikestat)EventRLockThread) TracebackType)AnyBinaryIOCallableContextManagerDequeDictGenericIterableList NamedTupleNewTypeOptionalSequenceTextIOTupleTypeTypeVarUnion))Literal)r& )Self)filesize get_console)ConsoleGroup JustifyMethodRenderableType) Highlighter) JupyterMixin)Live) ProgressBar)Spinner) StyleType)ColumnTable)TextTextTypeTaskID ProgressType_IcsleZdZdZdddddeffdd Zdd d Zdd dZdee e dee dee d d fddZ Z S) _TrackThreadz)A thread to periodically update progress.progressProgresstask_idr< update_periodcs2||_||_||_t|_d|_tjdddS)NrT)daemon)r@rBrCrdone completedsuper__init__)selfr@rBrC __class__O/home/air/sanwanet/backup_V2/venv/lib/python3.10/site-packages/rich/progress.pyrHGs z_TrackThread.__init__returnNcCs~|j}|jj}|j}d}|jj}||s2|jjjr2|j}||kr)|||||}||s2|jjjs|jj |j|jdddS)NrT)rFrefresh) rBr@advancerCrEwaitlive is_startedrFupdate)rIrBrPrClast_completedrQrFrLrLrMrunPsz_TrackThread.runcC ||SNstartrIrLrLrM __enter__^z_TrackThread.__enter__exc_typeexc_valexc_tbcCs|j|dSrX)rEsetjoinrIr^r_r`rLrLrM__exit__bs  z_TrackThread.__exit__rNN)rNr?)__name__ __module__ __qualname____doc__floatrHrVr\rr# BaseExceptionrrd __classcell__rLrLrJrMr?Ds  r? Working...TF bar.back bar.complete bar.finished bar.pulse皙?sequence descriptiontotalrF auto_refreshconsole transientget_timerefresh_per_secondstylecomplete_stylefinished_style pulse_stylerCdisable show_speedrNc cs|rtdgng}|t| | | | dt|dtddft||||||p'd|d}||j||||| dEd HWd d S1sGwYd S) a=Track progress by iterating over a sequence. Args: sequence (Iterable[ProgressType]): A sequence (must support "len") you wish to iterate over. description (str, optional): Description of task show next to progress bar. Defaults to "Working". total: (float, optional): Total number of steps. Default is len(sequence). completed (int, optional): Number of steps completed so far. Defaults to 0. 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}r|r}r~r)rT)elapsed_when_finishedrnrwrxryrzr{r)rvrFrurCN) TextColumnextend BarColumnTaskProgressColumnTimeRemainingColumnrAtrack)rtrurvrFrwrxryrzr{r|r}r~rrCrrcolumnsr@rLrLrMrls@*  "rc @seZdZdZ dBdedddededd f d d ZdCd d Zde e e de e de e dd fddZ defddZdefddZedefddZdefddZdefddZedefddZedefdd Zdefd!d"Zdefd#d$Zdefd%d&ZdDd(edefd)d*Zd+eeee ffd,d-Z!dDd(edefd.d/Z"dDd0ede#efd1d2Z$dEd3d4Z%dFd6ed7edefd8d9Z&defd:d;Z'dZ)d?e*e(dd fd@dAZ+d S)G_Readerz9A reader that tracks progress while it's being read from.Thandler@rAtask close_handlerNNcCs"||_||_||_||_d|_dSNF)rr@rr_closed)rIrr@rrrLrLrMrHs  z_Reader.__init__cCs|j|SrX)rr\r[rLrLrMr\s z_Reader.__enter__r^r_r`cC |dSrX)closercrLrLrMrd z_Reader.__exit__cCs|SrXrLr[rLrLrM__iter__z_Reader.__iter__cCs$t|j}|jj|jt|d|SNrP)nextrr@rPrlen)rIlinerLrLrM__next__s z_Reader.__next__cC|jSrX)rr[rLrLrMclosedsz_Reader.closedcC |jSrX)rfilenor[rLrLrMr z_Reader.filenocCrrX)risattyr[rLrLrMrrz_Reader.isattycC|jjSrX)rmoder[rLrLrMrz _Reader.modecCrrX)rnamer[rLrLrMrrz _Reader.namecCrrX)rreadabler[rLrLrMrrz_Reader.readablecCrrX)rseekabler[rLrLrMrrz_Reader.seekablecCdSrrLr[rLrLrMwritablerz_Reader.writablesizecC&|j|}|jj|jt|d|Sr)rreadr@rPrr)rIrblockrLrLrMr z _Reader.readbcCs"|j|}|jj|j|d|Sr)rreadintor@rPr)rIrnrLrLrMrs z_Reader.readintocCrr)rreadliner@rPrr)rIrrrLrLrMrrz_Reader.readlinehintcCs,|j|}|jj|jttt|d|Sr)r readlinesr@rPrsummapr)rIrlinesrLrLrMrs z_Reader.readlinescCs|jr|jd|_dS)NT)rrrrr[rLrLrMr s  z _Reader.closeroffsetwhencecCs$|j||}|jj|j|d|S)NrF)rseekr@rTr)rIrrposrLrLrMrsz _Reader.seekcCrrX)rtellr[rLrLrMrrz _Reader.tellscCtd)Nwriter )rIrrLrLrMrz _Reader.writercCr)N writelinesr)rIrrLrLrMrrz_Reader.writelines)T)rNr)rre)r),rfrgrhrirr<boolrHr\rr#rkrrdrbytesrpropertyrintrrstrrrrrrrr% bytearray memoryviewr rrrrrrrrrrrrLrLrLrMrs\    rc@s^eZdZdZdddeddfddZdefd d Zd eee d ee d ee ddfddZ dS) _ReadContextzEA utility class to handle a context for both a reader and a progress.r@rAreaderrNNcCs||_||_dSrX)r@r)rIr@rrLrLrMrH"s z_ReadContext.__init__cCs|j|jSrX)r@rZrr\r[rLrLrMr\&s  z_ReadContext.__enter__r^r_r`cCs|j|j|||dSrX)r@stoprrdrcrLrLrMrd*s z_ReadContext.__exit__) rfrgrhrir>rHr\rr#rkrrdrLrLrLrMrs r Reading...) rurwrxryrzr{r|r}r~rrfilec  Csh|rtdgng} | t|| | | dttft| |||||p"d| 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)rvru)rrrDownloadColumnrrA wrap_filer)rrvrurwrxryrzr{r|r}r~rrrr@rrLrLrMr4s0%  rr) rvrurwrxryrzr{r|r}r~rr PathLike[str]rrtr bufferingencodingerrorsnewlinec CdSrXrLrrrrrrrvrurwrxryrzr{r|r}r~rrrLrLrMopenurrbc CrrXrLrrLrLrMrrc  Csr|rtdgng}|t| |||dttft||| | | | p"d|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)rrrrrrvru)rrrrrrArr)rrrrrrrvrurwrxryrzr{r|r}r~rrrr@rrLrLrMrsB1   c@speZdZUdZdZeeed<ddeeddfddZ defdd Z d d de fd d Z e d d de fddZdS)ProgressColumnz3Base class for a widget to use in progress display.N max_refresh table_columnrNcCs||_i|_d|_dSrX) _table_column_renderable_cache _update_time)rIrrLrLrMrHs zProgressColumn.__init__cCs |jptS)z.Get a table column, used to build tasks table.)rr8r[rLrLrMget_table_columns zProgressColumn.get_table_columnrTaskcCsp|}|jdur)|js)z |j|j\}}Wn tyYn w||j|kr)|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)rzrrFridKeyErrorrender)rIr current_time timestamp renderablerLrLrM__call__ s   zProgressColumn.__call__cCr)z"Should return a renderable object.NrLrIrrLrLrMr"szProgressColumn.renderrX)rfrgrhrirrrj__annotations__r8rHrr1rrrrLrLrLrMrs rcsJeZdZdZ ddddedeeffddZd d d efd d ZZ S)RenderableColumnzA column to insert an arbitrary column. Args: renderable (RenderableType, optional): Any renderable. Defaults to empty string. Nrrrc||_tj|ddSNr)rrGrH)rIrrrJrLrMrH.zRenderableColumn.__init__rrrNcCrrX)rrrLrLrMr4szRenderableColumn.render)r) rfrgrhrir1rr8rHrrlrLrLrJrMr'src seZdZdZ     ddedeed ed ed ee f fd d Z  ddedeed eddfddZ ddde fddZ ZS) 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? N spinner_namer|speed finished_textrcs<t|||d|_t|trt|n||_tj|ddS)Nr|rr) r6spinner isinstancerr: from_markuprrGrH)rIrr|rrrrJrLrMrHBs  zSpinnerColumn.__init__ spinner_stylerNcCst|||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)r6r)rIrrrrLrLrM set_spinnerRs zSpinnerColumn.set_spinnerrrcCs$|jr|j}|S|j|}|SrX)finishedrrrrz)rIrtextrLrLrMraszSpinnerColumn.render)rrrrN)rr)rfrgrhrirrr7rjr;r8rHrr1rrlrLrLrJrMr8s<  rcsdeZdZdZ     ddededed ed ee d ee d dffd d Z ddd e fddZ ZS)rzA column containing text.noneleftTN text_formatr|justifymarkup highlighterrrNcs:||_||_||_||_||_tj|ptddddS)NTno_wrapr)r r r|r r rGrHr8)rIr r|r r r rrJrLrMrHms  zTextColumn.__init__rrcCsR|jj|d}|jrtj||j|jd}n t||j|jd}|jr'|j||SNr)r|r ) r formatr r:rr|r r  highlight)rIr_textrrLrLrMr}s zTextColumn.render)rr TNN)rfrgrhrirr7r0rrr2r8rHr:rrlrLrLrJrMrjs.rcsfeZdZdZ      ddeed ed ed ed ed eeddffdd Zddde fddZ Z S)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". (rorprqrrN bar_widthr|r}r~rrrNcs0||_||_||_||_||_tj|ddSr)rr|r}r~rrGrH)rIrr|r}r~rrrJrLrMrHs  zBarColumn.__init__rrc Cs^t|jdur td|jndtd|j|jdurdntd|j|j ||j|j|j |j d S)z&Gets a progress bar widget for a task.Nrr+) rvrFwidthpulseanimation_timer|r}r~r) r5rvmaxrFrstartedrzr|r}r~rrrLrLrMrs zBarColumn.render)rrorprqrrN) rfrgrhrirrr7r8rHr5rrlrLrLrJrMrs0 rc@"eZdZdZdddefddZdS)TimeElapsedColumnzRenders time elapsed.rrrNcCsJ|jr|jn|j}|durtdddSttdt|d}tt|ddS)zShow time elapsed.N-:--:--progress.elapsedr|r)seconds)r finished_timeelapsedr:rrrr)rIrr#deltarLrLrMrs  zTimeElapsedColumn.renderNrfrgrhrir:rrLrLrLrMrrcseZdZdZ        dd ed ed ed ed edee dee deddffdd Z e dee defddZdddefddZZS)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}%rrr TNFr text_format_no_percentager|r r r rrrNc s(||_||_tj||||||ddS)N)r r|r r r r)r(rrGrH) rIr r(r|r r r rrrJrLrMrHs  zTaskProgressColumn.__init__rcCsN|dur tdddStt|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)r:r,pick_unit_and_suffixr)clsrunitsuffix data_speedrLrLrM render_speeds zTaskProgressColumn.render_speedrrcCs|jdur|jr||jp|jS|jdur|jn|j}|j|d}|jr0t j ||j |j d}n t ||j |j d}|j rB|j ||Sr)rvrr/finished_speedrr(r rr r:rr|r r r)rIrr rrrLrLrMrs  zTaskProgressColumn.render)r'rrr TNNF)rfrgrhrirr7r0rrr2r8rH classmethodrjr:r/rrlrLrLrJrMrs@  rcsPeZdZdZdZ   ddededeeffdd Zd d d e fd dZ Z S)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. ?FNcompactrrcs||_||_tj|ddSr)r3rrGrH)rIr3rrrJrLrMrHszTimeRemainingColumn.__init__rrrNcCs|jr |jr |j}d}n|j}d}|jdurtd|dS|dur.t|jr)d|dSd|dStt|d\}}t|d\}}|jrM|sM|d d |d }n |d d |d d |d }t||dS) zShow time remaining.rzprogress.remainingNrr z--:--r<02d:d) rrr"time_remainingrvr:r3divmodr)rIr task_timer|minutesr!hours formattedrLrLrMrs     zTimeRemainingColumn.render)FFN) rfrgrhrirrrr8rHr:rrlrLrLrJrMrs rc@r)FileSizeColumnzRenders completed filesize.rrrNcCstt|j}t|ddS)Show data completed.zprogress.filesizer )r,decimalrrFr:rIr data_sizerLrLrMr9s zFileSizeColumn.renderNr%rLrLrLrMr>6r&r>c@r)TotalFileSizeColumnzRenders total filesize.rrrNcCs*|jdur tt|jnd}t|ddS)r?Nrzprogress.filesize.totalr )rvr,r@rr:rArLrLrMrBs zTotalFileSizeColumn.renderNr%rLrLrLrMrC?r&rCcsBeZdZdZd dedeeffdd Zdd d efd d Z Z S)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 "/". /N separatorrcrr)rFrGrH)rIrFrrJrLrMrHTszMofNCompleteColumn.__init__rrrNcCsPt|j}|jdurt|jnd}tt|}t||d|j|ddS)zShow completed/total.N?r7progress.downloadr )rrFrvrrr:rF)rIrrFrv total_widthrLrLrMrXs  zMofNCompleteColumn.render)rEN) rfrgrhrirrr8rHr:rrlrLrLrJrMrDHs rDcsHeZdZdZ d dedeeddffdd Zd d defd d Z Z S)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. FN binary_unitsrrNcrr)rJrGrH)rIrJrrJrLrMrHjrzDownloadColumn.__init__rrcCst|j}|jdurt|jn|}|jr t|gdd\}}n t|gdd\}}|dkr1dnd}||}|d|d }|jdurVt|j} | |} | d|d } nd } |d | d |} t| d d} | S)z.Calculate common unit for completed and total.N) rKiBMiBGiBTiBPiBEiBZiBYiBi) rkBMBGBTBPBEBZBYBr)r+rz,.frGrErrHr )rrFrvrJr,r*r:)rIrrF unit_and_suffix_calculation_baser,r- precisioncompleted_ratio completed_strrv total_ratio total_strdownload_status download_textrLrLrMrps2     zDownloadColumn.render)FN) rfrgrhrirrr8rHr:rrlrLrLrJrMrcsrc@r)TransferSpeedColumnz&Renders human readable transfer speed.rrrNcCs@|jp|j}|durtdddStt|}t|dddS)zShow data transfer speed.NrGzprogress.data.speedr z/s)r0rr:r,r@r)rIrrr.rLrLrMrs  zTransferSpeedColumn.renderNr%rLrLrLrMrdr&rdc@s$eZdZUdZeed< eed<dS)ProgressSamplez$Sample of progress for a given time.rrFN)rfrgrhrirjrrLrLrLrMres rec@seZdZUdZeed< eed< eeed< eed< e ed< dZ eeed< d Z e ed < e ed Zeeefed < e dd d dZeeed< e dd d dZeeed< dZeeed< e ddd d dZeeed<e d edZeed< defddZede fddZedeefddZedeefdd Zede fd!d"Zedefd#d$Z edeefd%d&Z!edeefd'd(Z"d+d)d*Z#dS),rzInformation regarding a progress task. This object should be considered read-only outside of the :class:`~Progress` class. rrurvrF _get_timeNr"Tvisible)default_factoryfieldsF)defaultinitrepr start_time stop_timer0cCs tddS)Nr))maxlenrrLrLrLrMs z Task.)rhrkrl _progress)rlrh_lockrNcCs|S)z(float: Get the current time, in seconds.)rfr[rLrLrMrzrz Task.get_timecC |jduS)z#bool: Check if the task as started.N)rmr[rLrLrMr z Task.startedcCs|jdurdS|j|jS)zPOptional[float]: Get the number of steps remaining, if a non-None total was set.NrvrFr[rLrLrM 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)rmrnrzr[rLrLrMr#s   z Task.elapsedcCrs)zCheck if the task has finished.N)r"r[rLrLrMrrtz Task.finishedcCs.|jsdS|j|jd}tdtd|}|S)zOfloat: Get progress of task as a percentage. If a None total was set, returns 0Y@)rvrFminr)rIrFrLrLrM percentages zTask.percentagecCs|jdurdS|jD|j}|s WddS|dj|dj}|dkr0 WddSt|}t|tdd|D}||}|WdS1sQwYdS)z=Optional[float]: Get the estimated speed in steps per second.Nrrcs|]}|jVqdSrXr).0samplerLrLrM zTask.speed..)rmrrrqriterrr)rIr@ total_time iter_progresstotal_completedrrLrLrMrs" $z Task.speedcCs:|jrdS|j}|s dS|j}|durdSt||}|S)zJOptional[float]: Get estimated time to completion, or ``None`` if no data.rwN)rrrvr )rIrrvestimaterLrLrMr8s zTask.time_remainingcCs|jd|_d|_dS)zReset progress.N)rqclearr"r0r[rLrLrM_reset s  z Task._resetre)$rfrgrhrir<rrrrjGetTimeCallabler"rgrrdictrirrrmrnr0rqrrerrrrzrrrvr#rrzrr8rrLrLrLrMrsZ     rc@szeZdZdZddddddddddd deeefd eed e d e d e d e de de dee de de ddfddZ e deedffddZedefddZedeefddZedeefddZede fdd Zdmd!d"Zdmd#d$Zdefd%d&Zd'eeed(eed)eeddfd*d+Z  ,  - .dnd/ee e!e"e!fd0ee d1e#d2eed3ed4e de e!fd5d6Z$ dodd7d8d9e%d0ee#d2eed3ede%f d:d;Z&e'j( <   dpddd7d=d9eed>e)fd?e*d@dAe#dBeedCeedDeed0ee#d2eed3ede%fdEdFZ+e'j( <   dpddd7d=d9eed>e)fd?ee*dGe*dHfdAe#dBeedCeedDeed0ee#d2eed3ede,fdIdFZ+ G <   dqddd7d=d9eed>e)fd?ee*d@e*dHe*dGfdAe#dBeedCeedDeed0ee#d2eed3edee%e,ffdJdFZ+d2eddfdKdLZ-d2eddfdMdNZ.dddddddOd2ed0ee d1ee dPee d3eedQee dRe dSe/ddfdTdUZ0ddd,dddVd2edWe d0ee d1e#dQee d3eedSe/ddfdXdYZ1drd2edPe ddfd[d\Z2dmd]d^Z3de4fd_d`Z5de e4fdadbZ6dce ede7fdddeZ8de4fdfdgZ9  h , dsd3edWe d0ee d1e#dQe dSe/defdidjZ:d2eddfdkdlZ;dS)trAaRenders 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. NTrng>@F) rxrwr{speed_estimate_periodryredirect_stdoutredirect_stderrrzrexpandrrxrwr{rryrrrzrrrNc Gs|dksJdt|_| p||_||_| |_| |_i|_td|_ t |p)t ||||||j d|_ |p9|jj|_|jj|_|jj|_dS)Nrzrefresh_per_second must be > 0)rxrwr{ryrrget_renderable)rrrget_default_columnsrrrr_tasksr< _task_indexr4r-rrRrxrzprintlog) rIrxrwr{rryrrrzrrrrLrLrMrH7s(  zProgress.__init__.cCstdtttfS)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+rLrLrMr[s zProgress.get_default_columnscCrrX)rRrxr[rLrLrMrxzrzProgress.consolecC8|jt|jWdS1swYdS)zGet a list of Task instances.N)rrlistrvaluesr[rLrLrMtasks~ $zProgress.taskscCr)zA list of task IDs.N)rrrrkeysr[rLrLrMtask_idsrzProgress.task_idscCsZ|j |js WddStdd|jDWdS1s&wYdS)z'Check if all tasks have been completed.NTcsr{rX)r)r|rrLrLrMr~rz$Progress.finished..)rrrallrr[rLrLrMrs $zProgress.finishedcCs|js |jjdddSdS)zStart the progress display.T)rON)rrRrZr[rLrLrMrZszProgress.startcCs0|j|jjs|jjs|jdSdSdS)zStop the progress display.N)rRrrxis_interactive is_jupyterrr[rLrLrMrs z Progress.stopcCrWrXrYr[rLrLrMr\r]zProgress.__enter__r^r_r`cCrrX)rrcrLrLrMrdrzProgress.__exit__rrmrsrtrvrFrBrurCc cs|dur tt|p d}|dur|j|||d}n|j|||d|jjrNt|||}|D] }|V|jd7_q/WddS1sGwYdS|j} |j } |D] }|V| |d| qVdS)aTrack 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). 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. Nrur+) rjr add_taskrTrRrwr?rFrPrO) rIrtrvrFrBrurC track_threadvaluerPrOrLrLrMrs(" zProgress.trackr)rBrurcCsd}|dur |}n|dur&|j|j|j}Wdn1s!wY|dur.td|dur:|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'rvFr)rrrrv ValueErrorrrTr)rIrrvrBru total_bytesrLrLrMrszProgress.wrap_filer)rvrBrurrrrrrrc CrrXrL rIrrrrrrrvrBrurLrLrMrz Progress.openrrc CrrXrLrrLrLrMrrcCsdt|dd} | dvrtd||dk} | dkr)|dkr)tdtd }n| d vr;|d kr5td |dkr;d }|d urDt|j}|d urP|j| |d}n|j ||dt j |d|d} t | ||dd} |dvrut 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)brrrz 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/ONrr)rTr)rr)rrrline_buffering)rbsortedrwarningswarnRuntimeWarningrst_sizerrTiorr TextIOWrapper)rIrrrrrrrvrBru_moderrrrLrLrMrs>! cCsZ|j |j|}|jdur||_WddSWddS1s&wYdS)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)rrrrmrz)rIrBrrLrLrM start_taskks   "zProgress.start_taskcCsT|j|j|}|}|jdur||_||_WddS1s#wYdS)zStop a task. This will freeze the elapsed time on the task. Args: task_id (TaskID): ID of task. N)rrrrzrmrn)rIrBrrrLrLrM stop_taskys  "zProgress.stop_task)rvrFrPrurgrOrPrgrOricKsH|j|j|} | j} |dur|| jkr|| _| |dur'| j|7_|dur.|| _|dur5|| _|dur<|| _| j|| j| } | } | |j } | j }|j }|rk|dj | krk||rk|dj | ks_| dkrw|t| | | jdur| j| jkr| jdur| j| _Wdn1swY|r|dSdS)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)rrrrFrvrrurgrirTrzrrqpopleftrappendrer"r#rO)rIrBrvrFrPrurgrOrircompleted_startupdate_completedrold_sample_timerqrrLrLrMrTsD       " zProgress.update)rZrvrFrgrurZc Ks|}|j8|j|} | |r|nd| _|dur|| _|| _|dur)|| _|r.|| _|dur5|| _ d| _ Wdn1sBwY| 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) rzrrrrrmrvrFrgrirur"rO) rIrBrZrvrFrgrurirrrLrLrMresets"  zProgress.resetr+c Cs*|}|j|j|}|j}|j|7_|j|}||j}|j}|j} |r<|dj|kr<| |r<|dj|ks0t|dkrK| t|dksB| t |||j durs|j|j kr{|j dur|j |_ |j|_WddSWddSWddSWddS1swYdS)zAdvance task by a number of steps. Args: task_id (TaskID): ID of task. advance (float): Number of steps to advance. Default is 1. rr)N)rzrrrrFrrqrrrrrervr"r#rr0) rIrBrPrrrrrrqrrLrLrMrPs8         "zProgress.advancecCs$|js|jjr|jdSdSdS)z*Refresh (render) the progress information.N)rrRrSrOr[rLrLrMrO szProgress.refreshcCst|}|S)z*Get a renderable for the progress display.)r/get_renderables)rIrrLrLrMrs zProgress.get_renderableccs||j}|VdS)z5Get a number of renderables for the progress display.N)make_tasks_tabler)rItablerLrLrMrs  zProgress.get_renderablesrcsRdd|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. css0|]}t|trtddn|VqdS)TrN)rrr8rcopy)r|_columnrLrLrMr~"s  z,Progress.make_tasks_table..)rr+)paddingrc3s.|]}t|tr|jdn|VqdS)rN)rrr)r|columnrrLrMr~/s )rr9gridrrgadd_row)rIr table_columnsrrLrrMrs   zProgress.make_tasks_tablecCs2|j |WdS1swYdS)z+Makes the Progress class itself renderable.N)rrrr[rLrLrM__rich__:s$zProgress.__rich__rxc Ks|j2t|j||||||j|jd}||j|j<|r!||j|j}tt|jd|_Wdn1s8wY||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`. )rgrirfrrr+N) rrrrrzrrr<rrO) rIrurZrvrFrgrirnew_task_indexrLrLrMr?s&  zProgress.add_taskcCs4|j |j|=WddS1swYdS)z]Delete a task if it exists. Args: task_id (TaskID): A task ID. N)rrr)rIrBrLrLrM remove_taskjs "zProgress.remove_taskre)NrNrmrsrXrNNNrrNNN)r+)TrxrT) 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_numbersfoobarbaz123z: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...examplezPretty printed)typerz Syntax...zGive it a try!)cycle)record)rxryz[red]Downloadingr)rz[green]Processingz[yellow]Thinkingr2rg333333?g{Gz?d)rmNrTNFNrnrorprqrrrsFTrr)rsysrrabcrr collectionsr dataclassesrrdatetimerr r mathr r operatorr osrr threadingrrrtypesrrrrrrrrrrrrrr r!r"r#r$r% version_infor(typing_extensionsr*rr,r-rxr.r/r0r1r r2jupyterr3rRr4 progress_barr5rr6r|r7rr8r9rr:r;rr<r=rjrr>r?rrrrrrrrrrrrrrrrrr>rCrDrrdrerrArfrandomtimepanelrrulersyntaxrrprogress_renderables itertoolsrexamplesrr@rtask1task2task3rrTsleeprandintrrrLrLrLrMs      P            *      Lg      A                     V*2* H0  1  } R           $