festival.edmaven.com:80

Linux b747.shapiroconsult.com 3.10.0-1160.119.1.vz7.224.4 #1 SMP Mon Sep 30 15:36:27 MSK 2024 x86_64
Apache
173.231.212.80

File Name : patch_stdout.py

"""
patch_stdout
============

This implements a context manager that ensures that print statements within
it won't destroy the user interface. The context manager will replace
`sys.stdout` by something that draws the output above the current prompt,
rather than overwriting the UI.

Usage::

with patch_stdout(application):
        ...
        application.run()
        ...

Multiple applications can run in the body of the context manager, one after the
other.
"""

from __future__ import annotations

import asyncio
import queue
import sys
import threading
import time
from contextlib import contextmanager
from typing import Generator, TextIO, cast

from .application import get_app_session, run_in_terminal
from .output import Output

__all__ = [
    "patch_stdout",
    "StdoutProxy",
]

@contextmanager
def patch_stdout(raw: bool = False) -> Generator[None, None, None]:
    """
    Replace `sys.stdout` by an :class:`_StdoutProxy` instance.

Writing to this proxy will make sure that the text appears above the
    prompt, and that it doesn't destroy the output from the renderer.  If no
    application is curring, the behavior should be identical to writing to
    `sys.stdout` directly.

Warning: If a new event loop is installed using `asyncio.set_event_loop()`,
        then make sure that the context manager is applied after the event loop
        is changed. Printing to stdout will be scheduled in the event loop
        that's active when the context manager is created.

:param raw: (`bool`) When True, vt100 terminal escape sequences are not
                removed/escaped.
    """
    with StdoutProxy(raw=raw) as proxy:
        original_stdout = sys.stdout
        original_stderr = sys.stderr

# Enter.
        sys.stdout = cast(TextIO, proxy)
        sys.stderr = cast(TextIO, proxy)

try:
            yield
        finally:
            sys.stdout = original_stdout
            sys.stderr = original_stderr

class _Done:
    "Sentinel value for stopping the stdout proxy."

class StdoutProxy:
    """
    File-like object, which prints everything written to it, output above the
    current application/prompt. This class is compatible with other file
    objects and can be used as a drop-in replacement for `sys.stdout` or can
    for instance be passed to `logging.StreamHandler`.

The current application, above which we print, is determined by looking
    what application currently runs in the `AppSession` that is active during
    the creation of this instance.

This class can be used as a context manager.

In order to avoid having to repaint the prompt continuously for every
    little write, a short delay of `sleep_between_writes` seconds will be added
    between writes in order to bundle many smaller writes in a short timespan.
    """

def __init__(
        self,
        sleep_between_writes: float = 0.2,
        raw: bool = False,
    ) -> None:
        self.sleep_between_writes = sleep_between_writes
        self.raw = raw

self._lock = threading.RLock()
        self._buffer: list[str] = []

# Keep track of the curret app session.
        self.app_session = get_app_session()

# See what output is active *right now*. We should do it at this point,
        # before this `StdoutProxy` instance is possibly assigned to `sys.stdout`.
        # Otherwise, if `patch_stdout` is used, and no `Output` instance has
        # been created, then the default output creation code will see this
        # proxy object as `sys.stdout`, and get in a recursive loop trying to
        # access `StdoutProxy.isatty()` which will again retrieve the output.
        self._output: Output = self.app_session.output

# Flush thread
        self._flush_queue: queue.Queue[str | _Done] = queue.Queue()
        self._flush_thread = self._start_write_thread()
        self.closed = False

def __enter__(self) -> StdoutProxy:
        return self

def __exit__(self, *args: object) -> None:
        self.close()

def close(self) -> None:
        """
        Stop `StdoutProxy` proxy.

This will terminate the write thread, make sure everything is flushed
        and wait for the write thread to finish.
        """
        if not self.closed:
            self._flush_queue.put(_Done())
            self._flush_thread.join()
            self.closed = True

def _start_write_thread(self) -> threading.Thread:
        thread = threading.Thread(
            target=self._write_thread,
            name="patch-stdout-flush-thread",
            daemon=True,
        )
        thread.start()
        return thread

def _write_thread(self) -> None:
        done = False

while not done:
            item = self._flush_queue.get()

if isinstance(item, _Done):
                break

# Don't bother calling when we got an empty string.
            if not item:
                continue

text = []
            text.append(item)

# Read the rest of the queue if more data was queued up.
            while True:
                try:
                    item = self._flush_queue.get_nowait()
                except queue.Empty:
                    break
                else:
                    if isinstance(item, _Done):
                        done = True
                    else:
                        text.append(item)

app_loop = self._get_app_loop()
            self._write_and_flush(app_loop, "".join(text))

# If an application was running that requires repainting, then wait
            # for a very short time, in order to bundle actual writes and avoid
            # having to repaint to often.
            if app_loop is not None:
                time.sleep(self.sleep_between_writes)

def _get_app_loop(self) -> asyncio.AbstractEventLoop | None:
        """
        Return the event loop for the application currently running in our
        `AppSession`.
        """
        app = self.app_session.app

if app is None:
            return None

return app.loop

def _write_and_flush(
        self, loop: asyncio.AbstractEventLoop | None, text: str
    ) -> None:
        """
        Write the given text to stdout and flush.
        If an application is running, use `run_in_terminal`.
        """

def write_and_flush() -> None:
            # Ensure that autowrap is enabled before calling `write`.
            # XXX: On Windows, the `Windows10_Output` enables/disables VT
            #      terminal processing for every flush. It turns out that this
            #      causes autowrap to be reset (disabled) after each flush. So,
            #      we have to enable it again before writing text.
            self._output.enable_autowrap()

if self.raw:
                self._output.write_raw(text)
            else:
                self._output.write(text)

self._output.flush()

def write_and_flush_in_loop() -> None:
            # If an application is running, use `run_in_terminal`, otherwise
            # call it directly.
            run_in_terminal(write_and_flush, in_executor=False)

if loop is None:
            # No loop, write immediately.
            write_and_flush()
        else:
            # Make sure `write_and_flush` is executed *in* the event loop, not
            # in another thread.
            loop.call_soon_threadsafe(write_and_flush_in_loop)

def _write(self, data: str) -> None:
        """
        Note: print()-statements cause to multiple write calls.
              (write('line') and write('\n')). Of course we don't want to call
              `run_in_terminal` for every individual call, because that's too
              expensive, and as long as the newline hasn't been written, the
              text itself is again overwritten by the rendering of the input
              command line. Therefor, we have a little buffer which holds the
              text until a newline is written to stdout.
        """
        if "\n" in data:
            # When there is a newline in the data, write everything before the
            # newline, including the newline itself.
            before, after = data.rsplit("\n", 1)
            to_write = self._buffer + [before, "\n"]
            self._buffer = [after]

text = "".join(to_write)
            self._flush_queue.put(text)
        else:
            # Otherwise, cache in buffer.
            self._buffer.append(data)

def _flush(self) -> None:
        text = "".join(self._buffer)
        self._buffer = []
        self._flush_queue.put(text)

def write(self, data: str) -> int:
        with self._lock:
            self._write(data)

return len(data)  # Pretend everything was written.

def flush(self) -> None:
        """
        Flush buffered output.
        """
        with self._lock:
            self._flush()

@property
    def original_stdout(self) -> TextIO | None:
        return self._output.stdout or sys.__stdout__

# Attributes for compatibility with sys.__stdout__:

def fileno(self) -> int:
        return self._output.fileno()

def isatty(self) -> bool:
        stdout = self._output.stdout
        if stdout is None:
            return False

return stdout.isatty()

@property
    def encoding(self) -> str:
        return self._output.encoding()

@property
    def errors(self) -> str:
        return "strict"

Name	Type	Size	Owner/Group	Permission	Last Modified	Actions
.	dir	-	root/root	0755	2025-01-07 04:51:48
..	dir	-	root/root	0755	2026-06-01 12:02:46
__pycache__	dir	-	root/root	0755	2025-01-07 04:51:47
application	dir	-	root/root	0755	2025-01-07 04:51:47
clipboard	dir	-	root/root	0755	2025-01-07 04:51:47
completion	dir	-	root/root	0755	2025-01-07 04:51:47
contrib	dir	-	root/root	0755	2025-01-07 04:51:47
eventloop	dir	-	root/root	0755	2025-01-07 04:51:47
filters	dir	-	root/root	0755	2025-01-07 04:51:47
formatted_text	dir	-	root/root	0755	2025-01-07 04:51:47
input	dir	-	root/root	0755	2025-01-07 04:51:47
key_binding	dir	-	root/root	0755	2025-01-07 04:51:48
layout	dir	-	root/root	0755	2025-01-07 04:51:48
lexers	dir	-	root/root	0755	2025-01-07 04:51:48
output	dir	-	root/root	0755	2025-01-07 04:51:48
shortcuts	dir	-	root/root	0755	2025-01-07 04:51:48
styles	dir	-	root/root	0755	2025-01-07 04:51:48
widgets	dir	-	root/root	0755	2025-01-07 04:51:48
__init__.py	text/plain	1.27 KB	root/root	0644	2025-01-06 04:11:05
auto_suggest.py	text/plain	5.66 KB	root/root	0644	2025-01-06 04:11:05
buffer.py	text/plain	72.77 KB	root/root	0644	2025-01-06 04:11:05
cache.py	text/x-python	3.73 KB	root/root	0644	2025-01-06 04:11:05
cursor_shapes.py	text/x-python	3.63 KB	root/root	0644	2025-01-06 04:11:05
data_structures.py	text/x-python	212 B	root/root	0644	2025-01-06 04:11:05
document.py	text/plain	39.63 KB	root/root	0644	2025-01-06 04:11:05
enums.py	text/x-python	358 B	root/root	0644	2025-01-06 04:11:05
history.py	text/plain	9.22 KB	root/root	0644	2025-01-06 04:11:05
keys.py	text/x-python	4.8 KB	root/root	0644	2025-01-06 04:11:05
log.py	text/plain	153 B	root/root	0644	2025-01-06 04:11:05
mouse_events.py	text/plain	2.42 KB	root/root	0644	2025-01-06 04:11:05
patch_stdout.py	text/plain	9.25 KB	root/root	0644	2025-01-06 04:11:05
py.typed	application/x-empty	0 B	root/root	0644	2025-01-06 04:11:05
renderer.py	text/plain	28.43 KB	root/root	0644	2025-01-06 04:11:05
search.py	text/plain	6.79 KB	root/root	0644	2025-01-06 04:11:05
selection.py	text/plain	1.24 KB	root/root	0644	2025-01-06 04:11:05
token.py	text/plain	121 B	root/root	0644	2025-01-06 04:11:05
utils.py	text/x-python	8.43 KB	root/root	0644	2025-01-06 04:11:05
validation.py	text/plain	5.67 KB	root/root	0644	2025-01-06 04:11:05
win32_types.py	text/x-python	5.42 KB	root/root	0644	2025-01-06 04:11:05