o

�N�g�7�@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__��I/opt/saltstack/salt/lib/python3.10/site-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�Zellipsis)	�console�screen�auto_refreshr�	transient�redirect_stdout�redirect_stderr�vertical_overflow�get_renderable�
renderabler:r;r<rr=r>r?r@rArc	Cs�|d
ksJd�
�
|
|_|du
r|nt
�|_||_d|_||_||_d|_d|_t	�|_
d|_||_d|_
|r8dn
||_d|_||_|	|_|
|_t|��|	d�|_dS)Nr
zrefresh_per_second must be > 0FT)
r@)�_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__c


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

��zLive.get_renderabler0c	Cs�|j�d
|j
r	Wd
�
d
S|j�|�

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

|��
|j�	|�

|
rHz|�
�
WntyG


|��
�w|j
r_t||j�|_|j��
Wd
�
d
SWd
�
d
S1sjw



Y
d
S)z|Start live rendering display.

        Args:
            refresh (bool, optional): Also refresh. Defaults to False.
        NTF)r.rKr:Zset_liverD�set_alt_screenrE�show_cursor�_enable_redirect_ioZpush_render_hookr0�	Exceptionr,r<rrrL�start)r$r0r'r'r(rVhs0

�










�

�"�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.NFZvisibleT)r.rKr:Z
clear_liver<rLr,r@rE�
is_jupyterr0�_disable_redirect_ioZpop_render_hook�is_terminal�linerSrRr=�controlrNZrestore_cursorrJ�closer+r'r'r(r,�sX

�








�











��










����"�z	Live.stopc

Cs|j|j
du
d
�

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

zLive.__enter__�exc_type�exc_val�exc_tbcCs|��
dSr))
r,)r$r_r`rar'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:rYrWrF�
isinstance�sys�stdoutrrHr
rG�stderrrIr+r'r'r(rT�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)rHr
rdrerIrfr+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.
        )rArErrQr'r'r(rB�s
zLive.renderabler]c
Csdt|
t
�r|j�|
�
}
|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)rc�strr:Z
render_strr.rCr0)r$rBr0r'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.rNZset_renderablerBr:rWZIPython.displayriZ
ipywidgetsrj�ImportError�warnings�warnrJZclear_output�printrYZis_dumb_terminalrrKr=)r$rirjrlr'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)r@rNr:Zis_interactiver.rEr�homeZposition_cursorrKr=)r$ro�resetr'r'r(�process_renderables�s$


��
����
�zLive.process_renderablesr))
Fr2)rr)r3r4r5r6r
rr�boolr7rrr#�propertyrOrArVr,r^r�
BaseExceptionrrbrTrXrBrhr0r	rrrr'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)
Zline_numbersZfooZbarZbaz�
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)Trd�	threadingrrr�typesr�typingrrrr	r
rrr
rPrr:rrrrr[rZ
file_proxyrZjupyterrZlive_renderrrr;rr�rrrr3�random�time�	itertoolsrwrxryZalignrzrZpanelr{Zruler|Zsyntaxr}�tabler~Zadd_rowZprogress_renderablesZexamplesZ	exchangesZ
live_tabler�rgr7�__annotations__�range�index�lenZselect_exchangeZexchange�sleep�randint�log�next�pop�list�keysZ
add_column�items�source�destZ
exchange_raterh�centerr'r'r'r(�<module>
s�


(








m











�







�











�













��	��$��