o 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/m0Z0m1Z1erddl2m3Z3ddl4m5Z5m6Z6ddl7m8Z8m9Z9m:Z:m;Z;ddlm?Z?ddl@mAZAddlBmCZCddlDmEZEddlFmGZGddlHmIZImJZJddlKmLZLmMZMe+deNZOe0dZPe"geQfZRe0de-e!ZSGdddeZT  !  "  # $ % & ' ( " !dddCdDZUGdEdFdFee!ZVGdGdHdHe#eSe&eSZWdId!dd"dd#d$d%d&d'd"dJ ddNdOZXejY P   dddId!dd"dd#d$d%d&d'd"dQ dd\d]ZZejY P   dddId!dd"dd#d$d%d&d'd"dQ dd_d]ZZ ` P   dddId!dd"dd#d$d%d&d'd"dQ ddcd]ZZGdddedeeZ[Gdfdgdge[Z\Gdhdidie[Z]Gdjdkdke[Z^Gdldmdme[Z_Gdndodoe[Z`Gdpdqdqe^ZaGdrdsdse[ZbGdtdudue[ZcGdvdwdwe[ZdGdxdydye[ZeGdzd{d{e[ZfGd|d}d}e[ZgGd~dde*Zhe GdddZiGddde?ZjekdkrddllZlddlmZmddlnmoZoddlpmqZqddlrmsZsddlHmJZJesddd!dZreJdddZHeHtddddeoddeHdddddereqdg ZuddlvmwZweweuZxe8d!dZ7eje]gejye`Re7d"dQZzezj{dddZ|ezj{dddZ}ezj{dddZ~ezjsezje|ddezje}ddemdeldddkrezeexezjrWddSWddS1swYdSdS)) annotationsN)ABCabstractmethoddeque) dataclassfield) timedelta) RawIOBaseUnsupportedOperation)ceil)mmap) length_hint)PathLikestat)EventRLockThread) TracebackType) TYPE_CHECKINGAnyBinaryIOCallableContextManagerDequeDictGenericIterableListLiteral NamedTupleNewTypeOptionalTextIOTupleTypeTypeVarUnion)Self)filesize get_console)ConsoleGroup JustifyMethodRenderableType) Highlighter) JupyterMixin)Live) ProgressBar)Spinner) StyleType)ColumnTable)TextTextTypeTaskID ProgressType_Ics@eZdZdZdfdd Zdd d ZdddZdddZZS) _TrackThreadz)A thread to periodically update progress.progress 'Progress'task_id'TaskID' update_periodfloatcs2||_||_||_t|_d|_tjdddS)NrT)daemon)r>r@rBrdone completedsuper__init__)selfr>r@rB __class___/home/www/facesmatcher.com/frenv_anti/lib/python3.10/site-packages/pip/_vendor/rich/progress.pyrHCs z_TrackThread.__init__returnNonecCs~|j}|jj}|j}d}|jj}||s2|jjjr2|j}||kr)|||||}||s2|jjjs|jj |j|jdddS)NrT)rFrefresh) r@r>advancerBrEwaitlive is_startedrFupdate)rIr@rQrBZlast_completedrRrFrLrLrMrunLsz_TrackThread.run'_TrackThread'cC ||SNstartrIrLrLrM __enter__Zz_TrackThread.__enter__exc_typeOptional[Type[BaseException]]exc_valOptional[BaseException]exc_tbOptional[TracebackType]cCs|j|dSrY)rEsetjoinrIr_rarcrLrLrM__exit__^s  z_TrackThread.__exit__)r>r?r@rArBrCrNrO)rNrWr_r`rarbrcrdrNrO) __name__ __module__ __qualname____doc__rHrVr]rh __classcell__rLrLrJrMr=@s  r= Working...TF bar.back bar.complete bar.finished bar.pulse皙?sequenceIterable[ProgressType] descriptionstrtotalOptional[float]rFint auto_refreshboolconsoleOptional[Console] transientget_timeOptional[Callable[[], float]]refresh_per_secondrCstyler5complete_stylefinished_style pulse_stylerBdisable show_speedrNc cs|rtdgng}|t| | | | dt|dtddft||||||p'd|d}||j||||| dEd HWd d S1sGwYd S) aTrack 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 wish to iterate over and track progress. 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}rrrr)rT)elapsed_when_finishedrqr~rrrrr)r{rFryrBN) TextColumnextend BarColumnTaskProgressColumnTimeRemainingColumnProgresstrack)rwryr{rFr~rrrrrrrrrBrrcolumnsr>rLrLrMrhs@,  "rc@seZdZdZ dQdRd dZdSddZdTddZdUddZdVddZe dWdd Z dXd"d#Z dWd$d%Z e dYd'd(Z e dYd)d*ZdWd+d,ZdWd-d.ZdWd/d0ZdZd[d3d4Zd\d7d8ZdZd[d9d:ZdZd]d=d>Zd^d?d@Zd_d`dDdEZdXdFdGZdadJdKZdbdNdOZdPS)c_Readerz9A reader that tracks progress while it's being read from.Thandlerr>r?taskr: close_handlerrNrOcCs"||_||_||_||_d|_dSNF)rr>rr_closed)rIrr>rrrLrLrMrHs  z_Reader.__init__ '_Reader'cCs|j|SrY)rr]r\rLrLrMr]s z_Reader.__enter__r_r`rarbrcrdcC |dSrY)closergrLrLrMrh z_Reader.__exit__cCs|SrYrLr\rLrLrM__iter__z_Reader.__iter__bytescCs$t|j}|jj|jt|d|SNrQ)nextrr>rQrlen)rIlinerLrLrM__next__s z_Reader.__next__cC|jSrY)rr\rLrLrMclosedsz_Reader.closedr}cC |jSrY)rfilenor\rLrLrMr z_Reader.filenocCrrY)risattyr\rLrLrMrrz_Reader.isattyrzcC|jjSrY)rmoder\rLrLrMrz _Reader.modecCrrY)rnamer\rLrLrMrrz _Reader.namecCrrY)rreadabler\rLrLrMrrz_Reader.readablecCrrY)rseekabler\rLrLrMrrz_Reader.seekablecCdSrrLr\rLrLrMwritablerz_Reader.writablesizecC&|j|}|jj|jt|d|Sr)rreadr>rQrr)rIrblockrLrLrMr z _Reader.readb"Union[bytearray, memoryview, mmap]cCs"|j|}|jj|j|d|Sr)rreadintor>rQr)rIrnrLrLrMrs z_Reader.readintocCrr)rreadliner>rQrr)rIrrrLrLrMrrz_Reader.readlinehint List[bytes]cCs,|j|}|jj|jttt|d|Sr)r readlinesr>rQrsummapr)rIrlinesrLrLrMrs z_Reader.readlinescCs|jr|jd|_dS)NT)rrrrr\rLrLrMr s  z _Reader.closeroffsetwhencecCs$|j||}|jj|j|d|S)NrF)rseekr>rUr)rIrrposrLrLrMrsz _Reader.seekcCrrY)rtellr\rLrLrMrrz _Reader.tellsrcCtd)Nwriter )rIrrLrLrMrz _Reader.writer Iterable[Any]cCr)N writelinesr)rIrrLrLrMrrz_Reader.writelinesN)T) rrr>r?rr:rrrNrO)rNrrj)rNr)rNrrNr)rNr})rNrz)r)rr}rNr)rr)rr}rNrri)r)rr}rr}rNr})rrrNr})rrrNrO)rkrlrmrnrHr]rhrrpropertyrrrrrrrrrrrrrrrrrrLrLrLrMrs8                   rc@s.eZdZdZddd Zdd d ZdddZdS) _ReadContextzEA utility class to handle a context for both a reader and a progress.r>r?readerr<rNrOcCs||_||_dSrY)r>r)rIr>rrLrLrMrH s z_ReadContext.__init__cCs|j|jSrY)r>r[rr]r\rLrLrMr]$s  z_ReadContext.__enter__r_r`rarbrcrdcCs|j|j|||dSrY)r>stoprrhrgrLrLrMrh(s z_ReadContext.__exit__N)r>r?rr<rNrO)rNr<rj)rkrlrmrnrHr]rhrLrLrLrMrs   r Reading...) ryr~rrrrrrrrrfilerContextManager[BinaryIO]c  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. rrrqr)r{ry)rrrDownloadColumnrr wrap_filer)rr{ryr~rrrrrrrrrrr>rrLrLrMr2s0%  rr) r{ryr~rrrrrrrrr"Union[str, 'PathLike[str]', bytes]r"Union[Literal['rt'], Literal['r']] bufferingencoding Optional[str]errorsnewline Optional[int]ContextManager[TextIO]c CdSrYrLrrrrrrr{ryr~rrrrrrrrrrLrLrMopensr Literal['rb']c CrrYrLrrLrLrMrrr1Union[Literal['rb'], Literal['rt'], Literal['r']]7Union[ContextManager[BinaryIO], ContextManager[TextIO]]c  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. rrrqr)rrrrrr{ry)rrrrrrrr)rrrrrrr{ryr~rrrrrrrrrrr>rrLrLrMrsB1   c@sLeZdZUdZdZded<ddd d Zdd d ZdddZe dddZ dS)ProgressColumnz3Base class for a widget to use in progress display.Nr| max_refresh table_columnOptional[Column]rNrOcCs||_i|_d|_dSrY) _table_column_renderable_cacheZ _update_time)rIrrLrLrMrHs zProgressColumn.__init__r6cCs |jptS)z.Get a table column, used to build tasks table.)rr6r\rLrLrMget_table_columns zProgressColumn.get_table_columnr'Task'r/cCsp|}|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)rrrFridKeyErrorrender)rIr current_time timestamp renderablerLrLrM__call__ s   zProgressColumn.__call__cCr)z"Should return a renderable object.NrLrIrrLrLrMr szProgressColumn.renderrY)rrrNrO)rNr6rrrNr/) rkrlrmrnr__annotations__rHrrrrrLrLrLrMrs     rcs6eZdZdZ ddddfd d ZdddZZS)RenderableColumnzA column to insert an arbitrary column. Args: renderable (RenderableType, optional): Any renderable. Defaults to empty string. Nrrr/rrc||_tj|ddSNr)rrGrH)rIrrrJrLrMrH,zRenderableColumn.__init__rrrNcCrrY)rrrLrLrMr2szRenderableColumn.render)r)rr/rrrrkrlrmrnrHrrorLrLrJrMr%srcsHeZdZdZ     ddfdd Z  dd ddZd!ddZZS)" 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_namerzrOptional[StyleType]speedrC finished_textr9rrcs<t|||d|_t|trt|n||_tj|ddS)Nrrr) r4spinner isinstancerzr8 from_markuprrGrH)rIrrrrrrJrLrMrH@s  zSpinnerColumn.__init__ spinner_stylerNrOcCst|||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)rIrrrrLrLrM set_spinnerPs zSpinnerColumn.set_spinnerrrr/cCs$|jr|j}|S|j|}|SrY)finishedrrrr)rIrtextrLrLrMr_szSpinnerColumn.render)r r rrN) rrzrrrrCrr9rr)r r)rrzrrrrCrNrOr)rkrlrmrnrHrrrorLrLrJrMr 6s  r cs8eZdZdZ     ddfdd ZdddZZS)rzA column containing text.noneleftTN text_formatrzrr5justifyr.markupr highlighterOptional[Highlighter]rrrNrOcs:||_||_||_||_||_tj|ptddddS)NTZno_wrapr)rrrr r!rGrHr6)rIrrrr r!rrJrLrMrHks  zTextColumn.__init__rrr8cCsR|jj|d}|jrtj||j|jd}n t||j|jd}|jr'|j||SNr)rr) rformatr r8rrrr! highlight)rIr_textrrLrLrMr{s zTextColumn.render)rrTNN)rrzrr5rr.r rr!r"rrrNrOrrrNr8r rLrLrJrMrhsrcs:eZdZdZ      ddfdd ZdddZZS)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". (rrrsrtruN bar_widthrrr5rrrrrrNrOcs0||_||_||_||_||_tj|ddSr)r+rrrrrGrH)rIr+rrrrrrJrLrMrHs  zBarColumn.__init__rrr3c 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)) r{rFwidthZpulseZanimation_timerrrr) r3r{maxrFr+startedrrrrrrrLrLrMrs zBarColumn.render)r*rrrsrtruN)r+rrr5rr5rr5rr5rrrNrO)rrrNr3r rLrLrJrMrs rc@eZdZdZd ddZdS) TimeElapsedColumnzRenders time elapsed.rrrNr8cCsJ|jr|jn|j}|durtdddSttdt|d}tt|ddS)zShow time elapsed.N-:--:--progress.elapsedrr)seconds)r finished_timeelapsedr8r r-r}rz)rIrr6deltarLrLrMrs  zTimeElapsedColumn.renderNr)rkrlrmrnrrLrLrLrMr0r0csLeZdZdZ        d$d%fdd Zed&ddZd'd"d#ZZS)(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}%rrrTNFrrztext_format_no_percentagerr5rr.r rr!r"rrrrNrOc s(||_||_tj||||||ddS)N)rrrr r!r)r;rrGrH) rIrr;rrr r!rrrJrLrMrHs  zTaskProgressColumn.__init__rr|r8cCsN|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.percentager3)ru×10³u×10⁶u×10⁹u×10¹²z.1fz it/s)r8r*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$)r{rrBfinished_speedrr;rr&r r8rrrr!r')rIrrr(rrLrLrMrs  zTaskProgressColumn.render)r:rrrTNNF)rrzr;rzrr5rr.r rr!r"rrrrrNrO)rr|rNr8r)) rkrlrmrnrH classmethodrBrrorLrLrJrMrs rcs8eZdZdZdZ   ddfd d ZdddZZS)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. ?FNcompactrrrrcs||_||_tj|ddSr)rFrrGrH)rIrFrrrJrLrMrHszTimeRemainingColumn.__init__rrrNr8cCs|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.r2zprogress.remainingNrr3z--:--r1<Z02d:d) rrr5time_remainingr{r8rFdivmodr})rIrZ task_timerminutesr4hours formattedrLrLrMrs     zTimeRemainingColumn.render)FFN)rFrrrrrr))rkrlrmrnrrHrrorLrLrJrMrs rc@r/) FileSizeColumnzRenders completed filesize.rrrNr8cCstt|j}t|ddS)Show data completed.zprogress.filesizer3)r*decimalr}rFr8rIr data_sizerLrLrMr7s zFileSizeColumn.renderNr)r8rLrLrLrMrO4r9rOc@r/) TotalFileSizeColumnzRenders total filesize.rrrNr8cCs*|jdur tt|jnd}t|ddS)rPNrzprogress.filesize.totalr3)r{r*rQr}r8rRrLrLrMr@s zTotalFileSizeColumn.renderNr)r8rLrLrLrMrT=r9rTcs.eZdZdZddfdd ZdddZZS)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 separatorrzrrcrr)rWrGrH)rIrWrrJrLrMrHRszMofNCompleteColumn.__init__rrrNr8cCsPt|j}|jdurt|jnd}tt|}t||d|j|ddS)zShow completed/total.N?rIprogress.downloadr3)r}rFr{rrzr8rW)rIrrFr{Z total_widthrLrLrMrVs  zMofNCompleteColumn.render)rVN)rWrzrrr)r rLrLrJrMrUFs rUcs0eZdZdZ ddfd d ZdddZZS)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_unitsrrrrNrOcrr)rZrGrH)rIrZrrJrLrMrHhr zDownloadColumn.__init__rrr8cCst|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) rZKiBZMiBZGiBZTiBZPiBZEiBZZiBZYiBi) rZkBZMBZGBZTBZPBZEBZZBZYBr<r)rz,.frXrVrrYr3)r}rFr{rZr*r=r8)rIrrFZ unit_and_suffix_calculation_baser?r@Z precisionZcompleted_ratioZ completed_strr{Z total_ratioZ total_strZdownload_statusZ download_textrLrLrMrns2     zDownloadColumn.render)FN)rZrrrrNrOr)r rLrLrJrMras rc@r/) TransferSpeedColumnz&Renders human readable transfer speed.rrrNr8cCs@|jp|j}|durtdddStt|}t|dddS)zShow data transfer speed.NrXzprogress.data.speedr3z/s)rCrr8r*rQr})rIrrrArLrLrMrs  zTransferSpeedColumn.renderNr)r8rLrLrLrMr\r9r\c@s$eZdZUdZded< ded<dS)ProgressSamplez$Sample of progress for a given time.rCrrFN)rkrlrmrnrrLrLrLrMr]s r]c@sXeZdZUdZded< ded< ded< ded < d ed < d Zded < dZded< eedZ ded< ed dddZ ded< ed dddZ ded< d Z ded< edddddZ ded<ededZded < d5d"d#Zed6d$d%Zed7d&d'Zed7d(d)Zed6d*d+Zed5d,d-Zed7d.d/Zed7d0d1Zd8d3d4Zd S)9TaskzInformation regarding a progress task. This object should be considered read-only outside of the :class:`~Progress` class. r:rrzryr|r{rCrFGetTimeCallable _get_timeNr5Trvisible)default_factoryzDict[str, Any]fieldsF)defaultinitrepr start_time stop_timerCcCs tddS)Nr<)maxlenrrLrLrLrMs z Task.)rbrerfzDeque[ProgressSample] _progress)rfrbr_lockrNcCs|S)z(float: Get the current time, in seconds.)r`r\rLrLrMrrz Task.get_timecC |jduS)z#bool: Check if the task as started.N)rgr\rLrLrMr. z Task.startedcCs|jdurdS|j|jS)zPOptional[float]: Get the number of steps remaining, if a non-None total was set.Nr{rFr\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)rgrhrr\rLrLrMr6s   z Task.elapsedcCrm)zCheck if the task has finished.N)r5r\rLrLrMrrnz Task.finishedcCs.|jsdS|j|jd}tdtd|}|S)zOfloat: Get progress of task as a percentage. If a None total was set, returns 0Y@)r{rFminr-)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|]}|jVqdSrYr).0samplerLrLrM zTask.speed..)rgrlrkriterrr)rIr>Z total_timeZ iter_progressZtotal_completedrrLrLrMrs" $z Task.speedcCs:|jrdS|j}|s dS|j}|durdSt||}|S)zJOptional[float]: Get estimated time to completion, or ``None`` if no data.rqN)rrrpr )rIrrpZestimaterLrLrMrJs zTask.time_remainingrOcCs|jd|_d|_dS)zReset progress.N)rkclearr5rCr\rLrLrM_resets  z Task._reset)rNrCr)rNr|ri)rkrlrmrnrr5rardictrcrgrhrCrkrrlrrr.rpr6rrtrrJr|rLrLrLrMr^sZ              r^c @seZdZdZddddddddddd dddZedddZedd d!Zedd#d$Z edd&d'Z edd(d)Z dd*d+Z dd,d-Z dd/d0Zdd7d8Z  9  : ;dddGdHZ dddIdJddNdOZej P   ddddIdQddZd[Zej P   ddddIdQdd^d[Z _ P   ddddIdQddbd[ZddddeZddfdgZdddddddhddodpZddd9dddqddsdtZdddvdwZddxdyZdd{d|Zdd~dZdddZdddZ  9 ddddZdddZ 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. NTrqg>@F) rr~rspeed_estimate_periodrredirect_stdoutredirect_stderrrrexpandrUnion[str, ProgressColumn]rrr~rrrCr~rrrrOptional[GetTimeCallable]rrrNrOc Gs|dksJdt|_| p||_||_| |_| |_i|_td|_ t |p)t ||||||j d|_ |p9|jj|_|jj|_|jj|_dS)Nrzrefresh_per_second must be > 0)rr~rrrrget_renderable)rrlget_default_columnsrr~rr_tasksr: _task_indexr2r+rrSrrprintlog) rIrr~rr~rrrrrrrrLrLrMrH5s(  zProgress.__init__Tuple[ProgressColumn, ...]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>rLrLrMrYs zProgress.get_default_columnsr,cCrrY)rSrr\rLrLrMrxrzProgress.console List[Task]cC8|jt|jWdS1swYdS)zGet a list of Task instances.N)rllistrvaluesr\rLrLrMtasks| $zProgress.tasks List[TaskID]cCr)zA list of task IDs.N)rlrrkeysr\rLrLrMtask_idsrzProgress.task_idscCsZ|j |js WddStdd|jDWdS1s&wYdS)z'Check if all tasks have been completed.NTcsrurY)r)rvrrLrLrMrxryz$Progress.finished..)rlrallrr\rLrLrMrs $zProgress.finishedcCs|js |jjdddSdS)zStart the progress display.T)rPN)rrSr[r\rLrLrMr[szProgress.startcCs0|j|jjs|jjs|jdSdSdS)zStop the progress display.N)rSrrZis_interactiveZ is_jupyterrr\rLrLrMrs z Progress.stopr(cCrXrYrZr\rLrLrMr]r^zProgress.__enter__r_r`rarbrcrdcCrrY)rrgrLrLrMrhrzProgress.__exit__rrprvrwrxr{r|rFr}r@Optional[TaskID]ryrzrBc cs|dur tt|p d}|dur|j|||d}n|j|||d|jjrNt|||}|D] }|V|jd7_q/WddS1sGwYdS|j} |j } |D] }|V| |d| qVdS)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. Nror)) rCradd_taskrUrSr~r=rFrQrP) rIrwr{rFr@ryrBZ track_threadvaluerQrPrLrLrMrs(" zProgress.trackr)r@ryrrrcCsd}|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'r{Fr)rlrr{ ValueErrorrrUr)rIrr{r@ry total_bytesrLrLrMrszProgress.wrap_filer)r{r@ryrrrrrrrrc CrrYrL rIrrrrrrr{r@ryrLrLrMrz Progress.open"Union[Literal['r'], Literal['rt']]r#c CrrYrLrrLrLrMrrrrUnion[BinaryIO, TextIO]cCsdt|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)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)rfsortedrwarningswarnRuntimeWarningrst_sizerrUiorr TextIOWrapper)rIrrrrrrr{r@ry_moderrrrLrLrMrs>! r: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)rlrrgr)rIr@rrLrLrM 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)rlrrrgrh)rIr@rrrLrLrM stop_taskys  "zProgress.stop_task)r{rFrQryrarPrQraOptional[bool]rPrcrcKsH|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)rlrrFr{r|ryrarcrUrr~rkpopleftrappendr]r5r6rP)rIr@r{rFrQryrarPrcrcompleted_startupdate_completedrold_sample_timerkrrLrLrMrUsJ     " zProgress.update)r[r{rFraryr[c 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) rrlrr|rgr{rFrarcryr5rP) rIr@r[r{rFraryrcrrrLrLrMresets"  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)rrlrrFr~rkrrrrr]r{r5r6rrC) rIr@rQrrrrrrkrrLrLrMrQs>       "zProgress.advancecCs$|js|jjr|jdSdSdS)z*Refresh (render) the progress information.N)rrSrTrPr\rLrLrMrP szProgress.refreshr/cCst|}|S)z*Get a renderable for the progress display.)r-get_renderables)rIrrLrLrMrs zProgress.get_renderableIterable[RenderableType]ccs||j}|VdS)z5Get a number of renderables for the progress display.N)make_tasks_tabler)rItablerLrLrMrs  zProgress.get_renderablesrIterable[Task]r7csRdd|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)Tr#N)rrzr6rcopy)rvZ_columnrLrLrMrx"s  z,Progress.make_tasks_table..)rr))paddingrc3s.|]}t|tr|jdn|VqdS)r%N)rrzr&)rvcolumnr%rLrMrx/s )rr7Zgridrraadd_row)rIrZ table_columnsrrLr%rMrs   zProgress.make_tasks_tablecCs2|j |WdS1swYdS)z+Makes the Progress class itself renderable.N)rlrr\rLrLrM__rich__:s$zProgress.__rich__rrc 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`. )rarcr`rlr)N) rlr^rrrrr:r}rP) rIryr[r{rFrarcrZnew_task_indexrLrLrMr?s&  zProgress.add_taskcCs4|j |j|=WddS1swYdS)z]Delete a task if it exists. Args: task_id (TaskID): A task ID. N)rlr)rIr@rLrLrM remove_taskjs "zProgress.remove_task)rrrrr~rrrCr~rCrrrrrrrrrrrrrNrO)rNr)rNr,)rNr)rNrrri)rNr(rj)NrNrprv)rwrxr{r|rFr}r@rryrzrBrCrNrxrY) rrr{rr@rryrzrNrrNNN)rrrrrr}rrrrrrr{rr@rryrzrNr)rrrrrr}rrrrrrr{rr@rryrzrNr#rrNNN)rrrrrr}rrrrrrr{rr@rryrzrNr)r@r:rNrO)r@r:r{r|rFr|rQr|ryrrarrPrrcrrNrO)r@r:r[rr{r|rFr}rarryrrcrrNrO)r))r@r:rQrCrNrO)rNr/)rNr)rrrNr7)TrrrT)ryrzr[rr{r|rFr}rarrcrrNr:)!rkrlrmrnrHrDrrrrrrr[rr]rhrrtypingoverloadrrrrUrrQrPrrrrrrrLrLrLrMr%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)rrz[red]Downloadingr<rz[green]Processingz[yellow]ThinkingrErg333333?g{Gz?d)rpNrTNFNrqrrrsrtrurvFT)"rwrxryrzr{r|rFr}r~rrrrrrrrrCrr5rr5rr5rr5rBrCrrrrrNrx)rrr{r}ryrzr~rrrrrrrrrCrr5rr5rr5rr5rrrNrr)&rrrrrr}rrrrrrr{rryrzr~rrrrrrrrrCrr5rr5rr5rr5rrrNr)&rrrrrr}rrrrrrr{rryrzr~rrrrrrrrrCrr5rr5rr5rr5rrrNrr)&rrrrrr}rrrrrrr{rryrzr~rrrrrrrrrCrr5rr5rr5rr5rrrNr) __future__rrrrabcrr collectionsr dataclassesrrdatetimer r r mathr r operatorrosrr threadingrrrtypesrrrrrrrrrrrrr r!r"r#r$r%r&r'Ztyping_extensionsr(rr*r+rr,r-r.r/r!r0Zjupyterr1rSr2 progress_barr3rr4rr5rr6r7rr8r9r}r:r;rCr_r<r=rrrrrrrrr rrr0rrrOrTrUrr\r]r^rrkrandomtimeZpanelrZrulerZsyntaxrrZprogress_renderables itertoolsrZexamplesrr>rZtask1Ztask2Ztask3rrUsleeprandintrrrLrLrLrMs       T         * NgAV*2* H0  1  } T           $