Restoring authorship annotation for <shadchin@yandex-team.ru>. Commit 2 of 2.

1 files changed, 135 insertions, 135 deletions

diff --git a/contrib/python/prompt-toolkit/py3/prompt_toolkit/input/win32_pipe.py b/contrib/python/prompt-toolkit/py3/prompt_toolkit/input/win32_pipe.py
index 67cf6f0ee3e..cdcf084de11 100644
--- a/contrib/python/prompt-toolkit/py3/prompt_toolkit/input/win32_pipe.py
+++ b/contrib/python/prompt-toolkit/py3/prompt_toolkit/input/win32_pipe.py
@@ -1,135 +1,135 @@
-from ctypes import windll 
-from ctypes.wintypes import HANDLE 
-from typing import Callable, ContextManager, List 
- 
-from prompt_toolkit.eventloop.win32 import create_win32_event 
- 
-from ..key_binding import KeyPress 
-from ..utils import DummyContext 
-from .base import PipeInput 
-from .vt100_parser import Vt100Parser 
-from .win32 import _Win32InputBase, attach_win32_input, detach_win32_input 
- 
-__all__ = ["Win32PipeInput"] 
- 
- 
-class Win32PipeInput(_Win32InputBase, PipeInput): 
-    """ 
-    This is an input pipe that works on Windows. 
-    Text or bytes can be feed into the pipe, and key strokes can be read from 
-    the pipe. This is useful if we want to send the input programmatically into 
-    the application. Mostly useful for unit testing. 
- 
-    Notice that even though it's Windows, we use vt100 escape sequences over 
-    the pipe. 
- 
-    Usage:: 
- 
-        input = Win32PipeInput() 
-        input.send_text('inputdata') 
-    """ 
- 
-    _id = 0 
- 
-    def __init__(self) -> None: 
-        super().__init__() 
-        # Event (handle) for registering this input in the event loop. 
-        # This event is set when there is data available to read from the pipe. 
-        # Note: We use this approach instead of using a regular pipe, like 
-        #       returned from `os.pipe()`, because making such a regular pipe 
-        #       non-blocking is tricky and this works really well. 
-        self._event = create_win32_event() 
- 
-        self._closed = False 
- 
-        # Parser for incoming keys. 
-        self._buffer: List[KeyPress] = []  # Buffer to collect the Key objects. 
-        self.vt100_parser = Vt100Parser(lambda key: self._buffer.append(key)) 
- 
-        # Identifier for every PipeInput for the hash. 
-        self.__class__._id += 1 
-        self._id = self.__class__._id 
- 
-    @property 
-    def closed(self) -> bool: 
-        return self._closed 
- 
-    def fileno(self) -> int: 
-        """ 
-        The windows pipe doesn't depend on the file handle. 
-        """ 
-        raise NotImplementedError 
- 
-    @property 
-    def handle(self) -> HANDLE: 
-        "The handle used for registering this pipe in the event loop." 
-        return self._event 
- 
-    def attach(self, input_ready_callback: Callable[[], None]) -> ContextManager[None]: 
-        """ 
-        Return a context manager that makes this input active in the current 
-        event loop. 
-        """ 
-        return attach_win32_input(self, input_ready_callback) 
- 
-    def detach(self) -> ContextManager[None]: 
-        """ 
-        Return a context manager that makes sure that this input is not active 
-        in the current event loop. 
-        """ 
-        return detach_win32_input(self) 
- 
-    def read_keys(self) -> List[KeyPress]: 
-        "Read list of KeyPress." 
- 
-        # Return result. 
-        result = self._buffer 
-        self._buffer = [] 
- 
-        # Reset event. 
-        windll.kernel32.ResetEvent(self._event) 
- 
-        return result 
- 
-    def flush_keys(self) -> List[KeyPress]: 
-        """ 
-        Flush pending keys and return them. 
-        (Used for flushing the 'escape' key.) 
-        """ 
-        # Flush all pending keys. (This is most important to flush the vt100 
-        # 'Escape' key early when nothing else follows.) 
-        self.vt100_parser.flush() 
- 
-        # Return result. 
-        result = self._buffer 
-        self._buffer = [] 
-        return result 
- 
-    def send_bytes(self, data: bytes) -> None: 
-        "Send bytes to the input." 
-        self.send_text(data.decode("utf-8", "ignore")) 
- 
-    def send_text(self, text: str) -> None: 
-        "Send text to the input." 
-        # Pass it through our vt100 parser. 
-        self.vt100_parser.feed(text) 
- 
-        # Set event. 
-        windll.kernel32.SetEvent(self._event) 
- 
-    def raw_mode(self) -> ContextManager[None]: 
-        return DummyContext() 
- 
-    def cooked_mode(self) -> ContextManager[None]: 
-        return DummyContext() 
- 
-    def close(self) -> None: 
-        "Close pipe handles." 
-        windll.kernel32.CloseHandle(self._event) 
-        self._closed = True 
- 
-    def typeahead_hash(self) -> str: 
-        """ 
-        This needs to be unique for every `PipeInput`. 
-        """ 
-        return "pipe-input-%s" % (self._id,) 
+from ctypes import windll
+from ctypes.wintypes import HANDLE
+from typing import Callable, ContextManager, List
+
+from prompt_toolkit.eventloop.win32 import create_win32_event
+
+from ..key_binding import KeyPress
+from ..utils import DummyContext
+from .base import PipeInput
+from .vt100_parser import Vt100Parser
+from .win32 import _Win32InputBase, attach_win32_input, detach_win32_input
+
+__all__ = ["Win32PipeInput"]
+
+
+class Win32PipeInput(_Win32InputBase, PipeInput):
+    """
+    This is an input pipe that works on Windows.
+    Text or bytes can be feed into the pipe, and key strokes can be read from
+    the pipe. This is useful if we want to send the input programmatically into
+    the application. Mostly useful for unit testing.
+
+    Notice that even though it's Windows, we use vt100 escape sequences over
+    the pipe.
+
+    Usage::
+
+        input = Win32PipeInput()
+        input.send_text('inputdata')
+    """
+
+    _id = 0
+
+    def __init__(self) -> None:
+        super().__init__()
+        # Event (handle) for registering this input in the event loop.
+        # This event is set when there is data available to read from the pipe.
+        # Note: We use this approach instead of using a regular pipe, like
+        #       returned from `os.pipe()`, because making such a regular pipe
+        #       non-blocking is tricky and this works really well.
+        self._event = create_win32_event()
+
+        self._closed = False
+
+        # Parser for incoming keys.
+        self._buffer: List[KeyPress] = []  # Buffer to collect the Key objects.
+        self.vt100_parser = Vt100Parser(lambda key: self._buffer.append(key))
+
+        # Identifier for every PipeInput for the hash.
+        self.__class__._id += 1
+        self._id = self.__class__._id
+
+    @property
+    def closed(self) -> bool:
+        return self._closed
+
+    def fileno(self) -> int:
+        """
+        The windows pipe doesn't depend on the file handle.
+        """
+        raise NotImplementedError
+
+    @property
+    def handle(self) -> HANDLE:
+        "The handle used for registering this pipe in the event loop."
+        return self._event
+
+    def attach(self, input_ready_callback: Callable[[], None]) -> ContextManager[None]:
+        """
+        Return a context manager that makes this input active in the current
+        event loop.
+        """
+        return attach_win32_input(self, input_ready_callback)
+
+    def detach(self) -> ContextManager[None]:
+        """
+        Return a context manager that makes sure that this input is not active
+        in the current event loop.
+        """
+        return detach_win32_input(self)
+
+    def read_keys(self) -> List[KeyPress]:
+        "Read list of KeyPress."
+
+        # Return result.
+        result = self._buffer
+        self._buffer = []
+
+        # Reset event.
+        windll.kernel32.ResetEvent(self._event)
+
+        return result
+
+    def flush_keys(self) -> List[KeyPress]:
+        """
+        Flush pending keys and return them.
+        (Used for flushing the 'escape' key.)
+        """
+        # Flush all pending keys. (This is most important to flush the vt100
+        # 'Escape' key early when nothing else follows.)
+        self.vt100_parser.flush()
+
+        # Return result.
+        result = self._buffer
+        self._buffer = []
+        return result
+
+    def send_bytes(self, data: bytes) -> None:
+        "Send bytes to the input."
+        self.send_text(data.decode("utf-8", "ignore"))
+
+    def send_text(self, text: str) -> None:
+        "Send text to the input."
+        # Pass it through our vt100 parser.
+        self.vt100_parser.feed(text)
+
+        # Set event.
+        windll.kernel32.SetEvent(self._event)
+
+    def raw_mode(self) -> ContextManager[None]:
+        return DummyContext()
+
+    def cooked_mode(self) -> ContextManager[None]:
+        return DummyContext()
+
+    def close(self) -> None:
+        "Close pipe handles."
+        windll.kernel32.CloseHandle(self._event)
+        self._closed = True
+
+    def typeahead_hash(self) -> str:
+        """
+        This needs to be unique for every `PipeInput`.
+        """
+        return "pipe-input-%s" % (self._id,)