Файловый менеджер - Редактировать - /opt/imh-python/lib/python3.9/site-packages/prompt_toolkit/application/__pycache__/application.cpython-39.pyc
Ðазад
a d�hF� � @ sB d dl mZ d dlZd dlZd dlZd dlZd dlZd dlZd dlZd dl Z d dlm Z m Z m Z m Z mZmZ d dlmZmZ d dlmZ d dlmZ d dlmZmZmZmZm Z m Z m Z m Z m Z m!Z!m"Z" d dl#m$Z$ d d l%m&Z& d d l'm(Z(m)Z) d d l*m+Z+m,Z, d d l-m.Z. d d l/m0Z0 d dl1m2Z2m3Z3m4Z4m5Z5 d dl6m7Z7 d dl8m9Z9m:Z:m;Z;m<Z< d dl=m>Z> d dl?m@Z@ d dlAmBZBmCZC d dlDmEZE d dlFmGZG d dlHmIZI d dlJmKZKmLZLmMZMmNZNmOZOmPZPmQZQ d dlRmSZSmTZT d dlUmVZV d dlWmXZX d dlYmZZZm[Z[ d d l\m]Z]m^Z^ d d l_m`Z` d d lambZbmcZc d d ldmeZemfZf d d lgmhZhmiZi d d!ljmkZk d d"llmmZmmnZnmoZompZpmqZqmrZrmsZsmtZt d d#lumvZvmwZw d$d%lxmyZymzZz d$d&l{m|Z|m{Z{ d'gZ}eSZ~e d(�Zed)gdf Z�e�ed*d�Z�e�ed+d�Z�G d,d'� d'e e �Z�G d-d.� d.eO�Z�d/d0d1�d2d3�Z�ed4d5d6�d7d8��Z�ed5d9�d:d;��Z�dS )<� )� annotationsN)�AbstractEventLoop�Future�Task� ensure_future�get_running_loop�sleep)� ExitStack�contextmanager)�Popen)� format_tb) �Any�Callable� Coroutine� Generator�Generic�Hashable�Iterable�Iterator�TypeVar�cast�overload)�Buffer)� SimpleCache)� Clipboard�InMemoryClipboard)�AnyCursorShapeConfig�to_cursor_shape_config)�Size)� EditingMode)� InputHook�get_traceback_from_context� new_eventloop_with_inputhook� run_in_executor_with_context)�call_soon_threadsafe)� Condition�Filter� FilterOrBool� to_filter)�AnyFormattedText)�Input)� get_typeahead�store_typeahead)� load_page_navigation_bindings)�load_key_bindings)� EmacsState)�Binding�ConditionalKeyBindings�GlobalOnlyKeyBindings� KeyBindings�KeyBindingsBase� KeysTuple�merge_key_bindings)� KeyPressEvent� KeyProcessor)�ViState)�Keys)� Container�Window)� BufferControl� UIControl)�create_dummy_layout)�Layout�walk)� ColorDepth�Output)�Renderer�print_formatted_text)� SearchState)� BaseStyle� DummyStyle�DummyStyleTransformation� DynamicStyle�StyleTransformation�default_pygments_style�default_ui_style� merge_styles)�Event�in_main_thread� )�get_app_session�set_app)� in_terminal�run_in_terminal� Application� _AppResult�Application[_AppResult]�SIGWINCH�SIGTSTPc @ s� e Zd ZdZdddddddddddejdddddddddddddfddd d d d d dd dd dd d ddddddddddddd�dd�Zdd d �d d �Zed d!�d"d#��Z ed$d!�d%d&��Z ed'd!�d(d)��Z dd!�d*d+�Z dd!�d,d-�Z ed d!�d.d/��Zd�d dd0�d1d2�Zdd!�d3d4�Zdd!�d5d6�Zd7dd8�d9d:�Zdd!�d;d<�Zd�d=dd>�d?d@�Zd�d=d d dAdBdC�dDdE�Zd�d=d d d dFdBdG�dHdI�ZdJdKddL�dMdN�ZedOd!�dPdQ��Zd7d7ddR�dSdT�ZdUdVdW�dXdY�ZdVddZ�d[d\�Z dd!�d]d^�Z dd!�d_d`�Z dd!�dadb�Z e dd!�dcdd��Z!e dedf�dBdgddh�didd��Z!e dedf�djdgddk�dldd��Z!d�dmdndgddo�dpdd�Z!dd!�dqdr�Z"d�dgd dtdgddu�dvdw�Z#d�d ddx�dydz�Z$d�dtddd{�d|d}�Z%ed d!�d~d��Z&ed d!�d�d���Z'd�d!�d�d��Z(dS )�rV a' The main Application class! This glues everything together. :param layout: A :class:`~prompt_toolkit.layout.Layout` instance. :param key_bindings: :class:`~prompt_toolkit.key_binding.KeyBindingsBase` instance for the key bindings. :param clipboard: :class:`~prompt_toolkit.clipboard.Clipboard` to use. :param full_screen: When True, run the application on the alternate screen buffer. :param color_depth: Any :class:`~.ColorDepth` value, a callable that returns a :class:`~.ColorDepth` or `None` for default. :param erase_when_done: (bool) Clear the application output when it finishes. :param reverse_vi_search_direction: Normally, in Vi mode, a '/' searches forward and a '?' searches backward. In Readline mode, this is usually reversed. :param min_redraw_interval: Number of seconds to wait between redraws. Use this for applications where `invalidate` is called a lot. This could cause a lot of terminal output, which some terminals are not able to process. `None` means that every `invalidate` will be scheduled right away (which is usually fine). When one `invalidate` is called, but a scheduled redraw of a previous `invalidate` call has not been executed yet, nothing will happen in any case. :param max_render_postpone_time: When there is high CPU (a lot of other scheduled calls), postpone the rendering max x seconds. '0' means: don't postpone. '.5' means: try to draw at least twice a second. :param refresh_interval: Automatically invalidate the UI every so many seconds. When `None` (the default), only invalidate when `invalidate` has been called. :param terminal_size_polling_interval: Poll the terminal size every so many seconds. Useful if the applications runs in a thread other then then main thread where SIGWINCH can't be handled, or on Windows. Filters: :param mouse_support: (:class:`~prompt_toolkit.filters.Filter` or boolean). When True, enable mouse support. :param paste_mode: :class:`~prompt_toolkit.filters.Filter` or boolean. :param editing_mode: :class:`~prompt_toolkit.enums.EditingMode`. :param enable_page_navigation_bindings: When `True`, enable the page navigation key bindings. These include both Emacs and Vi bindings like page-up, page-down and so on to scroll through pages. Mostly useful for creating an editor or other full screen applications. Probably, you don't want this for the implementation of a REPL. By default, this is enabled if `full_screen` is set. Callbacks (all of these should accept an :class:`~prompt_toolkit.application.Application` object as input.) :param on_reset: Called during reset. :param on_invalidate: Called when the UI has been invalidated. :param before_render: Called right before rendering. :param after_render: Called right after rendering. I/O: (Note that the preferred way to change the input/output is by creating an `AppSession` with the required input/output objects. If you need multiple applications running at the same time, you have to create a separate `AppSession` using a `with create_app_session():` block. :param input: :class:`~prompt_toolkit.input.Input` instance. :param output: :class:`~prompt_toolkit.output.Output` instance. (Probably Vt100_Output or Win32Output.) Usage: app = Application(...) app.run() # Or await app.run_async() NTFg{�G�z�?� �?z Layout | NonezBaseStyle | Noner' zStyleTransformation | NonezKeyBindingsBase | NonezClipboard | None�boolz3ColorDepth | Callable[[], ColorDepth | None] | NonezNone | FilterOrBoolr zfloat | int | Nonez float | Noner z*ApplicationEventHandler[_AppResult] | Nonez Input | Nonez Output | None�None)�layout�style� include_default_pygments_style�style_transformation� key_bindings� clipboard� full_screen� color_depth� mouse_support� enable_page_navigation_bindings� paste_mode� editing_mode�erase_when_done�reverse_vi_search_direction�min_redraw_interval�max_render_postpone_time�refresh_interval� terminal_size_polling_interval�cursor�on_reset� on_invalidate� before_render� after_render�input�output�returnc s� | d u rt � fdd��} t| �} t| �} t|�}t| �} t|�}|d u rNt� }|d u r\t� }|� _|� _|� _t� � _t � � _ |� _ |p�t � � _ |� _|� _| � _| � _| � _| � _|� _| � _|� _|� _|� _|� _t|�� _t � |�� _ t � |�� _ t � |�� _ t � |�� _ t!� }|�p"|j"� _"|�p0|j#� _#g � _$d� _%d � _&d � _'d � _(d � _)d� _*t+� � _,t-� � _.d� _/d� _0� �1|�� _2t3� j2� j"|| � j4d�� _5d� _6d� _7g � _8d� _9t:t;� ��� _<d� _=d � _>� �?� d S ) Nc s � j S �N)rd � ��selfry ��/root/rpmbuild/BUILDROOT/imh-python39-modules-3.9.7-92.el8.x86_64/opt/imh-python/lib/python3.9/site-packages/prompt_toolkit/application/application.py�<lambda>� � z&Application.__init__.<locals>.<lambda>Fr[ g �?)rd rf �cpr_not_supported_callbackr g )@r% r( r? rI r_ ra rb r. �_default_bindingsr- �_page_navigation_bindingsr^ r rc rd � _color_depthrf rh ri rj rk rg rl rm rn ro r rp rO rr rq rs rt rR rv ru �pre_run_callables� _is_running�future�loop� _loop_thread�contextZ quoted_insertr9 �vi_stater/ � emacs_state� ttimeoutlenZ timeoutlen�_create_merged_style� _merged_stylerD r �renderer�render_counter� _invalidated�_invalidate_events�_last_redraw_timer8 �_CombinedRegistry� key_processor�_running_in_terminal�_running_in_terminal_f�reset)r{ r^ r_ r` ra rb rc rd re rf rg rh ri rj rk rl rm rn ro rp rq rr rs rt ru rv �sessionry rz r| �__init__� s� � �zApplication.__init__r& rG )r` rw c sB t � � t� �tdd�� ��fdd� �}tt� |t�fdd��g�S )z� Create a `Style` object that merges the default UI style, the default pygments style, and the custom user style. rG �rw c s �� r �S � S d S rx ry ry )� dummy_styler` �pygments_stylery r| �conditional_pygments_style[ s zDApplication._create_merged_style.<locals>.conditional_pygments_stylec s � j S rx �r_ ry rz ry r| r} f r~ z2Application._create_merged_style.<locals>.<lambda>)rH rL rJ rN rM )r{ r` r� ry )r� r` r� r{ r| r� S s ��z Application._create_merged_stylerB r� c C s* | j }t|�r|� }|du r&| j�� }|S )a� The active :class:`.ColorDepth`. The current value is determined as follows: - If a color depth was given explicitly to this application, use that value. - Otherwise, fall back to the color depth that is reported by the :class:`.Output` implementation. If the :class:`.Output` class was created using `output.defaults.create_output`, then this value is coming from the $PROMPT_TOOLKIT_COLOR_DEPTH environment variable. N)r� �callablerv Zget_default_color_depth)r{ �depthry ry r| re j s zApplication.color_depthr c C s | j jptdd�S )a The currently focused :class:`~.Buffer`. (This returns a dummy :class:`.Buffer` when none of the actual buffers has the focus. In this case, it's really not practical to check for `None` values or catch exceptions every time.) z dummy-buffer)�name)r^ �current_bufferr rz ry ry r| r� � s �zApplication.current_bufferrF c C s" | j j}t|t�r|jS t� S dS )zv Return the current :class:`.SearchState`. (The one for the focused :class:`.BufferControl`.) N)r^ �current_control� isinstancer= Z search_staterF )r{ Z ui_controlry ry r| �current_search_state� s z Application.current_search_statec C s� d| _ t� | _| j�� | j�� | j�� | j�� | j�� | j � � | j}|j � � s||� � D ]}|j� � rb||_ q|qbdS )z? Reset everything, for reading the next input. � N)� exit_style�set�_background_tasksr� r� r� r^ r� r� rq �firer� Z is_focusableZfind_all_windows�content�current_window)r{ r^ �wry ry r| r� � s zApplication.resetc s� �j s dS �jdu s �j�� r"dS �jr,dS d�_�j��jj� dd��fdd� �dd���fdd� ��jr�t�� �j � � �jk r�dd�� ��fd d � ��j���fd d �� q� n�� dS ) zW Thread safe way of sending a repaint trigger to the input event loop. NTr] r� c s d� _ � �� d S �NF)r� �_redrawry rz ry r| �redraw� s z&Application.invalidate.<locals>.redrawc s t � �j�jd� d S )N)Zmax_postpone_timer� )r$ rm r� ry )r� r{ ry r| �schedule_redraw� s �z/Application.invalidate.<locals>.schedule_redrawc � s$ t tt�j�� �I d H �� d S rx )r r �floatrl ry )�diffr� r{ ry r| �redraw_in_future� s z0Application.invalidate.<locals>.redraw_in_futurec s �� � � �S rx )�create_background_taskry )r� r{ ry r| r} � r~ z(Application.invalidate.<locals>.<lambda>) r� r� Z is_closedr� r$ rr r� rl �timer� rz ry )r� r� r� r� r{ r| � invalidate� s& �zApplication.invalidatec C s | j S )z0True when a redraw operation has been scheduled.)r� rz ry ry r| � invalidated� s zApplication.invalidated)�render_as_donerw c s2 dd�� �fdd� }�j dur.�j �� �|� dS )z� Render the command line again. (Not thread safe!) (From other threads, or if unsure, use :meth:`.Application.invalidate`.) :param render_as_done: make sure to put the cursor after the UI. r] r� c s� �j r��js��jr t�� �_� jd7 _�j�� � r`�jrJ�j � � qp�j j ��j � d� n�j � ��j � �j � � �j�� ��� d S )NrQ )�is_done)r� r� rl r� r� r� rs r� rj r� �erase�renderr^ Zupdate_parents_relationsrt �_update_invalidate_eventsry �r� r{ ry r| �run_in_context� s z+Application._redraw.<locals>.run_in_contextN)r� �copy�run)r{ r� r� ry r� r| r� � s ! zApplication._redrawc s< � j dur8� j dkr8ddd�� fdd� }� �|� j �� dS )zi Start a while/true loop in the background for automatic invalidation of the UI. Nr r� r] )rn rw c � s t | �I d H � �� q d S rx )r r� )rn rz ry r| � auto_refresh( s z:Application._start_auto_refresh_task.<locals>.auto_refresh)rn r� )r{ r� ry rz r| �_start_auto_refresh_task! s z$Application._start_auto_refresh_taskc sN � j D ]}|� j8 }qdd�� fdd� }t|� �� _ � j D ]}|� j7 }q:dS )zg Make sure to attach 'invalidate' handlers to all invalidate events in the UI. zIterable[Event[object]]r� c 3 s" � j �� D ]} | �� E d H q d S rx )r^ �find_all_controlsZget_invalidate_events)�crz ry r| � gather_events; s z<Application._update_invalidate_events.<locals>.gather_eventsN)r� �_invalidate_handler�list)r{ �evr� ry rz r| r� / s z%Application._update_invalidate_events�object)�senderrw c C s | � � dS )a Handler for invalidate events coming from UIControls. (This handles the difference in signature between event handler and `self.invalidate`. It also needs to be a method -not a nested function-, so that we can remove it again .) N)r� )r{ r� ry ry r| r� D s z Application._invalidate_handlerc C s" | j jdd� | �� | �� dS )z� When the window size changes, we erase the current output and request again the cursor position. When the CPR answer arrives, the output is drawn again. F)Zleave_alternate_screenN)r� r� �!_request_absolute_cursor_positionr� rz ry ry r| � _on_resizeN s zApplication._on_resizezCallable[[], None] | None)�pre_runrw c C s, |r |� | j D ] }|� q| j dd�= dS )a� Called during `run`. `self.future` should be set to the new future at the point where this is called in order to avoid data races. `pre_run` can be used to set a `threading.Event` to synchronize with UI termination code, running in another thread that would call `Application.exit`. (See the progress bar code for an example.) N)r� )r{ r� r� ry ry r| �_pre_runZ s zApplication._pre_runr� rW )r� �set_exception_handler� handle_sigint�slow_callback_durationrw c � s� �j rJ d��t� r tjdkr"d� ddd���fdd� }td d ��fd d � �}td d ��fdd� �}tdd d�� �fdd� �}tdd d���fdd� �} tdd d��fdd� �} tddd��fdd� �} t� ��} | �|� � d�_| �|� �} | �|| �� | �| | �� | �| | �� | �t��� | ��� � � | �| | ��}z,||�I dH W �� � I dH W d � S �� � I dH 0 W d � n1 �s�0 Y d�s�J d ��dS ) aY Run the prompt_toolkit :class:`~prompt_toolkit.application.Application` until :meth:`~prompt_toolkit.application.Application.exit` has been called. Return the value that was passed to :meth:`~prompt_toolkit.application.Application.exit`. This is the main entry point for a prompt_toolkit :class:`~prompt_toolkit.application.Application` and usually the only place where the event loop is actually running. :param pre_run: Optional callable, which is called right after the "reset" of the application. :param set_exception_handler: When set, in case of an exception, go out of the alternate screen and hide the application, display the exception, and wait for the user to press ENTER. :param handle_sigint: Handle SIGINT signal if possible. This will call the `<sigint>` key binding when a SIGINT is received. (This only works in the main thread.) :param slow_callback_duration: Display warnings if code scheduled in the asyncio event loop takes more time than this. The asyncio default of `0.1` is sometimes not sufficient on a slow system, because exceptionally, the drawing of the app, which happens in the event loop, can take a bit longer from time to time. z Application is already running.�win32Fzasyncio.Future[_AppResult]rW )�frw c � sf t �� ���_d ���� ���� �j�t�j�� �j� � dd�� ���fdd� �dd���fdd� }dd���fdd� � dd���fd d � ��j� � ��� �j� |���� t �j ���R ��� ��� ��� ����� � �z�I d H }W z��jd d � W �j�� d �_�jD ]}|�j8 }�q g �_�jj�rN�j�� I d H �j}|�rd|I d H t�j�j� � � nr�j�� d �_�jD ]}|�j8 }�q�g �_�jj�r��j�� I d H �j}|�r�|I d H t�j�j� � � 0 n�z��jd d � W �j�� d �_�jD ]}|�j8 }�qg �_�jj�rD�j�� I d H �j}|�rZ|I d H t�j�j� � � nr�j�� d �_�jD ]}|�j8 }�q�g �_�jj�r��j�� I d H �j}|�r�|I d H t�j�j� � � 0 0 |W d � W d � W d � S 1 �s0 Y W d � n1 �s80 Y W d � n1 �sX0 Y d S )Nr] r� c sj �j s�jjsd S �j�� } �j�| � �j�� �jjrN�� � sf�� t � n�rZ�� � �� � � ��d S rx )r� r� Zwaiting_for_cprru Z read_keysr� � feed_multiple� process_keys�closed�done� set_exception�EOFError�cancelr� ��keys)�auto_flush_inputr� � flush_taskr{ ry r| �read_from_input� s zBApplication.run_async.<locals>._run_async.<locals>.read_from_inputc s � � � ��� d S rx )r� r� ry )r� r� ry r| �read_from_input_in_context� s zMApplication.run_async.<locals>._run_async.<locals>.read_from_input_in_contextc � s t �j�I d H � � d S rx )r r� ry )� flush_inputr{ ry r| r� � s zCApplication.run_async.<locals>._run_async.<locals>.auto_flush_inputc s< �j s8�j�� } �j�| � �j�� �jjr8� �t� d S rx ) r� ru Z flush_keysr� r� r� r� r� r� r� )r� r{ ry r| r� � s z>Application.run_async.<locals>._run_async.<locals>.flush_inputT)r� F) � contextvarsZ copy_contextr� r� r� r� r� r+ ru r� Zraw_mode�attach�attach_winch_signal_handlerr� r� r� r� r� �_poll_output_sizer� r� r� r� rv �responds_to_cprZwait_for_cpr_responsesr� r, Z empty_queue)r� r� �resultr� Zprevious_run_in_terminal_f)r� r{ )r� r� r� r� r� r� r| � _run_async� s� �� � � � z)Application.run_async.<locals>._run_asynczIterator[AbstractEventLoop]r� c 3 s@ t � } | � _t�� � _z| V W d � _d � _nd � _d � _0 d S rx )r r� � threading�current_threadr� �r� rz ry r| �set_loop s �z'Application.run_async.<locals>.set_loopzIterator[None]c 3 s$ d� _ zd V W d� _ nd� _ 0 d S )NTF�r� ry rz ry r| �set_is_running s z-Application.run_async.<locals>.set_is_runningr )r� rw c 3 st �rjt � �N � �tj� �fdd�� zd V W � �tj� n� �tj� 0 W d � qp1 s^0 Y nd V d S )Nc s � � �jj�S rx )r$ r� Z send_sigint)�_)r� r{ ry r| r} / s �zBApplication.run_async.<locals>.set_handle_sigint.<locals>.<lambda>)�_restore_sigint_from_ctypes�add_signal_handler�signal�SIGINT�remove_signal_handlerr� )r� r{ r� r| �set_handle_sigint' s �<z0Application.run_async.<locals>.set_handle_sigintc 3 sF �r<| � � }| �� j� zd V W | �|� qB| �|� 0 nd V d S rx )Zget_exception_handlerr� �_handle_exception)r� Zprevious_exc_handler)r{ r� ry r| �set_exception_handler_ctx: s z8Application.run_async.<locals>.set_exception_handler_ctxc 3 s* | j }� | _ zd V W || _ n|| _ 0 d S rx �r� )r� Z original_slow_callback_durationr� ry r| �set_callback_durationG s z4Application.run_async.<locals>.set_callback_durationz$Iterator[asyncio.Future[_AppResult]]c 3 s, | � � }|� _z|V W d � _nd � _0 d S rx )� create_futurer� )r� r� rz ry r| r� R s z,Application.run_async.<locals>.create_futureNZ unreachable) r� rP �sys�platformr r � enter_contextr� rS �_enable_breakpointhook�$cancel_and_wait_for_background_tasks)r{ r� r� r� r� r� r� r� r� r� r� r� �stackr� r� ry )r� r� r{ r� r� r| � run_asyncl s@ �0zApplication.run_asynczInputHook | None)r� r� r� � in_thread� inputhookrw c s� |rPd� dd�� �����fdd� }t j|d�}|�� |�� � durL� ��S �j��|d�}dd�d d �} �dur�t��} | �|��| �| �� � | �� �S | � r�z t � � } W n t y� t � |� Y S 0 | �|�S n t � |�S dS ) a� A blocking 'run' call that waits until the UI is finished. This will run the application in a fresh asyncio event loop. :param pre_run: Optional callable, which is called right after the "reset" of the application. :param set_exception_handler: When set, in case of an exception, go out of the alternate screen and hide the application, display the exception, and wait for the user to press ENTER. :param in_thread: When true, run the application in a background thread, and block the current thread until the application terminates. This is useful if we need to be sure the application won't use the current event loop (asyncio does not support nested event loops). A new event loop will be created in this background thread, and that loop will also be closed when the background thread terminates. When this is used, it's especially important to make sure that all asyncio background tasks are managed through `get_appp().create_background_task()`, so that unfinished tasks are properly cancelled before the event loop is closed. This is used for instance in ptpython. :param handle_sigint: Handle SIGINT signal. Call the key binding for `Keys.SIGINT`. (This only works in the main thread.) Nr] r� c sD z�j ��d�d��W n( ty> } z| � W Y d } ~ n d } ~ 0 0 d S )NF)r� r� r� r )r� � BaseException)�e�� exceptionr r� r� r{ r� ry r| � run_in_thread� s � z&Application.run.<locals>.run_in_thread)�target)r� r� r� r\ c S s> z$t jd jdk o"dt �d�jjv W S ty8 Y dS 0 d S )NZIPython)� � r r� z$IPython/terminal/interactiveshell.py� F)r� �modules� version_info� _getframe�f_code� co_filenamer ry ry ry r| �_called_from_ipython� s �� z-Application.run.<locals>._called_from_ipython) r� �Thread�start�joinr r" Zrun_until_completeZshutdown_asyncgens�close�asyncioZget_event_loop� RuntimeErrorr� ) r{ r� r� r� r r r �thread�coror r� ry r r| r� � s8 � zApplication.runr zdict[str, Any])r� r� rw c s8 t � �}d�t|���dd�� �fdd� }t|� � dS )zr Handler for event loop exceptions. This will print the exception, using run_in_terminal. r� r] r� c � sp t � 4 I d H �H td� t�� td�� �d��� td�I d H W d �I d H ql1 I d H sb0 Y d S )Nz# Unhandled exception in event loop:z Exception {}r �Press ENTER to continue...)rT �print�format�get�_do_wait_for_enterry �r� Z formatted_tbry r| �in_term� s z.Application._handle_exception.<locals>.in_termN)r! r r r )r{ r� r� �tbr" ry r! r| r� � s z Application._handle_exception�Generator[None, None, None]c c s> t jt jkr4| jt _zdV W t jt _q:t jt _0 ndV dS )z� Install our custom breakpointhook for the duration of this context manager. (We will only install the hook if no other custom hook was set.) N)r� �breakpointhook�__breakpointhook__�_breakpointhookrz ry ry r| r� s z"Application._enable_breakpointhook)�a�kwrw c s� ��ddl }ddlm� t� ttgtf �tdd��fdd� ��tdd���fdd � ��G � ����fd d �d |j�}t� � j }|tj d �� |� dS ) am Breakpointhook which uses PDB, but ensures that the application is hidden and input echoing is restored during each debugger dispatch. This can be called from any thread. In any case, the application's event loop will be blocked while the PDB input is displayed. The event will continue after leaving the debugger. r N)� FrameTyper$ r� c 3 sh � j �� � j�� �@ � j�� � dV W d � n1 s<0 Y W d � n1 sZ0 Y dS )z`Stop application if `__breakpointhook__` is called from within the App's event loop.N)r� r� ru �detach� cooked_modery )�appry r| � hide_app_from_eventloop_thread' s zCApplication._breakpointhook.<locals>.hide_app_from_eventloop_threadc 3 s\ t �� �t �� � dd��� �fdd� } ��| � � ��� zdV W � �� n � �� 0 dS )zmStop application if `__breakpointhook__` is called from a thread other than the App's event loop.r] r� c � sr � j �� � j�� �J � j�� � ��� ��� W d � n1 sF0 Y W d � n1 sd0 Y d S rx )r� r� ru r+ r, r� �waitry )r- r� �readyry r| �in_loop? s zPApplication._breakpointhook.<locals>.hide_app_from_other_thread.<locals>.in_loopN)r� rO r� r/ r� )r1 )r- r{ )r� r0 r| �hide_app_from_other_thread8 s z?Application._breakpointhook.<locals>.hide_app_from_other_threadc s. e Zd Zddddd�� ���fdd� Z� ZS )z.Application._breakpointhook.<locals>.CustomPdbr* �strr � TraceDispatch)�frame�event�argrw c s� �j d u rt� �|||�S �j t�� kr^�� � t� �|||�W d � S 1 sT0 Y �� � t� �|||�W d � S 1 s�0 Y d S rx )r� �super�trace_dispatchr� r� )r{ r5 r6 r7 )� __class__r- r. r2 ry r| r9 \ s .z=Application._breakpointhook.<locals>.CustomPdb.trace_dispatch)�__name__� __module__� __qualname__r9 � __classcell__ry )r* r4 r- r. r2 )r: r| � CustomPdb[ s r? )�stdout) �pdb�typesr* r r3 r r ZPdbr� r �f_back� __stdout__Z set_trace)r{ r( r) rA r? r5 ry )r* r4 r- r. r2 r{ r| r' s " zApplication._breakpointhookzCoroutine[Any, Any, None]zasyncio.Task[None])� coroutinerw c C s2 | j p t� }|�|�}| j�|� |�| j� |S )a� Start a background task (coroutine) for the running application. When the `Application` terminates, unfinished background tasks will be cancelled. Given that we still support Python versions before 3.11, we can't use task groups (and exception groups), because of that, these background tasks are not allowed to raise exceptions. If they do, we'll call the default exception handler from the event loop. If at some point, we have Python 3.11 as the minimum supported Python version, then we can use a `TaskGroup` (with the lifetime of `Application.run_async()`, and run run the background tasks in there. This is not threadsafe. )r� r Z create_taskr� �addZadd_done_callback�_on_background_task_done)r{ rE r� �taskry ry r| r� l s z"Application.create_background_task)rH rw c C sH | j �|� |�� rdS |�� }|durDt� �d|�d�||d�� dS )z� Called when a background task completes. Remove it from `_background_tasks`, and handle exceptions if any. Nz+prompt_toolkit.Application background task z raised an unexpected exception.)�messager rH )r� �discardZ cancelledr r Zcall_exception_handler)r{ rH �excry ry r| rG � s ��z$Application._on_background_task_donec � s@ | j D ] }|�� qt| j �dkr<tj| j dtjd�I dH dS )a# Cancel all background tasks, and wait for the cancellation to complete. If any of the background tasks raised an exception, this will also propagate the exception. (If we had nurseries like Trio, this would be the `__aexit__` of a nursery.) r N)�timeoutZ return_when)r� r� �lenr r/ Z ALL_COMPLETED)r{ rH ry ry r| r � s �z0Application.cancel_and_wait_for_background_tasksc � sR d}| j }|du rdS t�|�I dH | j�� }|durH||krH| �� |}qdS )z� Coroutine for polling the terminal dimensions. Useful for situations where `attach_winch_signal_handler` is not sufficient: - If we are not running in the main thread. - On Windows. N)ro r r rv �get_sizer� )r{ �size�interval�new_sizery ry r| r� � s z Application._poll_output_sizec s* � j js dS dd�� fdd� }t|� dS )zT Called when we don't receive the cursor position response in time. Nr] r� c s � j �d� � j �� d S )NzHWARNING: your terminal doesn't support cursor position requests (CPR). )rv �write�flushry rz ry r| rT � s �z;Application.cpr_not_supported_callback.<locals>.in_terminal)rv r� rU )r{ rT ry rz r| r � s z&Application.cpr_not_supported_callbackc C s dS )zExit without arguments.Nry rz ry ry r| �exit� s zApplication.exitr� r� r3 )r� r_ rw c C s dS )zExit with `_AppResult`.Nry )r{ r� r_ ry ry r| rT � s z#BaseException | type[BaseException])r r_ rw c C s dS )zExit with exception.Nry )r{ r r_ ry ry r| rT � s z_AppResult | Nonez*BaseException | type[BaseException] | None)r� r r_ rw c C sj |du s|du sJ �| j du r&td��| j �� r8td��|| _|durT| j �|� n| j �tt|�� dS )a Exit application. .. note:: If `Application.exit` is called before `Application.run()` is called, then the `Application` won't exit (because the `Application.future` doesn't correspond to the current run). Use a `pre_run` hook and an event to synchronize the closing if there's a chance this can happen. :param result: Set this result for the application. :param exception: Set this exception as the result for an application. For a prompt, this is often `EOFError` or `KeyboardInterrupt`. :param style: Apply this style on the whole content when quitting, often this is 'class:exiting' for a prompt. (Used when `erase_when_done` is not set.) Nz6Application is not running. Application.exit() failed.z4Return value already set. Application.exit() failed.)r� � Exceptionr� r� r� Z set_resultr rW )r{ r� r r_ ry ry r| rT � s c C s | j js| js| j�� dS )z# Send CPR request. N)r� Z input_queuer� r� Z request_absolute_cursor_positionrz ry ry r| r� s z-Application._request_absolute_cursor_positionr r) )�command�wait_for_enter�display_before_text� wait_textrw c � s� t � 4 I dH �� z�j�� �W n ty: tj�� �Y n0 z�j�� �W n tyf tj�� �Y n0 dd�� ����fdd� }t|�I dH |r�t |�I dH W d �I dH q�1 I dH s�0 Y dS )a� Run system command (While hiding the prompt. When finished, all the output will scroll above the prompt.) :param command: Shell command to be executed. :param wait_for_enter: FWait for the user to press enter, when the command is finished. :param display_before_text: If given, text to be displayed before the command executes. :return: A `Future` object. Nr] r� c s& �� �� t� d��d�} | �� d S )NT)�shell�stdinr@ )� print_textr r/ )�p�rV rX Zinput_fdZ output_fdr{ ry r| � run_command> s z3Application.run_system_command.<locals>.run_command) rT ru �fileno�AttributeErrorr� r[ rv r@ r# r )r{ rV rW rX rY r_ ry r^ r| �run_system_command s z Application.run_system_command)� suspend_grouprw c s& t dur"dd�� fdd� }t|� dS )z� (Not thread safe -- to be called from inside the key bindings.) Suspend process. :param suspend_group: When true, suspend the whole process group. (This is the default, and probably what you want.) Nr] r� c s0 t tt�} � r t�d| � nt�t�� | � d S )Nr )r �int�_SIGTSTP�os�kill�getpid)r� �rc ry r| r� U s z.Application.suspend_to_background.<locals>.run)re rU )r{ rc r� ry ri r| �suspend_to_backgroundI s z!Application.suspend_to_background)�textr_ rw c C s" t | j||p| j| j| jd� dS )a\ Print a list of (style_str, text) tuples to the output. (When the UI is running, this method has to be called through `run_in_terminal`, otherwise it will destroy the UI.) :param text: List of ``(style_str, text)`` tuples. :param style: Style class to use. Defaults to the active style in the CLI. )rv Zformatted_textr_ re ra N)rE rv r� re ra )r{ rk r_ ry ry r| r\ c s �zApplication.print_textc C s | j S )z8`True` when the application is currently active/running.r� rz ry ry r| � is_runningv s zApplication.is_runningc C s | j r| j �� S dS r� )r� r� rz ry ry r| r� { s zApplication.is_donez list[str]c C s& | j j}|r"tdd� |�� D ��S g S )z| Return a list of used style strings. This is helpful for debugging, and for writing a new `Style`. c s s | ]}t �d d|��� V qdS )z\s+� N)�re�sub�strip)�.0Z style_strry ry r| � <genexpr>� s �z5Application.get_used_style_strings.<locals>.<genexpr>)r� Z_attrs_for_style�sortedr� )r{ Zattrs_for_stylery ry r| �get_used_style_strings� s �z"Application.get_used_style_strings)F)N)NTTr[ )NTTFN)NNr� )Tr� r )T)N))r; r< r= �__doc__r ZEMACSr� r� �propertyre r� r� r� r� r� r� r� r� r� r� r� r r� r� r r� r' r� rG r r� r r rT r� rb rj r\ rl r� rt ry ry ry r| rV i s� R�B 5, � �hU � �' �* �c @ s� e Zd ZdZddd�dd�Zedd�d d ��Zed d�d d ��Zdddd�dd�Zedd�dd��Z dd d�dd�Z dd d�dd�Z d S ) r� z� The `KeyBindings` of key bindings for a `Application`. This merges the global key bindings with the one of the current user control. rX r] )r- rw c C s || _ t� | _d S rx )r- r �_cache)r{ r- ry ry r| r� � s �z_CombinedRegistry.__init__r r� c C s t �dS �zZNot needed - this object is not going to be wrapped in another KeyBindings object.N��NotImplementedErrorrz ry ry r| �_version� s z_CombinedRegistry._versionz list[Binding]c C s t �dS rx ry rz ry ry r| �bindings� s z_CombinedRegistry.bindingsr< zlist[UIControl]r4 )r� �other_controlsrw c C s� g }t � }|}|�|� |�� }|dur2|�|� |�� r<q\| jj�|�}|du rVq\q|}qt|�D ]*}||vrd|�� }|durd|�t |�� qd| jj r�|�| jj � |�t | jj | jj �� |�| jj� |ddd� }t|�S )z� Create a `KeyBindings` object that merges the `KeyBindings` from the `UIControl` with all the parent controls and the global key bindings. N���)r� rF Zget_key_bindings�appendZis_modalr- r^ Z get_parentrA r2 rb r1 r� rg r� r6 ) r{ r� r} rb Zcollected_containers� container�kb�parentr� ry ry r| �_create_key_bindings� s: ��z&_CombinedRegistry._create_key_bindingsc s@ �j jj� t�j j�� ��� t��f}�j�|� ��fdd��S )Nc s �� � ��S rx )r� ry �r� r} r{ ry r| r} � r~ z1_CombinedRegistry._key_bindings.<locals>.<lambda>)r- r^ r� r� r� � frozensetrw r )r{ �keyry r� r| � _key_bindings� s �z _CombinedRegistry._key_bindingsr5 )r� rw c C s | j �|�S rx )r� �get_bindings_for_keys�r{ r� ry ry r| r� � s z'_CombinedRegistry.get_bindings_for_keysc C s | j �|�S rx )r� � get_bindings_starting_with_keysr� ry ry r| r� � s z1_CombinedRegistry.get_bindings_starting_with_keysN) r; r< r= ru r� rv r{ r| r� r� r� r� ry ry ry r| r� � s 6 r� r) r] )rY rw c � s� ddl m} t� }|�d�ddd�dd��}|�tj�ddd�d d ��}|| |d �}z|j�� I d H W n tyz Y n0 d S ) z� Create a sub application to wait for the enter key press. This has two advantages over using 'input'/'raw_input': - This will share the same input/output I/O. - This doesn't block the event loop. r )� PromptSessionZenter�Er] )r6 rw c S s | j �� d S rx )r- rT �r6 ry ry r| �_ok� s z _do_wait_for_enter.<locals>._okc S s dS )zDisallow typing.Nry r� ry ry r| �_ignore s z#_do_wait_for_enter.<locals>._ignore)rI rb N) Zprompt_toolkit.shortcutsr� r3 rF r: r r- r �KeyboardInterrupt)rY r� rb r� r� r� ry ry r| r � s � r zCallable[[], None]r$ )�handlerrw c c s� t tdd�}|du st� s$dV dS t� }t |di ��|�}z@|�|| � dV W |�|� |dur�|j||jg|j�R � n,|�|� |dur�|j||jg|j�R � 0 dS )a Attach the given callback as a WINCH signal handler within the context manager. Restore the original signal handler when done. The `Application.run` method will register SIGWINCH, so that it will properly repaint when the terminal window resizes. However, using `run_in_terminal`, we can temporarily send an application to the background, and run an other app in between, which will then overwrite the SIGWINCH. This is why it's important to restore the handler when the app terminates. rY NZ_signal_handlers) �getattrr� rP r r r� r� Z _callback�_args)r� Zsigwinchr� Zprevious_winch_handlerry ry r| r� s2 �� � ��r� r� c c s� zddl m} m}m} W n ty2 d V Y d S 0 ||j_| f|j_||j_| |f|j_t � t j �}|�t j �}z.d V W |d ur�t � t j |� |�t j |� n&|d ur�t � t j |� |�t j |� 0 d S )Nr )�c_int�c_void_p� pythonapi) �ctypesr� r� r� � ImportErrorZ PyOS_getsig�restype�argtypesZ PyOS_setsigr� � getsignalr� )r� r� r� ZsigintZ sigint_osry ry r| r� ; s* � �r� )�� __future__r r r� rf rn r� r� r� r� r r r r r r � contextlibr r � subprocessr � tracebackr �typingr r r r r r r r r r r Zprompt_toolkit.bufferr Zprompt_toolkit.cacher Zprompt_toolkit.clipboardr r Z prompt_toolkit.cursor_shapesr r Z prompt_toolkit.data_structuresr Zprompt_toolkit.enumsr Zprompt_toolkit.eventloopr r! r" r# Z prompt_toolkit.eventloop.utilsr$ Zprompt_toolkit.filtersr% r& r' r( Z prompt_toolkit.formatted_textr) Zprompt_toolkit.input.baser* Z prompt_toolkit.input.typeaheadr+ r, Z3prompt_toolkit.key_binding.bindings.page_navigationr- Z#prompt_toolkit.key_binding.defaultsr. Z&prompt_toolkit.key_binding.emacs_stater/ Z'prompt_toolkit.key_binding.key_bindingsr0 r1 r2 r3 r4 r5 r6 Z(prompt_toolkit.key_binding.key_processorr7 r8 Z#prompt_toolkit.key_binding.vi_stater9 Zprompt_toolkit.keysr: Z prompt_toolkit.layout.containersr; r< Z prompt_toolkit.layout.controlsr= r> Zprompt_toolkit.layout.dummyr? Z prompt_toolkit.layout.layoutr@ rA Zprompt_toolkit.outputrB rC Zprompt_toolkit.rendererrD rE Zprompt_toolkit.searchrF Zprompt_toolkit.stylesrG rH rI rJ rK rL rM rN Zprompt_toolkit.utilsrO rP �currentrR rS rU rT �__all__r� rW ZApplicationEventHandlerr� Z _SIGWINCHre rV r� r r� r� ry ry ry r| �<module> s� 4 $ ( � 2` ,
| ver. 1.1 | |
.
| PHP 8.3.30 | Ð“ÐµÐ½ÐµÑ€Ð°Ñ†Ð¸Ñ Ñтраницы: 0 |
proxy
|
phpinfo
|
ÐаÑтройка