FM / rich

/opt/imunify360/venv/lib/python3.11/site-packages/pip/_vendor/rich/

/opt/imunify360/venv/lib/python3.11/site-packages/pip/_vendor/rich

Name	Size	Mode	Actions
__pycache__/	-	0755	rm
abc.py	890	0644	edit dl rm
align.py	10324	0644	edit dl rm
ansi.py	6921	0644	edit dl rm
bar.py	3263	0644	edit dl rm
box.py	10686	0644	edit dl rm
cells.py	5130	0644	edit dl rm
color.py	18211	0644	edit dl rm
color_triplet.py	1054	0644	edit dl rm
columns.py	7131	0644	edit dl rm
console.py	100849	0644	edit dl rm
constrain.py	1288	0644	edit dl rm
containers.py	5502	0644	edit dl rm
control.py	6487	0644	edit dl rm
default_styles.py	8257	0644	edit dl rm
diagnose.py	1025	0644	edit dl rm
emoji.py	2367	0644	edit dl rm
errors.py	642	0644	edit dl rm
filesize.py	2484	0644	edit dl rm
file_proxy.py	1683	0644	edit dl rm
highlighter.py	9586	0644	edit dl rm
json.py	5031	0644	edit dl rm
jupyter.py	3252	0644	edit dl rm
layout.py	14004	0644	edit dl rm
LICENSE	1056	0644	edit dl rm
live.py	15180	0644	edit dl rm
live_render.py	3521	0644	edit dl rm
logging.py	12468	0644	edit dl rm
markup.py	8451	0644	edit dl rm
measure.py	5305	0644	edit dl rm
padding.py	4908	0644	edit dl rm
pager.py	828	0644	edit dl rm
palette.py	3396	0644	edit dl rm
panel.py	11157	0644	edit dl rm
pretty.py	36391	0644	edit dl rm
progress.py	60408	0644	edit dl rm
progress_bar.py	8162	0644	edit dl rm
prompt.py	12447	0644	edit dl rm
protocol.py	1391	0644	edit dl rm
py.typed	0	0644	edit dl rm
region.py	166	0644	edit dl rm
repr.py	4431	0644	edit dl rm
rule.py	4602	0644	edit dl rm
scope.py	2843	0644	edit dl rm
screen.py	1591	0644	edit dl rm
segment.py	24743	0644	edit dl rm
spinner.py	4214	0644	edit dl rm
status.py	4424	0644	edit dl rm
style.py	26990	0644	edit dl rm
styled.py	1258	0644	edit dl rm
syntax.py	36371	0644	edit dl rm
table.py	40049	0644	edit dl rm
terminal_theme.py	3370	0644	edit dl rm
text.py	47552	0644	edit dl rm
theme.py	3771	0644	edit dl rm
themes.py	102	0644	edit dl rm
traceback.py	35861	0644	edit dl rm
tree.py	9451	0644	edit dl rm
_cell_widths.py	10209	0644	edit dl rm
_emoji_codes.py	140235	0644	edit dl rm
_emoji_replace.py	1064	0644	edit dl rm
_export_format.py	2128	0644	edit dl rm
_extension.py	265	0644	edit dl rm
_fileno.py	799	0644	edit dl rm
_inspect.py	9656	0644	edit dl rm
_log_render.py	3225	0644	edit dl rm
_loop.py	1236	0644	edit dl rm
_null_file.py	1394	0644	edit dl rm
_palettes.py	7063	0644	edit dl rm
_pick.py	423	0644	edit dl rm
_ratio.py	5325	0644	edit dl rm
_spinners.py	19919	0644	edit dl rm
_stack.py	351	0644	edit dl rm
_timer.py	417	0644	edit dl rm
_win32_console.py	22755	0644	edit dl rm
_windows.py	1925	0644	edit dl rm
_windows_renderer.py	2783	0644	edit dl rm
_wrap.py	3404	0644	edit dl rm
__init__.py	6090	0644	edit dl rm
__main__.py	7896	0644	edit dl rm

Edit: /opt/imunify360/venv/lib/python3.11/site-packages/pip/_vendor/rich/live.py (15180B)

from __future__ import annotations

import sys
from threading import Event, RLock, Thread
from types import TracebackType
from typing import IO, TYPE_CHECKING, Any, Callable, List, Optional, TextIO, Type, cast

from . import get_console
from .console import Console, ConsoleRenderable, Group, RenderableType, RenderHook
from .control import Control
from .file_proxy import FileProxy
from .jupyter import JupyterMixin
from .live_render import LiveRender, VerticalOverflowMethod
from .screen import Screen
from .text import Text

if TYPE_CHECKING:
    # Can be replaced with `from typing import Self` in Python 3.11+
    from typing_extensions import Self  # pragma: no cover

class _RefreshThread(Thread):
    """A thread that calls refresh() at regular intervals."""

def __init__(self, live: "Live", refresh_per_second: float) -> None:
        self.live = live
        self.refresh_per_second = refresh_per_second
        self.done = Event()
        super().__init__(daemon=True)

def stop(self) -> None:
        self.done.set()

def run(self) -> None:
        while not self.done.wait(1 / self.refresh_per_second):
            with self.live._lock:
                if not self.done.is_set():
                    self.live.refresh()

class Live(JupyterMixin, RenderHook):
    """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. Defaults to 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.
    """

def __init__(
        self,
        renderable: Optional[RenderableType] = None,
        *,
        console: Optional[Console] = None,
        screen: bool = False,
        auto_refresh: bool = True,
        refresh_per_second: float = 4,
        transient: bool = False,
        redirect_stdout: bool = True,
        redirect_stderr: bool = True,
        vertical_overflow: VerticalOverflowMethod = "ellipsis",
        get_renderable: Optional[Callable[[], RenderableType]] = None,
    ) -> None:
        assert refresh_per_second > 0, "refresh_per_second must be > 0"
        self._renderable = renderable
        self.console = console if console is not None else get_console()
        self._screen = screen
        self._alt_screen = False

self._redirect_stdout = redirect_stdout
        self._redirect_stderr = redirect_stderr
        self._restore_stdout: Optional[IO[str]] = None
        self._restore_stderr: Optional[IO[str]] = None

self._lock = RLock()
        self.ipy_widget: Optional[Any] = None
        self.auto_refresh = auto_refresh
        self._started: bool = False
        self.transient = True if screen else transient

self._refresh_thread: Optional[_RefreshThread] = None
        self.refresh_per_second = refresh_per_second

self.vertical_overflow = vertical_overflow
        self._get_renderable = get_renderable
        self._live_render = LiveRender(
            self.get_renderable(), vertical_overflow=vertical_overflow
        )
        self._nested = False

@property
    def is_started(self) -> bool:
        """Check if live display has been started."""
        return self._started

def get_renderable(self) -> RenderableType:
        renderable = (
            self._get_renderable()
            if self._get_renderable is not None
            else self._renderable
        )
        return renderable or ""

def start(self, refresh: bool = False) -> None:
        """Start live rendering display.

Args:
            refresh (bool, optional): Also refresh. Defaults to False.
        """
        with self._lock:
            if self._started:
                return
            self._started = True

if not self.console.set_live(self):
                self._nested = True
                return

if self._screen:
                self._alt_screen = self.console.set_alt_screen(True)
            self.console.show_cursor(False)
            self._enable_redirect_io()
            self.console.push_render_hook(self)
            if refresh:
                try:
                    self.refresh()
                except Exception:
                    # If refresh fails, we want to stop the redirection of sys.stderr,
                    # so the error stacktrace is properly displayed in the terminal.
                    # (or, if the code that calls Rich captures the exception and wants to display something,
                    # let this be displayed in the terminal).
                    self.stop()
                    raise
            if self.auto_refresh:
                self._refresh_thread = _RefreshThread(self, self.refresh_per_second)
                self._refresh_thread.start()

def stop(self) -> None:
        """Stop live rendering display."""
        with self._lock:
            if not self._started:
                return
            self._started = False
            self.console.clear_live()
            if self._nested:
                if not self.transient:
                    self.console.print(self.renderable)
                return

if self.auto_refresh and self._refresh_thread is not None:
                self._refresh_thread.stop()
                self._refresh_thread = None
            # allow it to fully render on the last even if overflow
            self.vertical_overflow = "visible"
            with self.console:
                try:
                    if not self._alt_screen and not self.console.is_jupyter:
                        self.refresh()
                finally:
                    self._disable_redirect_io()
                    self.console.pop_render_hook()
                    if not self._alt_screen and self.console.is_terminal:
                        self.console.line()
                    self.console.show_cursor(True)
                    if self._alt_screen:
                        self.console.set_alt_screen(False)
                    if self.transient and not self._alt_screen:
                        self.console.control(self._live_render.restore_cursor())
                    if self.ipy_widget is not None and self.transient:
                        self.ipy_widget.close()  # pragma: no cover

def __enter__(self) -> Self:
        self.start(refresh=self._renderable is not None)
        return self

def __exit__(
        self,
        exc_type: Optional[Type[BaseException]],
        exc_val: Optional[BaseException],
        exc_tb: Optional[TracebackType],
    ) -> None:
        self.stop()

def _enable_redirect_io(self) -> None:
        """Enable redirecting of stdout / stderr."""
        if self.console.is_terminal or self.console.is_jupyter:
            if self._redirect_stdout and not isinstance(sys.stdout, FileProxy):
                self._restore_stdout = sys.stdout
                sys.stdout = cast("TextIO", FileProxy(self.console, sys.stdout))
            if self._redirect_stderr and not isinstance(sys.stderr, FileProxy):
                self._restore_stderr = sys.stderr
                sys.stderr = cast("TextIO", FileProxy(self.console, sys.stderr))

def _disable_redirect_io(self) -> None:
        """Disable redirecting of stdout / stderr."""
        if self._restore_stdout:
            sys.stdout = cast("TextIO", self._restore_stdout)
            self._restore_stdout = None
        if self._restore_stderr:
            sys.stderr = cast("TextIO", self._restore_stderr)
            self._restore_stderr = None

@property
    def renderable(self) -> RenderableType:
        """Get the renderable that is being displayed

Returns:
            RenderableType: Displayed renderable.
        """
        live_stack = self.console._live_stack
        renderable: RenderableType
        if live_stack and self is live_stack[0]:
            # The first Live instance will render everything in the Live stack
            renderable = Group(*[live.get_renderable() for live in live_stack])
        else:
            renderable = self.get_renderable()
        return Screen(renderable) if self._alt_screen else renderable

def update(self, renderable: RenderableType, *, refresh: bool = False) -> None:
        """Update the renderable that is being displayed

Args:
            renderable (RenderableType): New renderable to use.
            refresh (bool, optional): Refresh the display. Defaults to False.
        """
        if isinstance(renderable, str):
            renderable = self.console.render_str(renderable)
        with self._lock:
            self._renderable = renderable
            if refresh:
                self.refresh()

def refresh(self) -> None:
        """Update the display of the Live Render."""
        with self._lock:
            self._live_render.set_renderable(self.renderable)
            if self._nested:
                if self.console._live_stack:
                    self.console._live_stack[0].refresh()
                return

if self.console.is_jupyter:  # pragma: no cover
                try:
                    from IPython.display import display
                    from ipywidgets import Output
                except ImportError:
                    import warnings

warnings.warn('install "ipywidgets" for Jupyter support')
                else:
                    if self.ipy_widget is None:
                        self.ipy_widget = Output()
                        display(self.ipy_widget)

with self.ipy_widget:
                        self.ipy_widget.clear_output(wait=True)
                        self.console.print(self._live_render.renderable)
            elif self.console.is_terminal and not self.console.is_dumb_terminal:
                with self.console:
                    self.console.print(Control())
            elif (
                not self._started and not self.transient
            ):  # if it is finished allow files or dumb-terminals to see final result
                with self.console:
                    self.console.print(Control())

def process_renderables(
        self, renderables: List[ConsoleRenderable]
    ) -> List[ConsoleRenderable]:
        """Process renderables to restore cursor and display progress."""
        self._live_render.vertical_overflow = self.vertical_overflow
        if self.console.is_interactive:
            # lock needs acquiring as user can modify live_render renderable at any time unlike in Progress.
            with self._lock:
                reset = (
                    Control.home()
                    if self._alt_screen
                    else self._live_render.position_cursor()
                )
                renderables = [reset, *renderables, self._live_render]
        elif (
            not self._started and not self.transient
        ):  # if it is finished render the final output for files or dumb_terminals
            renderables = [*renderables, self._live_render]

return renderables

if __name__ == "__main__":  # pragma: no cover
    import random
    import time
    from itertools import cycle
    from typing import Dict, List, Tuple

from .align import Align
    from .console import Console
    from .live import Live as Live
    from .panel import Panel
    from .rule import Rule
    from .syntax import Syntax
    from .table import Table

console = Console()

syntax = Syntax(
        '''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''',
        "python",
        line_numbers=True,
    )

table = Table("foo", "bar", "baz")
    table.add_row("1", "2", "3")

progress_renderables = [
        "You can make the terminal shorter and taller to see the live table hide"
        "Text may be printed while the progress bars are rendering.",
        Panel("In fact, [i]any[/i] renderable will work"),
        "Such as [magenta]tables[/]...",
        table,
        "Pretty printed structures...",
        {"type": "example", "text": "Pretty printed"},
        "Syntax...",
        syntax,
        Rule("Give it a try!"),
    ]

examples = cycle(progress_renderables)

exchanges = [
        "SGD",
        "MYR",
        "EUR",
        "USD",
        "AUD",
        "JPY",
        "CNH",
        "HKD",
        "CAD",
        "INR",
        "DKK",
        "GBP",
        "RUB",
        "NZD",
        "MXN",
        "IDR",
        "TWD",
        "THB",
        "VND",
    ]
    with Live(console=console) as live_table:
        exchange_rate_dict: Dict[Tuple[str, str], float] = {}

for index in range(100):
            select_exchange = exchanges[index % len(exchanges)]

for exchange in exchanges:
                if exchange == select_exchange:
                    continue
                time.sleep(0.4)
                if random.randint(0, 10) < 1:
                    console.log(next(examples))
                exchange_rate_dict[(select_exchange, exchange)] = 200 / (
                    (random.random() * 320) + 1
                )
                if len(exchange_rate_dict) > len(exchanges) - 1:
                    exchange_rate_dict.pop(list(exchange_rate_dict.keys())[0])
                table = Table(title="Exchange Rates")

table.add_column("Source Currency")
                table.add_column("Destination Currency")
                table.add_column("Exchange Rate")

for (source, dest), exchange_rate in exchange_rate_dict.items():
                    table.add_row(
                        source,
                        dest,
                        Text(
                            f"{exchange_rate:.4f}",
                            style="red" if exchange_rate < 1.0 else "green",
                        ),
                    )

live_table.update(Align.center(table))

cmd: