U

�{�e�7�@sTUdd
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�rPdd
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:d/d0d1d2d3d4d5d6d7d8d9d:d;d<d=d>d?d@dAgZ;e%edB�
�
�HZ<iZ=e+e,e>e>fe?fe@dC<eAdD�
D�
]ZBe;eBeCe;�
ZDe;D]�ZEeEeDk�rT�qBe(�FdE�

e'�GddF�dk�r~e�HeIe:�
�

dGe'�'�dHde=eDeEf<eCe=�
eCe;�
dk�r�e=�JeKe=�L��
d�

e7dIdJ�
Z6e6�MdK�

e6�MdL�

e6�MdM�

e=�N�D]6\\ZOZPZQe6�8eOePe#eQdN�eQdOk�r dPndQdR��
�q�e<�Re.�Se6�
�

�qB�q(W5QRXd
S)S�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)
�TextcsFeZ
dZd
Zdedd��f
dd�Zdd�
dd	�Zdd�
d
d�Z�ZS)�_RefreshThreadz3A thread that calls refresh() at regular intervals.�LiveN)�live�refresh_per_second�returncs&|
|_||_
t�|_t�jd
d�

dS)NT)
�daemon)rrr�done�super�__init__)�selfrr�
�	__class__��9/tmp/pip-unpacked-wheel-_0scjqea/pip/_vendor/rich/live.pyr#s



z_RefreshThread.__init__�
rc

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

	Cs@|j�
d
|j�
s<|jj�
|j��s0|j��
W5QRXqdS)Nr)r!�waitrr�_lock�is_set�refreshr,r'r'r(�runs





z_RefreshThread.run)	�__name__�
__module__�__qualname__�__doc__�floatr#r-r2�
__classcell__r'r'r%r(rs
rc@s<
eZ
dZd
Zd)dddddddddd�	eeeeeeeeeee	ee
gefdd�d	d
�Zeed�
dd
��
Z
ed�
dd�Zd*edd�dd�Zdd�
dd�Zdd�
dd�Zeeeeeeedd�dd�Zdd�
dd�Zdd�
dd�Zeed�
dd��
Zdd �
eedd!�d"d#�Zdd�
d$d%�Zeeeed&�d'd(�ZdS)+ra�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�Zellipsis)	�console�screen�auto_refreshr�	transient�redirect_stdout�redirect_stderr�vertical_overflow�get_renderable)�
renderabler:r;r<rr=r>r?r@rArc	Cs�|d
kstd�
�
|
|_
|dk	r"|nt�|_||_d|_||_||_d|_d|_	t
�|_d|_||_
d|_|rpdn||_d|_||_|	|_|
|_t|��|	d�|_dS)Nr
zrefresh_per_second must be > 0FT)
r@)�AssertionError�_renderablerr:�_screen�_alt_screen�_redirect_stdout�_redirect_stderr�_restore_stdout�_restore_stderrrr/�
ipy_widgetr<�_startedr=�_refresh_threadrr@�_get_renderablerrA�_live_render)r$rBr:r;r<rr=r>r?r@rAr'r'r(r#3s,














�z
Live.__init__r)c


Cs|jS)
z'Check if live display has been started.)
rLr,r'r'r(�
is_started[szLive.is_startedc
Cs |jdk	r|��n|j
}
|
pd
S)N�)rNrD�r$rBr'r'r(rA`s
�
�zLive.get_renderable)r1rc	Cs�|j��
|j
rW5QR�d
S|j�|�

d|_
|jrB|j�d�
|_|j�d�

|��
|j�	|�

|
r�z|�
�
Wntk
r�


|��
�YnX|j
r�t||j�|_|j��
W5QRXd
S)z|Start live rendering display.

        Args:
            refresh (bool, optional): Also refresh. Defaults to False.
        NTF)r/rLr:Zset_liverE�set_alt_screenrF�show_cursor�_enable_redirect_ioZpush_render_hookr1�	Exceptionr-r<rrrM�start)r$r1r'r'r(rWhs&
















z
Live.startc

Cs
|j�
�
|j
sW5QR�d
S|j��
d|_
|jrN|jd
k	rN|j��
d
|_d|_|j��
z|j
st|jjst|��
W5|��
|j�	�
|j
s�|jjr�|j��
|j�
d�

|j
r�|j�d�

|jr�|j
s�|j�|j���

|jd
k	r�|jr�|j��
XW5QRXW5QRXd
S)zStop live rendering display.NFZvisibleT)r/rLr:Z
clear_liver<rMr-r@�_disable_redirect_ioZpop_render_hookrF�is_terminal�linerTrSr=�controlrOZrestore_cursorrK�close�
is_jupyterr1r,r'r'r(r-�s0























z	Live.stopc

Cs|j|j
dk	d
�

|S)N�
r1)rWrDr,r'r'r(�	__enter__�s

zLive.__enter__)�exc_type�exc_val�exc_tbrcCs|��
dSr*)
r-)r$r`rarbr'r'r(�__exit__�sz
Live.__exit__c

Cst|jj
s|jjrp|jr@ttjt�s@tj|_t	d
t|jtj��t_|j
rpttjt�sptj|_t	d
t|jtj��t_dS)z&Enable redirecting of stdout / stderr.rN)
r:rYr]rG�
isinstance�sys�stdoutrrIr
rH�stderrrJr,r'r'r(rU�s





zLive._enable_redirect_ioc

Cs8|jrt
d
|j�t_d|_|jr4t
d
|j�t_d|_dS)z'Disable redirecting of stdout / stderr.rN)rIr
rerfrJrgr,r'r'r(rX�s




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

        Returns:
            RenderableType: Displayed renderable.
        )rArFrrRr'r'r(rB�s
zLive.renderabler^)rBr1rc
	Cs>t|
t
�r|j�|
�
}
|j�
|
|_|r0|��
W5QRXd
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)rd�strr:Z
render_strr/rDr1)r$rBr1r'r'r(�update�s





zLive.updatec

Cs"
|j�
�
|j
�|j�

|jjr�zd
dlm}

d
dlm	}
Wn&t
k
rb


d
dl}|�d�

YnNX|j
dkr�|�|_
|
|j
�

|j
�$
|j
jdd�

|j�|j
j�

W5QRXnb|jjr�|jjs�|j�
|j�t��

W5QRXn0|j�
s|j�
s|j�
|j�t��

W5QRXW5QRXdS)z&Update the display of the Live Render.r
)
�display)
�OutputNz(install "ipywidgets" for Jupyter supportT)
r.)r/rOZset_renderablerBr:r]ZIPython.displayrjZ
ipywidgetsrk�ImportError�warnings�warnrKZclear_output�printrYZis_dumb_terminalrrLr=)r$rjrkrmr'r'r(r1�s0
















�
�
zLive.refresh)�renderablesrc	Csj|j|j
_|jjrN|j�.
|jr(t��n|j
��}|f
|
|j
f
�}
W5QRXn|j	sf|j
sf|
|j
f
�}
|
S)
z;Process renderables to restore cursor and display progress.)r@rOr:Zis_interactiver/rFr�homeZposition_cursorrLr=)r$rp�resetr'r'r(�process_renderables�s

�
��
�zLive.process_renderables)
N)
F)r3r4r5r6r
rr�boolr7rrr#�propertyrPrArWr-r_r�
BaseExceptionrrcrUrXrBrir1r	rrsr'r'r'r(r#sZ
�







�








�(




�
	
	
�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)
Zline_numbersZfoo�barZbaz�
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...ZexamplezPretty printed)�type�textz	Syntax...zGive it a try!ZSGDZMYRZEURZUSDZAUDZJPYZCNHZHKDZCADZINRZDKKZGBPZRUBZNZDZMXNZIDRZTWDZTHBZVND)
r:�exchange_rate_dict�dg�������?�
��i@
zExchange Rates)
�titlezSource CurrencyzDestination Currencyz
Exchange Ratez.4fg�?ZredZgreen)
�style)Tre�	threadingrrr�typesr�typingrrrr	r
rrr
rQrr:rrrrr[rZ
file_proxyrZjupyterrZlive_renderrrr;rr�rrrr3�random�time�	itertoolsrxryrzZalignr{rZpanelr|Zruler}Zsyntaxr~�tablerZadd_rowZprogress_renderablesZexamplesZ	exchangesZ
live_tabler�rhr7�__annotations__�range�index�lenZselect_exchangeZexchange�sleep�randint�log�next�pop�list�keysZ
add_column�items�source�destZ
exchange_rateri�centerr'r'r'r(�<module>
s�


(






m












�







�


















�










�













��