o

@%Ne�5�@sJUdd
lZddl
mZmZmZ
ddlmZ
ddlmZm	Z	m
Z
mZmZm
Z
mZmZ
ddlmZ
ddlmZmZmZmZ
ddlmZ
dd	lmZ
dd
lmZ
ddlmZmZ
ddl m!Z!
dd
l"m#Z#
Gdd�de�Z$Gdd�dee�Z%e&dk�
r�dd
l'Z'dd
l(Z(ddl)m*Z*
ddlm+Z+mZm,Z,
ddl-m.Z.
ddlmZ
ddl/m%Z%
ddl0m1Z1
ddl2m3Z3
ddl4m5Z5
ddl6m7Z7
e�Ze5dddd�Z4e7d d!d"�Z6e6�8d#d$d%�
d&e1d'�
d(e6d)d*d+d,�d-e4e3d.�
g	Z9e*e9�
Z:gd/�
Z;e%ed0�
��Z<iZ=e+e,e>e>fe?fe@d1<eAd2�
D]�ZBe;eBeCe;�
ZDe;D]ZEeEeDk�
r�
qe(�Fd3�

e'�Gdd4�dk�
r,e�HeIe:�
�

d5e'�'�d6de=eDeEf<eCe=�
eCe;�
dk�
rPe=�JeKe=�L��
d�

e7d7d8�
Z6e6�Md9�

e6�Md:�

e6�Md;�

e=�N�D]\\ZOZPZQe6�8eOePe#eQd<�eQd=k�
r}d>n
d?d@��
�
qhe<�Re.�Se6�
�

�
q�
qWd
�
d
S1�
s�w



Y
d
Sd
S)A�N)�Event�RLock�Thread)
�
TracebackType)�IO�Any�Callable�List�Optional�TextIO�Type�cast�
)
�get_console)�Console�ConsoleRenderable�RenderableType�
RenderHook)
�Control)
�	FileProxy)
�JupyterMixin)�
LiveRender�VerticalOverflowMethod)
�Screen)
�TextcsBeZ
dZd
Zdddeddf�f
dd�Zd
d	d
�Zd
dd�Z�ZS)�_RefreshThreadz3A thread that calls refresh() at regular intervals.�live�Live�refresh_per_second�returnNcs&|
|_||_
t�|_t�jd
d�

dS)NT)
�daemon)rrr�done�super�__init__)�selfrr�
�	__class__��7/usr/lib/python3/dist-packages/pip/_vendor/rich/live.pyr#s



z_RefreshThread.__init__c

Cs|j�
�
dS�
N)r!�set�
r$r'r'r(�stops
z_RefreshThread.stopc

Csh|j�
d
|j�
s2|jj�
|j��s|j��
Wd�
n1s"w



Y
|j�
d
|j�
r	dSdS)Nr)r!�waitrr�_lock�is_set�refreshr+r'r'r(�runs






���z_RefreshThread.run�rN)	�__name__�
__module__�__qualname__�__doc__�floatr#r,r1�
__classcell__r'r'r%r(rs


rc@sL
eZ
dZd
Z	d3dddddddddd�	deed	eed
ededed
ededede	dee
gefddfdd�Zedefdd��
Z
defdd�Zd4deddfdd�Zd5dd�Zd6dd�Zd eeed!eed"eeddfd#d$�Zd5d%d&�Zd5d'd(�Zedefd)d*��
Zdd+�
dededdfd,d-�Zd5d.d/�Zd0eedeefd1d2�ZdS)7ra�Renders an auto-updating live display of any given renderable.

    Args:
        renderable (RenderableType, optional): The renderable to live display. Defaults to displaying nothing.
        console (Console, optional): Optional Console instance. Default will an internal Console instance writing to stdout.
        screen (bool, optional): Enable alternate screen mode. Defaults to False.
        auto_refresh (bool, optional): Enable auto refresh. If disabled, you will need to call `refresh()` or `update()` with refresh flag. Defaults to True
        refresh_per_second (float, optional): Number of times per second to refresh the live display. Defaults to 4.
        transient (bool, optional): Clear the renderable on exit (has no effect when screen=True). 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.
        vertical_overflow (VerticalOverflowMethod, optional): How to handle renderable when it is too tall for the console. Defaults to "ellipsis".
        get_renderable (Callable[[], RenderableType], optional): Optional callable to get renderable. Defaults to None.
    NFT��ellipsis)	�console�screen�auto_refreshr�	transient�redirect_stdout�redirect_stderr�vertical_overflow�get_renderable�
renderabler;r<r=rr>r?r@rArBrc	Cs�|d
ksJd�
�
|
|_|du
r|nt
�|_||_d|_||_||_d|_d|_t	�|_
d|_||_d|_
|r8dn
||_d|_||_|	|_|
|_t|��|	d�|_dS)Nr
zrefresh_per_second must be > 0FT)
rA)�_renderablerr;�_screen�_alt_screen�_redirect_stdout�_redirect_stderr�_restore_stdout�_restore_stderrrr.�
ipy_widgetr=�_startedr>�_refresh_threadrrA�_get_renderablerrB�_live_render)r$rCr;r<r=rr>r?r@rArBr'r'r(r#3s*














�z
Live.__init__c


Cs|jS)
z'Check if live display has been started.)
rLr+r'r'r(�
is_started[szLive.is_startedc
Cs |jdu
r	|��n|j
}
|
pd
S)N�)rNrD�r$rCr'r'r(rB`s

��zLive.get_renderabler0cCs�|j�U
|j
r	Wd
�
d
S|j�|�

d|_
|jr#|j�d�
|_|j�d�

|��
|j�	|�

|
r9|�
�
|jrPt||j
�|_|j��
Wd
�
d
SWd
�
d
S1s[w



Y
d
S)z|Start live rendering display.

        Args:
            refresh (bool, optional): Also refresh. Defaults to False.
        NTF)r.rLr;�set_liverE�set_alt_screenrF�show_cursor�_enable_redirect_io�push_render_hookr0r=rrrM�start)r$r0r'r'r(rXhs&

�










�"�z
Live.startc

Cs�
|j��
|j
s	Wd
�
d
S|j��
d|_
|jr(|jd
u
r(|j��
d
|_d|_|j��
zM|js;|jj	s;|�
�
W|��
|j��
|jsQ|jj
rQ|j��
|j�d�

|jr`|j�d�

|jro|jso|j�|j���

|jd
u
r||jr||j��
nC|��
|j��
|js�|jj
r�|j��
|j�d�

|jr�|j�d�

|jr�|js�|j�|j���

|jd
u
r�|jr�|j��
wwwWd
�
n1s�w



Y
Wd
�
d
SWd
�
d
S1s�w



Y
d
S)zStop live rendering display.NF�visibleT)r.rLr;�
clear_liver=rMr,rArF�
is_jupyterr0�_disable_redirect_io�pop_render_hook�is_terminal�linerUrTr>�controlrO�restore_cursorrK�closer+r'r'r(r,~sX

�








�











��










����"�z	Live.stopc

Cs|j|j
du
d
�

|S)N�
r0)rXrDr+r'r'r(�	__enter__�s

zLive.__enter__�exc_type�exc_val�exc_tbcCs|��
dSr))
r,)r$rerfrgr'r'r(�__exit__�sz
Live.__exit__c

Cs�|jj
s|jjr:|jr ttjt�s tj|_t	d
t|jtj��t_|j
r<ttjt�s>tj|_t	d
t|jtj��t_dSdSdSdS)z&Enable redirecting of stdout / stderr.rN)
r;r^r[rG�
isinstance�sys�stdoutrrIr
rH�stderrrJr+r'r'r(rV�s





�zLive._enable_redirect_ioc

Cs<|jr
t
d
|j�t_d|_|jrt
d
|j�t_d|_dSdS)z'Disable redirecting of stdout / stderr.rN)rIr
rjrkrJrlr+r'r'r(r\�s





�zLive._disable_redirect_ioc
Cs|��}
|j
rt|
�
S|
S)
zwGet the renderable that is being displayed

        Returns:
            RenderableType: Displayed renderable.
        )rBrFrrRr'r'r(rC�s
zLive.renderablercc
CsN|j�
|
|_
|r|��
Wd
�
d
SWd
�
d
S1s w



Y
d
S)z�Update the renderable that is being displayed

        Args:
            renderable (RenderableType): New renderable to use.
            refresh (bool, optional): Refresh the display. Defaults to False.
        N)r.rDr0)r$rCr0r'r'r(�update�s



�"�zLive.updatec
	Cs�
|j��
|j
�|j�

|jjrazd
dlm}

d
dlm	}
Wnt
y/


d
dl}|�d�

Yn�w|j
dur>|�|_
|
|j
�

|j
�
|j
jdd�

|j�|j
j�

Wd�
n1s[w



Y
nK|jjr�|jjs�|j�
|j�t��

Wd�
n1s~w



Y
n@|js�|js�|j�
|j�t��

Wd�
n81s�w



Y
Wd�
dSWd�
dSWd�
dSWd�
dSWd�
dSWd�
dSWd�
dS1s�w



Y
dS)z&Update the display of the Live Render.r
)
�display)
�OutputNz(install "ipywidgets" for Jupyter supportT)
r-)r.rO�set_renderablerCr;r[�IPython.displayrn�
ipywidgetsro�ImportError�warnings�warnrK�clear_output�printr^�is_dumb_terminalrrLr>)r$rnrortr'r'r(r0�sV






�





��

���
�
���	����"�zLive.refresh�renderablescCs�|j|j
_|jjr3|j�
|jrt��n|j
��}|g
|
�
|j
�
}
Wd
�
|
S1s,w



Y
|
S|j	s@|j
s@g|
�
|j
�
}
|
S)z;Process renderables to restore cursor and display progress.N)rArOr;�is_interactiver.rFr�home�position_cursorrLr>)r$ry�resetr'r'r(�process_renderables�s$


��
����
�zLive.process_renderablesr))
Fr2)rr)r3r4r5r6r
rr�boolr7rrr#�propertyrPrBrXr,rdr�
BaseExceptionrrhrVr\rCrmr0r	rr~r'r'r'r(r#s|
�







�������	�
���
�(



���
�


	
	

��r�__main__)
�cycle)�Dictr	�Tuple)
�Align)
r)
r)
�Panel)
�Rule)
�Syntax)
�Tablea~
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_value�pythonT)
�line_numbers�foo�bar�baz�
1�
2�
3z�You can make the terminal shorter and taller to see the live table hideText 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)�type�textz	Syntax...zGive it a try!)�SGD�MYR�EUR�USD�AUD�JPY�CNH�HKD�CAD�INR�DKK�GBP�RUB�NZD�MXN�IDR�TWD�THB�VND)
r;�exchange_rate_dict�dg�������?�
��i@
zExchange Rates)
�titlezSource CurrencyzDestination Currencyz
Exchange Ratez.4fg�?�red�green)
�style)Trj�	threadingrrr�typesr�typingrrrr	r
rrr
rQrr;rrrrr`r�
file_proxyr�jupyterr�live_renderrrr<rr�rrrr3�random�time�	itertoolsr�r�r��alignr�r�panelr��ruler��syntaxr��tabler��add_row�progress_renderables�examples�	exchanges�
live_tabler��strr7�__annotations__�range�index�len�select_exchange�exchange�sleep�randint�log�next�pop�list�keys�
add_column�items�source�dest�
exchange_raterm�centerr'r'r'r(�<module>
s�


(








c











�







�











�













��	��$��