o Ojb+@sddlZddlZddlZddlZddlmZmZddlmZddl m Z ddl m Z m Z ddlmZddlmZmZddlmZdd 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/ej0dkrddlm1Z1nddl2m1Z1ddl3m4Z4m5Z5ddl6m7Z7m8Z8m9Z9m:Z:ddl;mZ>ddl?m@Z@ddlAmBZBddlCmDZDddlEmFZFddlGmHZHmIZIddlJmKZKmLZLe(deMZNe.dZOe gePfZQe.de+eZRGdddeZS  !  "  # $ % & ' ( " !dd)e/e*eOe%eOfd*eTd+e)ePd,eUd-e)e7d.eUd/e)e gePfd0ePd1eFd2eFd3eFd4eFd5ePd6eUd7eUd8e%eOf d9d:ZVGd;d<dd>e!eRe$eRZXd?d!dd"dd#d$d%d&d'd"d@ dAed+eMd*eTd,eUd-e)e7d.eUd/e)e gePfd0ePd1eFd2eFd3eFd4eFd6eUd8e!efdBdCZYejZ D   ddd?d!dd"dd#d$d%d&d'd"dE dAe/eTdFe[fdGe/e1dHe1dIfdJeMdKe)eTdLe)eTdMe)eTd+e)eMd*eTd,eUd-e)e7d.eUd/e)e gePfd0ePd1eFd2eFd3eFd4eFd6eUd8e!e+f&dNdOZ\ejZ D   ddd?d!dd"dd#d$d%d&d'd"dE dAe/eTdFe[fdGe1dPdJeMdKe)eTdLe)eTdMe)eTd+e)eMd*eTd,eUd-e)e7d.eUd/e)e gePfd0ePd1eFd2eFd3eFd4eFd6eUd8e!ef&dQdOZ\ I D   ddd?d!dd"dd#d$d%d&d'd"dE dAe/eTdFe[fdGe/e1dPe1dHe1dIfdJeMdKe)eTdLe)eTdMe)eTd+e)eMd*eTd,eUd-e)e7d.eUd/e)e gePfd0ePd1eFd2eFd3eFd4eFd6eUd8e/e!ee!e+ff&dRdOZ\GdSdTdTeZ]GdUdVdVe]Z^GdWdXdXe]Z_GdYdZdZe]Z`Gd[d\d\e]ZaGd]d^d^e]ZbGd_d`d`e`ZcGdadbdbe]ZdGdcdddde]ZeGdedfdfe]ZfGdgdhdhe]ZgGdidjdje]ZhGdkdldle]ZiGdmdndne'Zje GdodpdpZkGdqdrdre>ZlemdskrddlnZnddloZoddtlpmqZqddulrmsZsddvltmuZuddwlGmIZIeudxdyd!dzZteId{d|d}ZGeGvd~dddeqddeGdddddetesdg ZwddlxmyZyeyewZze7d!dZ6ele_gel{ebRe6d"dQZ|e|j}dddZ~e|j}dddZe|j}dddZe|jse|je~dde|jeddeodendddkre|eeze|jrWddSWddS1swYdSdS)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_IcsleZdZdZdddddeffdd Zdd d Zdd dZdee e dee dee d d fddZ Z S) _TrackThreadz)A thread to periodically update progress.progressProgresstask_idr: update_periodcs.||_||_||_t|_d|_tdS)Nr)r>r@rArdone completedsuper__init__)selfr>r@rA __class___/var/www/html/pharmsmart-cdr-gen/venv/lib/python3.10/site-packages/pip/_vendor/rich/progress.pyrEBs z_TrackThread.__init__returnNcCsj|j}|jj}|j}d}|jj}||s(|j}||kr$|||||}||r|jj|j|jdddS)NrT)rCrefresh)r@r>advancerArBwaitrCupdate)rFr@rMrAlast_completedrNrCrIrIrJrunKsz_TrackThread.runcC ||SNstartrFrIrIrJ __enter__Yz_TrackThread.__enter__exc_typeexc_valexc_tbcCs|j|dSrS)rBsetjoinrFrYrZr[rIrIrJ__exit__]s  z_TrackThread.__exit__rKN)rKr=)__name__ __module__ __qualname____doc__floatrErQrWrr# BaseExceptionrr_ __classcell__rIrIrGrJr=?s  r= Working...TF bar.back bar.complete bar.finished bar.pulse皙?sequence descriptiontotal auto_refreshconsole transientget_timerefresh_per_secondstylecomplete_stylefinished_style pulse_stylerAdisable show_speedrKc cs|rtdgng}|t|| | | dt|dtft||||||p%d| d}||j|||| dEdHWddS1sDwYdS)aTrack 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}rwrxryrz)r|rirrrsrtrurvr{)rqrprAN) TextColumnextend BarColumnTaskProgressColumnTimeRemainingColumnr?track)rorprqrrrsrtrurvrwrxryrzrAr{r|columnsr>rIrIrJrgs8(  "rc @seZdZdZ d=dedddededd f d d Zd>d d Zde e e de e de e dd fddZ defddZdefddZedefddZdefddZdefddZedefddZdefdd Zdefd!d"Zdefd#d$Zd?d&edefd'd(Zd)eeeeffd*d+Z d?d&edefd,d-Z!d?d.ede"efd/d0Z#d@d1d2Z$dAd4ed5edefd6d7Z%defd8d9Z&d:e'defd;d<Z(d S)B_Readerz9A reader that tracks progress while it's being read from.Thandler>r?task close_handlerKNcCs"||_||_||_||_d|_dSNF)rr>rr_closed)rFrr>rrrIrIrJrEs  z_Reader.__init__cCs|j|SrS)rrWrVrIrIrJrWs z_Reader.__enter__rYrZr[cC |dSrS)closer^rIrIrJr_ z_Reader.__exit__cCs|SrSrIrVrIrIrJ__iter__z_Reader.__iter__cCs$t|j}|jj|jt|d|SNrM)nextrr>rMrlen)rFlinerIrIrJ__next__s z_Reader.__next__cC|jSrS)rrVrIrIrJclosedsz_Reader.closedcC |jSrS)rfilenorVrIrIrJr z_Reader.filenocCrrS)risattyrVrIrIrJrrz_Reader.isattycC|jjSrS)rnamerVrIrIrJrz _Reader.namecCrrS)rreadablerVrIrIrJrrz_Reader.readablecCrrS)rseekablerVrIrIrJrrz_Reader.seekablecCdSrrIrVrIrIrJwritablerz_Reader.writablesizecC&|j|}|jj|jt|d|Sr)rreadr>rMrr)rFrblockrIrIrJr z _Reader.readbcCs"|j|}|jj|j|d|Sr)rreadintor>rMr)rFrnrIrIrJrs z_Reader.readintocCrr)rreadliner>rMrr)rFrrrIrIrJrrz_Reader.readlinehintcCs,|j|}|jj|jttt|d|Sr)r readlinesr>rMrsummapr)rFrlinesrIrIrJrs z_Reader.readlinescCs|jr|jd|_dS)NT)rrrrrVrIrIrJrs  z _Reader.closeroffsetwhencecCs$|j||}|jj|j|d|S)NrC)rseekr>rOr)rFrrposrIrIrJrsz _Reader.seekcCrrS)rtellrVrIrIrJrrz _Reader.tellscCstd)Nwrite)r )rFrrIrIrJr sz _Reader.write)T)rKr)rr`)r))rarbrcrdrr:boolrErWrr#rfrr_rbytesrpropertyrintrrstrrrrrrr% bytearray memoryviewr rrrrrrrrrrIrIrIrJrsV    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>r?readerrKNcCs||_||_dSrS)r>r)rFr>rrIrIrJrEs z_ReadContext.__init__cCs|j|jSrS)r>rUrrWrVrIrIrJrWs  z_ReadContext.__enter__rYrZr[cCs|j|j|||dSrS)r>stoprr_r^rIrIrJr_s z_ReadContext.__exit__) rarbrcrdr<rErWrr#rfrr_rIrIrIrJr s r Reading...) rprrrsrtrurvrwrxryrzr{filec  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.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~rir)rqrp)rrrDownloadColumnrr? wrap_filer)rrqrprrrsrtrurvrwrxryrzr{rr>rrIrIrJr"s0%  rr) rqrprrrsrtrurvrwrxryrzr{ PathLike[str]modertr bufferingencodingerrorsnewlinec CdSrSrIrrrrrrrqrprrrsrtrurvrwrxryrzr{rIrIrJopencrrbc CrrSrIrrIrIrJr|rc  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.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~rir)rrrrrrqrp)rrrrrr?rr)rrrrrrrqrprrrsrtrurvrwrxryrzr{rr>rrIrIrJrsB1   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_columnrKcCs||_i|_d|_dSrS) _table_column_renderable_cache _update_time)rFrrIrIrJrEs zProgressColumn.__init__cCs |jptS)z.Get a table column, used to build tasks table.)rr6rVrIrIrJget_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)rurrCridKeyErrorrender)rFr current_time timestamp renderablerIrIrJ__call__s   zProgressColumn.__call__cCr)z"Should return a renderable object.NrIrFrrIrIrJrszProgressColumn.renderrS)rarbrcrdrrre__annotations__r6rErr/rrrrIrIrIrJrs 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)rrDrE)rFrrrGrIrJrEzRenderableColumn.__init__rrrKcCrrS)rrrIrIrJr"szRenderableColumn.render)r) rarbrcrdr/rr6rErrgrIrIrGrJrsrc 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_namerwspeed finished_textrcs<t|||d|_t|trt|n||_tj|ddS)Nrwrr) r4spinner isinstancerr8 from_markuprrDrE)rFrrwrrrrGrIrJrE0s  zSpinnerColumn.__init__ spinner_stylerKcCst|||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)rFrrrrIrIrJ set_spinner@s zSpinnerColumn.set_spinnerrrcCs$|jr|j}|S|j|}|SrS)finishedrrrru)rFrtextrIrIrJrOszSpinnerColumn.render)rrrrN)rr)rarbrcrdrrr5rer9r6rErr/rrgrIrIrGrJr&s<  rcsdeZdZdZ     ddededed ed ee d ee d dffd d Z ddd e fddZ ZS)rzA column containing text.noneleftTN text_formatrwjustifymarkup highlighterrrKcs:||_||_||_||_||_tj|ptddddS)NTno_wrapr)rrrwrrrDrEr6)rFrrwrrrrrGrIrJrE[s  zTextColumn.__init__rrcCsR|jj|d}|jrtj||j|jd}n t||j|jd}|jr'|j||SNr)rwr) rformatrr8rrwrr highlight)rFr_textrrIrIrJrks zTextColumn.render)rrTNN)rarbrcrdrr5r.rrr0r6rEr8rrgrIrIrGrJrXs.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.done". pulse_style (StyleType, optional): Style for pulsing bars. Defaults to "bar.pulse". (rjrkrlrmN bar_widthrwrxryrzrrKcs0||_||_||_||_||_tj|ddSr)r rwrxryrzrDrE)rFr rwrxryrzrrGrIrJrEs  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)) rqrCwidthpulseanimation_timerwrxryrz) r3rqmaxrCr startedrurwrxryrzrrIrIrJrs zBarColumn.render)r rjrkrlrmN) rarbrcrdrrr5r6rEr3rrgrIrIrGrJrvs0 rc@"eZdZdZdddefddZdS)TimeElapsedColumnzRenders time elapsed.rrrKcCsD|jr|jn|j}|durtdddStt|d}tt|ddS)Show time remaining.N-:--:--progress.elapsedrw)seconds)r finished_timeelapsedr8r rr)rFrrdeltarIrIrJrs  zTimeElapsedColumn.renderNrarbrcrdr8rrIrIrIrJrrcseZdZdZ        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}%rrrTNFrtext_format_no_percentagerwrrrrr|rKc s(||_||_tj||||||ddS)N)rrwrrrr)rr|rDrE) rFrrrwrrrrr|rGrIrJrEs  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)r8r*pick_unit_and_suffixr)clsrunitsuffix data_speedrIrIrJ 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)rqr|r&finished_speedrrrrrr8rrwrrr )rFrrr rrIrIrJrs  zTaskProgressColumn.render)rrrrTNNF)rarbrcrdrr5r.rrr0r6rE classmethodrer8r&rrgrIrIrGrJrs@  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. ?FNcompactelapsed_when_finishedrcs||_||_tj|ddSr)r*r+rDrE)rFr*r+rrGrIrJrEszTimeRemainingColumn.__init__rrrKcCs|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) rrzprogress.remainingNrrz--:--r<02d:d) r+rrtime_remainingrqr8r*divmodr)rFr task_timerwminutesrhours formattedrIrIrJr s     zTimeRemainingColumn.render)FFN) rarbrcrdrrrr6rEr8rrgrIrIrGrJrs rc@r)FileSizeColumnzRenders completed filesize.rrrKcCstt|j}t|ddS)Show data completed.zprogress.filesizer)r*decimalrrCr8rFr data_sizerIrIrJr(s zFileSizeColumn.renderNrrIrIrIrJr6%rr6c@r)TotalFileSizeColumnzRenders total filesize.rrrKcCs*|jdur tt|jnd}t|ddS)r7Nrzprogress.filesize.totalr)rqr*r8rr8r9rIrIrJr1s zTotalFileSizeColumn.renderNrrIrIrIrJr;.rr;csBeZdZdZd 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)r>rDrE)rFr>rrGrIrJrECszMofNCompleteColumn.__init__rrrKcCsPt|j}|jdurt|jnd}tt|}t||d|j|ddS)zShow completed/total.N?r/progress.downloadr)rrCrqrrr8r>)rFrrCrq total_widthrIrIrJrGs  zMofNCompleteColumn.render)r=N) rarbrcrdrrr6rEr8rrgrIrIrGrJr<7s r<csHeZdZdZ 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_unitsrrKcrr)rBrDrE)rFrBrrGrIrJrEYrzDownloadColumn.__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,.fr?r=rr@r)rrCrqrBr*r!r8)rFrrC unit_and_suffix_calculation_baser#r$ precisioncompleted_ratio completed_strrq total_ratio total_strdownload_status download_textrIrIrJr_s2     zDownloadColumn.render)FN) rarbrcrdrrr6rEr8rrgrIrIrGrJrRsrc@r)TransferSpeedColumnz&Renders human readable transfer speed.rrrKcCs@|jp|j}|durtdddStt|}t|dddS)zShow data transfer speed.Nr?zprogress.data.speedrz/s)r'rr8r*r8r)rFrrr%rIrIrJrs  zTransferSpeedColumn.renderNrrIrIrIrJr\rr\c@s$eZdZUdZeed< eed<dS)ProgressSamplez$Sample of progress for a given time.rrCN)rarbrcrdrerrIrIrIrJr]s r]c@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. rrprqrC _get_timeNrTvisible)default_factoryfieldsF)defaultinitrepr start_time stop_timer'cCs tddS)Nr )maxlenrrIrIrIrJs z Task.)r`rcrd _progress)rdr`_lockrKcCs|S)z(float: Get the current time, in seconds.)r^rVrIrIrJrurz Task.get_timecC |jduS)z#bool: Check if the task as started.N)rerVrIrIrJr z Task.startedcCs|jdurdS|j|jS)zPOptional[float]: Get the number of steps remaining, if a non-None total was set.N)rqrCrVrIrIrJ 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)rerfrurVrIrIrJrs   z Task.elapsedcCrk)zCheck if the task has finished.N)rrVrIrIrJrrlz Task.finishedcCs.|jsdS|j|jd}tdtd|}|S)zOfloat: Get progress of task as a percentage. If a None total was set, returns 0Y@)rqrCminr)rFrCrIrIrJ 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|]}|jVqdSrSr).0samplerIrIrJ zTask.speed..)rerjririterrr)rFr> total_time iter_progresstotal_completedrrIrIrJrs" $z Task.speedcCs:|jrdS|j}|s dS|j}|durdSt||}|S)zJOptional[float]: Get estimated time to completion, or ``None`` if no data.rnN)rrrmr )rFrrmestimaterIrIrJr0s zTask.time_remainingcCs|jd|_d|_dS)zReset progress.N)riclearrr'rVrIrIrJ_resets  z Task._resetr`)$rarbrcrdr:rrrreGetTimeCallablerr_rrdictrarrrerfr'rirr]rrjrurrrmrrrqrr0r}rIrIrIrJrsZ     rc@speZdZdZddddddddddd deeefd eed e d e d e d e de de dee de de ddfddZ e deedffddZedefddZedeefddZedeefddZede fdd Zdmd!d"Zdmd#d$Zdnd%d&Zd'eeed(eed)eeddfd*d+Z   , -dod.eee e!e fd/ee d0eed1ed2e dee f d3d4Z" dpdd5d6d7e#d/ee$d0eed1ede#f d8d9Z%e&j' :   dqddd5d;d7eedd?e$d@eedAeedBeed/ee$d0eed1ede#fdCdDZ*e&j' :   dqddd5d;d7eede)dFe)dEfd?e$d@eedAeedBeed/ee$d0eed1edee#e+ffdHdDZ*d0eddfdIdJZ,d0eddfdKdLZ-dddddddMd0ed/ee dNee dOee d1eedPee dQe dRe.ddfdSdTZ/dddUdddVd0edWe d/ee dNe$dPee d1eedRe.ddfdXdYZ0dsd0edOe ddfd[d\Z1dmd]d^Z2de3fd_d`Z4dee3fdadbZ5dceede6fdddeZ7de3fdfdgZ8  h U dtd1edWe d/ee dNe$dPe dRe.defdidjZ9d0eddfdkdlZ:dS)ur?aRenders 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. NTrig>@F) rsrrrvspeed_estimate_periodrtredirect_stdoutredirect_stderrrur{expandrrsrrrvrrtrrrur{rrKc Gs|dksJdt|_| p||_||_| |_| |_i|_td|_ t |p)t ||||||j d|_ |p9|jj|_|jj|_|jj|_dS)Nrzrefresh_per_second must be > 0)rsrrrvrtrrget_renderable)rrjget_default_columnsrrr{r_tasksr: _task_indexr2r+rliversruprintlog) rFrsrrrvrrtrrrur{rrrIrIrJrE&s(  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.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"rIrIrJrJs zProgress.get_default_columnscCrrS)rrsrVrIrIrJrsirzProgress.consolecC8|jt|jWdS1swYdS)zGet a list of Task instances.N)rjlistrvaluesrVrIrIrJtasksm $zProgress.taskscCr)zA list of task IDs.N)rjrrkeysrVrIrIrJtask_idssrzProgress.task_idscCsZ|j |js WddStdd|jDWdS1s&wYdS)z'Check if all tasks have been completed.NTcsrrrS)r)rsrrIrIrJrurvz$Progress.finished..)rjrallrrVrIrIrJrys $zProgress.finishedcCs|js |jjdddSdS)zStart the progress display.T)rLN)r{rrUrVrIrIrJrUszProgress.startcCs$|j|jjs|jdSdS)zStop the progress display.N)rrrsis_interactiverrVrIrIrJrs z Progress.stopcCrRrSrTrVrIrIrJrWrXzProgress.__enter__rYrZr[cCrrS)rr^rIrIrJr_rzProgress.__exit__rhrnrorqr@rprAc csd}|durt|trtt|}n|}|dur!|j||d}n|j||d|jjrTt|||}|D] }|V|j d7_ q5WddS1sMwYdS|j } |j } |D] }|V| |d| q\dS)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). 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. Nrqr)) rrreradd_taskrOrrrr=rCrMrL) rFrorqr@rprA task_total track_threadvaluerMrLrIrIrJrs0  " zProgress.trackr)r@rprcCsd}|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'rFr)rjrrq ValueErrorrrOr)rFrrqr@rp total_bytesrIrIrJrszProgress.wrap_filer)rqr@rprrrrrrrc CrrSrI rFrrrrrrrqr@rprIrIrJrz Progress.openrrc CrrSrIrrIrIrJrrcCsdt|dd} | dvrtd||dk} | dkr)|dkr)tdtd }n| d ks1| d kr?|d kr9td |dkr?d }|durHt|j}|durT|j | |d}n|j ||dt j |d|d} t | ||dd} |d kss|d kr}t 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)brrrzinvalid mode {!r}r)rzaline buffering (buffering=1) isn't supported in binary mode, the default buffer size will be usedrrrrzcan't have unbuffered text I/ONrr)rTr)rrrline_buffering)r]sortedrrwarningswarnRuntimeWarningrst_sizerrOiorr TextIOWrapper)rFrrrrrrrqr@rp_moderrrrIrIrJrs>! 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)rjrreru)rFr@rrIrIrJ start_task]s   "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)rjrrurerf)rFr@rrrIrIrJ stop_taskks  "zProgress.stop_task)rqrCrMrpr_rLrCrMr_rLracKsH|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)rjrrCrqr}rpr_rarOrurripopleftrappendr]rrrL)rFr@rqrCrMrpr_rLrarcompleted_startupdate_completedrold_sample_timerirrIrIrJrOzsJ     " zProgress.updater)rUrqrCr_rprUc 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) rurjrr}rerqrCr_rarprrL) rFr@rUrqrCr_rprarrrIrIrJresets"  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)rurjrrCrrirrrrr]rqrrrr') rFr@rMrrrrrrirrIrIrJrMs>       "zProgress.advancecCs$|js|jjr|jdSdSdS)z*Refresh (render) the progress information.N)r{r is_startedrLrVrIrIrJrLszProgress.refreshcCst|}|S)z*Get a renderable for the progress display.)r-get_renderables)rFrrIrIrJrs zProgress.get_renderableccs||j}|VdS)z5Get a number of renderables for the progress display.N)make_tasks_tabler)rFtablerIrIrJrs  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)rrr6rcopy)rs_columnrIrIrJrus  z,Progress.make_tasks_table..)rr))paddingrc3s.|]}t|tr|jdn|VqdS)rN)rrr)rscolumnrrIrJru!s )rr7gridrr_add_row)rFr table_columnsrrIrrJr s   zProgress.make_tasks_tablecCs2|j |WdS1swYdS)z+Makes the Progress class itself renderable.N)rjrrVrIrIrJ__rich__,s$zProgress.__rich__roc 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`. )r_rar^rjr)N) rjrrrurrr:rrL) rFrprUrqrCr_rarnew_task_indexrIrIrJr1s&  zProgress.add_taskcCs4|j |j|=WddS1swYdS)z]Delete a task if it exists. Args: task_id (TaskID): A task ID. N)rjr)rFr@rIrIrJ remove_task\s "zProgress.remove_taskr`)rKr?)NNrhrnrSrNNNrrNNN)r))TrorT);rarbrcrdr%rrrr,rrer~rEr(r"rrrsrrrr:rrrUrrWr#rfrr_rr;r rrrrtypingoverloadrr(rr!rrrrOrrMrLr/rrr7rrrrrIrIrIrJr?s      $       1 *                  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_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)rsrtz[red]Downloadingr rz[green]Processingz[yellow]Thinkingr)rg333333?g{Gz?d)rhNTNFNrirjrkrlrmrnFTrr)rsysrrabcrr collectionsrcollections.abcr dataclassesrrdatetimer r r mathr r osrr threadingrrrtypesrrrrrrrrrrrrrr r!r"r#r$r% version_infor(pip._vendor.typing_extensionsrr*r+rsr,r-r.r/rr0jupyterr1rr2 progress_barr3rr4rwr5rr6r7rr8r9rr:r;rer~r<r=rrrrrrrrrrrrrrrrrr6r;r<rr\r]rr?rarandomtimepanelrrulersyntaxrrprogress_renderables itertoolsrexamplesrr>rtask1task2task3rrOsleeprandintrrrIrIrIrJs      P          *      F`      A                     V*2* I0  1  } U           $