Server : LiteSpeed System : Linux barito.iixcp.rumahweb.net 5.14.0-611.49.1.el9_7.x86_64 #1 SMP PREEMPT_DYNAMIC Tue Apr 21 16:39:08 EDT 2026 x86_64 User : elvh3918 ( 1528) PHP Version : 8.2.31 Disable Function : mail Directory : /usr/local/lib/python3.9/site-packages/prompt_toolkit/__pycache__/ |
a
��Sh# � @ st d Z ddlmZ ddlZddlZddlZddlZddlZddlZddl Z ddl
Z
ddl m Z ddl
mZ ddlmZ ddlmZmZmZmZmZmZ dd lmZ dd
lmZ dd l m Z m Z dd l m Z dd
l!m"Z" ddl#m$Z$m%Z%m&Z&m'Z'm(Z( ddl)m*Z* ddl+m,Z, ddl-m.Z.m/Z/ ddl0m1Z1m2Z2 ddl3m4Z4m5Z5 ddl6m7Z7m8Z8m9Z9 ddl:m;Z;m<Z< ddl=m>Z>m?Z? g d�Z@e�AeB�ZCG dd� deD�ZEG dd� de�ZFG d d � d �ZGe�Hd �ZIG d d � d �ZJed!gdf ZKed!geLf ZMG d"d!� d!�ZNed#ed$eeedf f d%�ZOd#d#d&�d'd(�ZPG d)d*� d*eD�ZQd5d!d+d+d+d,d-�d.d/�ZRd6d!d+d+d+d,d-�d0d1�ZSd!d+d+d,d2�d3d4�ZTdS )7zU
Data structures for the Buffer.
It holds the text, cursor position, history, etc...
� )� annotationsN)�deque)�Enum)�wraps)�Any�Callable� Coroutine�Iterable�TypeVar�cast� )�get_app)�run_in_terminal)� AutoSuggest�
Suggestion)�
FastDictCache)�
ClipboardData)�
CompleteEvent� Completer�
Completion�DummyCompleter�get_common_complete_suffix)�Document)�aclosing)� FilterOrBool� to_filter)�History�InMemoryHistory)�SearchDirection� SearchState)� PasteMode�SelectionState�
SelectionType)�Event�to_str)�ValidationError� Validator)�EditReadOnlyBuffer�Buffer�CompletionState�indent�unindent� reshape_textc @ s e Zd ZdZdS )r' z.Attempt editing of read-only :class:`.Buffer`.N��__name__�
__module__� __qualname__�__doc__� r2 r2 �?/usr/local/lib/python3.9/site-packages/prompt_toolkit/buffer.pyr' 6 s r' c @ s e Zd ZdZdZdZdZdS )�ValidationStatezCThe validation state of a buffer. This is set after the validation.�VALID�INVALID�UNKNOWNN)r. r/ r0 r1 r5 r6 r7 r2 r2 r2 r3 r4 : s r4 c @ sd e Zd ZdZdddddd�dd �Zd
d �d d
�Zddd�dd�Zdd �dd�Zedd �dd��Z dS )r) z;
Immutable class that contains a completion state.
Nr zlist[Completion] | None�
int | None�None)�original_document� completions�complete_index�returnc C s || _ |p g | _|| _d S �N)r: r; r< )�selfr: r; r< r2 r2 r3 �__init__G s
zCompletionState.__init__�str�r= c C s* | j j� d| j�dt| j��d| j�d�S )N�(z, <z> completions, index=�))� __class__r. r: �lenr; r< �r? r2 r2 r3 �__repr__X s zCompletionState.__repr__��indexr= c C s8 | j r4|du s.d| kr(t| j �k s.n J �|| _dS )z�
Create a new :class:`.CompletionState` object with the new index.
When `index` is `None` deselect the completion.
Nr )r; rF r< �r? rJ r2 r2 r3 � go_to_index[ s (zCompletionState.go_to_indexztuple[str, int]c C s� | j du r| jj| jjfS | jj}| jj}| j| j }|jdkrF|}n|d|j� }||j | }t|�t|j� }||fS dS )zM
Return (new_text, new_cursor_position) for this completion.
Nr ) r< r: �text�cursor_position�text_before_cursor�text_after_cursorr; �start_positionrF )r? Zoriginal_text_before_cursorZoriginal_text_after_cursor�c�before�new_text�new_cursor_positionr2 r2 r3 �new_text_and_positione s
z%CompletionState.new_text_and_positionzCompletion | Nonec C s | j dur| j| j S dS )zi
Return the current completion, or return `None` when no completion is
selected.
N)r< r; rG r2 r2 r3 �current_completiony s
z"CompletionState.current_completion)NN)
r. r/ r0 r1 r@ rH rL rV �propertyrW r2 r2 r2 r3 r) B s �
r) z(\s+|".*?"|'.*?')c @ s4 e Zd ZdZdddddd�d d
�Zdd �d d
�ZdS )�YankNthArgStatezT
For yank-last-arg/yank-nth-arg: Keep track of where we are in the history.
r ���� �intrA r9 )�history_position�n�previous_inserted_wordr= c C s || _ || _|| _d S r> )r] r_ r^ )r? r] r^ r_ r2 r2 r3 r@ � s zYankNthArgState.__init__rB c C s& | j j� d| j�d| j�d| j�d�S )Nz(history_position=z, n=z, previous_inserted_word=rD )rE r. r] r^ r_ rG r2 r2 r3 rH � s zYankNthArgState.__repr__N)r rZ r[ )r. r/ r0 r1 r@ rH r2 r2 r2 r3 rY � s �rY r( c @ sL e Zd ZdZd�ddd d
d d d d
d
d
ddd
d
dddddddd�dd�Zd d�dd�Zd�dddd�dd �Zdd�d d �Zd dd �d d!�Zddd �d"d#�Z e
d d�d$d%��Z e j d dd �d&d%��Z e
dd�d'd(��Z
e
j ddd �d)d(��Z
e
dd�d*d+��Zej ddd �d,d+��Zdd�d-d.�Zdd�d/d0�Ze
d1d�d2d3��Zej d1dd �d4d3��Zd�d1ddd5�d6d7�Ze
dd�d8d9��Zd�ddd:�d;d<�Zd=d>d d?�d@dA�Zd>ddB�dCdD�Zddd>ddE�dFdG�Zd�dddI�dJdK�Zd�dddI�dLdM�Zd�dddI�dNdO�Zd�dddI�dPdQ�Zd�ddddR�dSdT�Z d�ddddR�dUdV�Z d�dd dI�dWdX�Z d�dd dI�dYdZ�Z d�d dd\�d]d^�Z d�d dd\�d_d`�Z!dd�dadb�Z"dddc�ddde�Z#d�ddddf�dgdh�Z$d�ddddf�didj�Z%dd�dkdl�Z&dmdndo�dpdq�Z'dd�drds�Z(dtddc�dudv�Z)dwddx�dydz�Z*dd�d{d|�Z+ddd}�d~d�Z,d�dddI�d�d��Z-d�dddI�d�d��Z.d�dtddd��d�d��Z/d�dtdd��d�d��Z0e1j2fd�dd��d�d��Z3d�dd�d��d�d��Z4d�d�d�d��Z5e6j7dHfd�d�ddd��d�d��Z8d�ddd��d�d��Z9d�ddd��d�d��Z:d�ddd��d�d��Z;d�d ddddd��d�d��Z<dd�d�d��Z=dd�d�d��Z>d�ddd��d�d��Z?dd�d�d��Z@dd�d�d��ZAd�d�ddd�d��d�d��ZBd�d1d��d�d��ZCd�d�dddd��d�d��ZDd�d�dddd��d�d��ZEdd�d�d��ZFd�d�d�d��ZGd�d�d�d��ZHd�dd�d��d�dÄZId ddĜd�dƄZJd�dddd�ddȜd�dʄZKd�d�d�d̈́ZLd�d�d�dЄZMd�d�d�d҄ZNdd�d�dԄZOdS )�r( a�
The core data structure that holds the text and cursor position of the
current input line and implements all text manipulations on top of it. It
also implements the history, undo stack and the completion state.
:param completer: :class:`~prompt_toolkit.completion.Completer` instance.
:param history: :class:`~prompt_toolkit.history.History` instance.
:param tempfile_suffix: The tempfile suffix (extension) to be used for the
"open in editor" function. For a Python REPL, this would be ".py", so
that the editor knows the syntax highlighting to use. This can also be
a callable that returns a string.
:param tempfile: For more advanced tempfile situations where you need
control over the subdirectories and filename. For a Git Commit Message,
this would be ".git/COMMIT_EDITMSG", so that the editor knows the syntax
highlighting to use. This can also be a callable that returns a string.
:param name: Name for this buffer. E.g. DEFAULT_BUFFER. This is mostly
useful for key bindings where we sometimes prefer to refer to a buffer
by their name instead of by reference.
:param accept_handler: Called when the buffer input is accepted. (Usually
when the user presses `enter`.) The accept handler receives this
`Buffer` as input and should return True when the buffer text should be
kept instead of calling reset.
In case of a `PromptSession` for instance, we want to keep the text,
because we will exit the application, and only reset it during the next
run.
:param max_number_of_completions: Never display more than this number of
completions, even when the completer can produce more (limited by
default to 10k for performance).
Events:
:param on_text_changed: When the buffer text changes. (Callable or None.)
:param on_text_insert: When new text is inserted. (Callable or None.)
:param on_cursor_position_changed: When the cursor moves. (Callable or None.)
:param on_completions_changed: When the completions were changed. (Callable or None.)
:param on_suggestion_set: When an auto-suggestion text has been set. (Callable or None.)
Filters:
:param complete_while_typing: :class:`~prompt_toolkit.filters.Filter`
or `bool`. Decide whether or not to do asynchronous autocompleting while
typing.
:param validate_while_typing: :class:`~prompt_toolkit.filters.Filter`
or `bool`. Decide whether or not to do asynchronous validation while
typing.
:param enable_history_search: :class:`~prompt_toolkit.filters.Filter` or
`bool` to indicate when up-arrow partial string matching is enabled. It
is advised to not enable this at the same time as
`complete_while_typing`, because when there is an autocompletion found,
the up arrows usually browse through the completions, rather than
through the history.
:param read_only: :class:`~prompt_toolkit.filters.Filter`. When True,
changes will not be allowed.
:param multiline: :class:`~prompt_toolkit.filters.Filter` or `bool`. When
not set, pressing `Enter` will call the `accept_handler`. Otherwise,
pressing `Esc-Enter` is required.
Nr[ FT�' zCompleter | NonezAutoSuggest | NonezHistory | NonezValidator | Nonezstr | Callable[[], str]rA r zDocument | NonezBufferAcceptHandler | Noner\ zBufferEventHandler | Noner9 )� completer� auto_suggest�history� validator�tempfile_suffix�tempfile�name�complete_while_typing�validate_while_typing�enable_history_search�document�accept_handler� read_only� multiline�max_number_of_completions�on_text_changed�on_text_insert�on_cursor_position_changed�on_completions_changed�on_suggestion_setr= c C s t |
�}
t |�}t | �} t |
�}
t |�}|p0t� | _|| _|| _|| _|| _|| _| | _|| _ | | _
|
| _ |
| _ || _
|| _d| _|d u r�t� n|| _d| _t| |�| _t| |�| _t| |�| _t| |�| _t| |�| _ttdd�| _| � � | _ | � � | _ | � � | _!d | _"| j#| d� d S )Nr �
)�size)rk )$r r ra rb rd re rf rg rl rh ri rj rm rn ro �
text_widthr rc �_Buffer__cursor_positionr# rp rq rr rs rt r r �_document_cache� _create_auto_suggest_coroutine�_async_suggester�_create_completer_coroutine�_async_completer� _create_auto_validate_coroutine�_async_validator�_load_history_task�reset)r? ra rb rc rd re rf rg rh ri rj rk rl rm rn ro rp rq rr rs rt r2 r2 r3 r@ � sF �
�
zBuffer.__init__rB c C sF t | j�dk r| j}n| jd d� d }d| j�d|�dt| ��d�S )N� � z...z
<Buffer(name=z, text=z) at �>)rF rM rg �id)r? rM r2 r2 r3 rH ( s zBuffer.__repr__�bool)rk �append_to_historyr= c C s� |r | � � |pt� }|j| _d| _tj| _d| _g | _ d| _
d| _ d| _ d| _
d| _d| _g | _g | _| jdur|| j�� d| _t|jg�| _d| _dS )zR
:param append_to_history: Append current input to history first.
Nr )r� r rN rx �validation_errorr4 r7 �validation_state�selection_stateZmultiple_cursor_positions�preferred_column�complete_state�yank_nth_arg_state�document_before_paste�
suggestion�history_search_text� _undo_stack� _redo_stackr� �cancelr rM �_working_lines�_Buffer__working_index)r? rk r� r2 r2 r3 r� 0 s*
z Buffer.resetc sL � j du rHdd�� fdd� }t� �|� �� _ ddd�dd �}� j �|� dS )
a�
Create task for populating the buffer history (if not yet done).
Note::
This needs to be called from within the event loop of the
application, because history loading is async, and we need to be
sure the right event loop is active. Therefor, we call this method
in the `BufferControl.create_content`.
There are situations where prompt_toolkit applications are created
in one thread, but will later run in a different thread (Ptpython
is one example. The REPL runs in a separate thread, in order to
prevent interfering with a potential different event loop in the
main thread. The REPL UI however is still created in the main
thread.) We could decide to not support creating prompt_toolkit
objects in one thread and running the application in a different
thread, but history loading is the only place where it matters, and
this solves it.
Nr9 rB c � s8 � j �� 2 z&3 d H W } � j�| � � jd7 _q
6 d S )Nr )rc �loadr� �
appendleftr� )�itemrG r2 r3 � load_history� s z;Buffer.load_history_if_not_yet_loaded.<locals>.load_historyzasyncio.Future[None])�fr= c S sP z | � � W n> tjy Y n, ty0 Y n tyJ t�d� Y n0 dS )z�
Handle `load_history` result when either done, cancelled, or
when an exception was raised.
zLoading history failedN)�result�asyncio�CancelledError�
GeneratorExit�
BaseException�logger� exception)r� r2 r2 r3 �load_history_done� s z@Buffer.load_history_if_not_yet_loaded.<locals>.load_history_done)r� r
�create_background_task�add_done_callback)r? r� r� r2 rG r3 � load_history_if_not_yet_loadedq s
z%Buffer.load_history_if_not_yet_loaded)�valuer= c C s@ | j }| j}|| }|||< t|�t|�kr0dS ||kr<dS dS )z=set text at current working_index. Return whether it changed.TF)�
working_indexr� rF )r? r� r� Z
working_lines�original_valuer2 r2 r3 � _set_text� s zBuffer._set_textc C s | j }td|�| _ | j |kS )z/Set cursor position. Return whether it changed.r )rx �max)r? r� Zoriginal_positionr2 r2 r3 �_set_cursor_position� s zBuffer._set_cursor_positionc C s | j | j S r> )r� r� rG r2 r2 r3 rM � s z Buffer.textc C sF | j t|�krt|�| _ | �� r&t� �| �|�}|rB| �� d| _dS )z�
Setting text. (When doing this, make sure that the cursor_position is
valid for this text. text/cursor_position should be consistent at any time,
otherwise set a Document instead.)
N)rN rF rm r' r� �
_text_changedr� �r? r� �changedr2 r2 r3 rM � s
c C s | j S r> )rx rG r2 r2 r3 rN � s zBuffer.cursor_positionc C sL t |t�sJ �|t| j�kr&t| j�}|dk r2d}| �|�}|rH| �� dS )z*
Setting cursor position.
r N)�
isinstancer\ rF rM r� �_cursor_position_changedr� r2 r2 r3 rN � s
c C s | j S r> )r� rG r2 r2 r3 r� � s zBuffer.working_indexc C s" | j |kr || _ d| _| �� d S )Nr )r� rN r� �r? r� r2 r2 r3 r� � s
c C s^ d | _ tj| _d | _d | _d | _d | _d | _d | _ | j
� � | j rZ| �
� rZt� �| �� � d S r> )r� r4 r7 r� r� r� r� r� r� r� rp �firerd ri r
r� r rG r2 r2 r3 r� s
zBuffer._text_changedc C s& d | _ d | _d | _d | _| j�� d S r> )r� r� r� r� rr r� rG r2 r2 r3 r� s
z Buffer._cursor_position_changedr c C s | j | j| j| jf S )z�
Return :class:`~prompt_toolkit.document.Document` instance from the
current text, cursor position and selection state.
)ry rM rN r� rG r2 r2 r3 rk + s �zBuffer.documentc C s | � |� dS )z�
Set :class:`~prompt_toolkit.document.Document` instance.
This will set both the text and cursor position at the same time, but
atomically. (Change events will be triggered only after both have been set.)
N)� set_documentr� r2 r2 r3 rk 5 s )r� �bypass_readonlyr= c C sL |s| � � rt� �| �|j�}| �|j�}|r<| �� d| _|rH| �� dS )a3
Set :class:`~prompt_toolkit.document.Document` instance. Like the
``document`` property, but accept an ``bypass_readonly`` argument.
:param bypass_readonly: When True, don't raise an
:class:`.EditReadOnlyBuffer` exception, even
when the buffer is read-only.
.. warning::
When this buffer is read-only and `bypass_readonly` was not passed,
the `EditReadOnlyBuffer` exception will be caught by the
`KeyProcessor` and is silently suppressed. This is important to
keep in mind when writing key bindings, because it won't do what
you expect, and there won't be a stack trace. Use try/finally
around this function if you need some cleanup code.
N) rm r' r� rM r� rN r� r� r� )r? r� r� Z text_changedZcursor_position_changedr2 r2 r3 r� ? s zBuffer.set_documentc C s
t | j�S )z?
True when there is something handling accept.
)r� rl rG r2 r2 r3 �
is_returnableb s zBuffer.is_returnable)�clear_redo_stackr= c C sX | j r6| j d d | jkr6| j d d | jf| j d< n| j �| j| jf� |rTg | _dS )zy
Safe current state (input text and cursor position), so that we can
restore it by calling undo.
rZ r N)r� rM rN �appendr� )r? r� r2 r2 r3 �save_to_undo_stackk s
zBuffer.save_to_undo_stackz
Iterable[int]zCallable[[str], str])�line_index_iterator�transform_callbackr= c C sH | j �d�}|D ],}z||| �||< W q ty: Y q0 qd�|�S )a/
Transforms the text on a range of lines.
When the iterator yield an index not in the range of lines that the
document contains, it skips them silently.
To uppercase some lines::
new_text = transform_lines(range(5,10), lambda text: text.upper())
:param line_index_iterator: Iterator of line numbers (int)
:param transform_callback: callable that takes the original text of a
line, and return the new text for this line.
:returns: The new text.
�
)rM �split�
IndexError�join)r? r� r� �linesrJ r2 r2 r3 �transform_lines{ s zBuffer.transform_lines)r� r= c C sV | j }|j|�� }|j|�� }|jd|� ||j||� � |j|d� | _dS )z�
Apply the given transformation function to the current line.
:param transform_callback: callable that takes a string and return a new string.
N)rk rN �get_start_of_line_position�get_end_of_line_positionrM )r? r� rk �a�br2 r2 r3 �transform_current_line� s � ��z Buffer.transform_current_line)�from_�tor� r= c C sH ||k s J �d� | jd|� || j||� � | j|d� g�| _dS )z�
Transform a part of the input string.
:param from_: (int) start position.
:param to: (int) end position.
:param transform_callback: Callable which accepts a string and returns
the transformed string.
r[ N)r� rM )r? r� r� r� r2 r2 r3 �transform_region� s � ���zBuffer.transform_regionr )�countr= c C s | j | jj|d�7 _ d S �N�r� )rN rk Zget_cursor_left_position�r? r� r2 r2 r3 � cursor_left� s zBuffer.cursor_leftc C s | j | jj|d�7 _ d S r� )rN rk Zget_cursor_right_positionr� r2 r2 r3 � cursor_right� s zBuffer.cursor_rightc C s2 | j p | jj}| j| jj||d�7 _|| _ dS )z7(for multiline edit). Move cursor to the previous line.�r� r� N)r� rk �cursor_position_colrN Zget_cursor_up_position�r? r� Zoriginal_columnr2 r2 r3 � cursor_up� s
�
zBuffer.cursor_upc C s2 | j p | jj}| j| jj||d�7 _|| _ dS )z3(for multiline edit). Move cursor to the next line.r� N)r� rk r� rN Zget_cursor_down_positionr� r2 r2 r3 � cursor_down� s
�
zBuffer.cursor_down)r� �&go_to_start_of_line_if_history_changesr= c C s\ | j r| j|d� nD| jjdkr.| j|d� n*| jsX| j|d� |rX| j| j�� 7 _dS )z�
If we're not on the first line (of a multiline input) go a line up,
otherwise go back in history. (If nothing is selected.)
r� r N) r� �complete_previousrk �cursor_position_rowr� r� �history_backwardrN r� �r? r� r� r2 r2 r3 �auto_up� s zBuffer.auto_upc C sd | j r| j|d� nL| jj| jjd k r6| j|d� n*| js`| j|d� |r`| j| j� � 7 _dS )z�
If we're not on the last line (of a multiline input) go a line down,
otherwise go forward in history. (If nothing is selected.)
r� r N)
r� �
complete_nextrk r� �
line_countr� r� �history_forwardrN r� r� r2 r2 r3 � auto_down� s zBuffer.auto_downc C sr |dks J �d}| j dkrn| j| j | | j � }| jd| j | � | j| j d� }| j t|� }t||�| _|S )zj
Delete specified number of characters before cursor and return the
deleted text.
r r[ N)rN rM rF r rk )r? r� �deletedrT rU r2 r2 r3 �delete_before_cursor� s
�� zBuffer.delete_before_cursorc C sV | j t| j�k rN| jjd|� }| jd| j � | j| j t|� d� | _|S dS dS )zT
Delete specified number of characters and Return the deleted text.
Nr[ )rN rF rM rk rP )r? r� r� r2 r2 r3 �delete s ��z
Buffer.delete� )� separatorr= c C sD | j js@| j| j �� 7 _| �� | j j| | j j�d� | _dS )zs
Join the next line to the current one by deleting the line ending after
the current line.
r� N) rk Z on_last_linerN r� r� rO rP �lstriprM )r? r� r2 r2 r3 �join_next_line! s � ��zBuffer.join_next_linec s� | j s
J �t| j| j jg�\}}| jd|� }| j||� �� }| j|d� }� fdd�|D �}t|d�|� | t|d�|dd� � �d d�| _ dS )z*
Join the selected lines.
Nc s g | ]}|� d �� �qS )r� )r� )�.0�l�r� r2 r3 �
<listcomp>A � z.Buffer.join_selected_lines.<locals>.<listcomp>r[ rZ r �rM rN )
r� �sortedrN Zoriginal_cursor_positionrM �
splitlinesr r� rF rk )r? r� r� r� rS r� �afterr2 r� r3 �join_selected_lines1 s
� �zBuffer.join_selected_linesc C sX | j }|dkrT| j|d }| j|d }| jd|d � | | | j|d� | _dS )zA
Swap the last two characters before the cursor.
� r N)rN rM )r? �posr� r� r2 r2 r3 � swap_characters_before_cursorI s
z$Buffer.swap_characters_before_cursorrI c C s$ |t | j�k r || _t | j�| _dS )z1
Go to this item in the history.
N)rF r� r� rM rN rK r2 r2 r3 �
go_to_historyU s zBuffer.go_to_history)r� �disable_wrap_aroundr= c C sf | j rbt| j j�}| j jdu r$d}n4| j j|d krBd}|rXdS nt|d | j j| �}| �|� dS )zd
Browse to the next completions.
(Does nothing if there are no completion.)
Nr r )r� rF r; r< �min�go_to_completion)r? r� r� Zcompletions_countrJ r2 r2 r3 r� ] s �zBuffer.complete_nextc C s^ | j rZ| j jdkr d}|rPdS n0| j jdu r>t| j j�d }ntd| j j| �}| �|� dS )zh
Browse to the previous completions.
(Does nothing if there are no completion.)
r Nr )r� r< rF r; r� r� )r? r� r� rJ r2 r2 r3 r� t s zBuffer.complete_previousc C s | j r| �d� d| _ dS )zB
Cancel completion, go back to the original text.
N)r� r� rG r2 r2 r3 �cancel_completion� s
zBuffer.cancel_completionzlist[Completion]r) )r; r= c C s t | j|d�| _| j�� | jS )z�
Start completions. (Generate list of completions and initialize.)
By default, no completion will be selected.
)r: r; )r) rk r� rs r� )r? r; r2 r2 r3 �_set_completions� s
�
zBuffer._set_completionsc C s� t � }g }| jj�� }t| j�D ]�\}}t|�d��D ]z\}}|�� }|r6|�|�r6||vr6|� |� || j
kr~d|d }nd|d � d|d � �}|� t |t
|� |d�� q6q | j|ddd� d � | �d
� dS ) zj
Start a completion based on all the other lines in the document and the
history.
r� zCurrent, line %sr zHistory z, line )rM rQ � display_metaNrZ �r; r )�setrk Zcurrent_line_before_cursorr� � enumerater� r� �strip�
startswith�addr� r� r rF r� r� ) r? Zfound_completionsr; � current_line�i�string�jr� r� r2 r2 r3 � start_history_lines_completion� s*
��z%Buffer.start_history_lines_completionr8 c C s< | j s
J �| j }|�|� |�� \}}t||�| _|| _ dS )zK
Select a completion from the list of current completions.
N)r� rL rV r rk )r? rJ �staterT rU r2 r2 r3 r� � s
zBuffer.go_to_completionr )�
completionr= c C s4 | j r| �d� d| _ | �|j � | �|j� dS )z,
Insert a given completion.
N)r� r� r� rQ � insert_textrM )r? r r2 r2 r3 �apply_completion� s
zBuffer.apply_completionc C s( | � � r | jdu r$| jj| _nd| _dS )zy
Set `history_search_text`.
(The text before the cursor will be used for filtering the history.)
N)rj r� rk rO rG r2 r2 r3 �_set_history_search� s
zBuffer._set_history_search)r r= c C s | j du p| j| �| j �S )z�
True when the current entry matches the history search.
(when we don't have history search, it's also True.)
N)r� r� r� )r? r r2 r2 r3 �_history_matches� s �zBuffer._history_matchesc C sr | � � d}t| jd t| j��D ],}| �|�rB|| _|d8 }d}|dkr" qPq"|rnd| _| j| j�� 7 _dS )zl
Move forwards through the history.
:param count: Amount of items to move forward.
Fr Tr N) r �ranger� rF r� r rN rk r� �r? r� Zfound_somethingr r2 r2 r3 r� � s
zBuffer.history_forwardc C s` | � � d}t| jd dd�D ],}| �|�r>|| _|d8 }d}|dkr qLq |r\t| j�| _dS )z1
Move backwards through history.
Fr rZ Tr N)r r
r� r rF rM rN r r2 r2 r3 r� s
zBuffer.history_backward)r^ �_yank_last_argr= c C s |du st |t�sJ �| j�� }t|�s,dS | jdu rJt|r@dndd�}n| j}|dur^||_|jd }| t|�krzd}|| }dd� t �
|�D �}dd� |D �}z||j }W n t y� d}Y n0 |j r�| �
t|j �� | �|� ||_ ||_|| _dS ) ay
Pick nth word from previous history entry (depending on current
`yank_nth_arg_state`) and insert it at current position. Rotate through
history if called repeatedly. If no `n` has been given, take the first
argument. (The second word.)
:param n: (None or int), The index of the word from the previous line
to take.
NrZ r )r^ c S s g | ] }|� � �qS r2 )r� �r� �wr2 r2 r3 r� E r� z'Buffer.yank_nth_arg.<locals>.<listcomp>c S s g | ] }|r|�qS r2 r2 r
r2 r2 r3 r� F r� r[ )r� r\ rc � get_stringsrF r� rY r^ r] �_QUOTED_WORDS_REr� r� r_ r� r ) r? r^ r �history_stringsr �new_pos�line�words�wordr2 r2 r3 � yank_nth_arg$ s2
zBuffer.yank_nth_arg)r^ r= c C s | j |dd� dS )zp
Like `yank_nth_arg`, but if no argument has been given, yank the last
word by default.
T)r^ r N)r )r? r^ r2 r2 r3 �
yank_last_argW s zBuffer.yank_last_argr" )�selection_typer= c C s t | j|�| _dS )zR
Take the current cursor position as the start of this selection.
N)r! rN r� )r? r r2 r2 r3 �start_selection^ s zBuffer.start_selectionr )�_cutr= c C s" | j �� \}}|r|| _ d| _|S )a8
Copy selected text and return :class:`.ClipboardData` instance.
Notice that this doesn't store the copied data on the clipboard yet.
You can store it like this:
.. code:: python
data = buffer.copy_selection()
get_app().clipboard.set_data(data)
N)rk �
cut_selectionr� )r? r Z new_documentZclipboard_datar2 r2 r3 �copy_selectionf s
zBuffer.copy_selectionc C s | j dd�S )zS
Delete selected text and return :class:`.ClipboardData` instance.
T)r )r rG r2 r2 r3 r y s zBuffer.cut_selectionr )�data�
paste_moder� r= c C sJ t |t�sJ �|tjtjtjfv s&J �| j}| jj|||d�| _|| _dS )z5
Insert the data from the clipboard.
)r r� N) r� r r Z VI_BEFOREZVI_AFTER�EMACSrk �paste_clipboard_datar� )r? r r r� r: r2 r2 r3 r s �zBuffer.paste_clipboard_data)� copy_marginr= c C s& |r| � d| jj � n
| � d� dS )z?
Insert a line ending at the current position.
r� N)r rk �"leading_whitespace_in_current_line)r? r! r2 r2 r3 �newline� s zBuffer.newlinec C sF |r| j jd }nd}| j| j �� 7 _| �|� | jd8 _dS )z:
Insert a new line above the current one.
r� r N)rk r" rN r� r �r? r! �insertr2 r2 r3 �insert_line_above� s
zBuffer.insert_line_abovec C s8 |rd| j j }nd}| j| j �� 7 _| �|� dS )z:
Insert a new line below the current one.
r� N)rk r" rN r� r r$ r2 r2 r3 �insert_line_below� s
zBuffer.insert_line_below)r � overwrite� move_cursor�
fire_eventr= c
C s� | j }| j}|rd|||t|� � }d|v r>|d|�d�� }|d|� | ||t|� d� }n |d|� | ||d� }|r�| jt|� } n| j} t|| �| _|r�| j�� | jr�| � � r�t
� � | � � � | j
r�t
� � | �� � dS )z�
Insert characters at cursor position.
:param fire_event: Fire `on_text_insert` event. This is mainly used to
trigger autocompletion while typing.
r� N)rM rN rF �findr rk rq r� ra rh r
r� r} rb r{ )
r? r r( r) r* ZotextZocposZoverwritten_textrM �cposr2 r2 r3 r � s$ &
zBuffer.insert_textc C sH | j rD| j �� \}}|| jkr | j�| j| jf� t||d�| _qDq d S )N�rN )r� �poprM r� r� rN r rk �r? rM r� r2 r2 r3 �undo� s
z Buffer.undoc C s2 | j r.| jdd� | j �� \}}t||d�| _d S )NF)r� r- )r� r� r. r rk r/ r2 r2 r3 �redo� s z Buffer.redo)�
set_cursorr= c
C s� | j tjkr| j tjkS | jr�z| j�| j� W nR ty� } z:|r^tt d|j
�t | j ��| _
tj
| _ || _W Y d}~dS d}~0 0 tj| _ d| _dS )zv
Returns `True` if valid.
:param set_cursor: Set the cursor position, if an error was found.
r NFT)r� r4 r7 r5 rd �validaterk r% r� r� rN rF rM r6 r� )r? r2 �er2 r2 r3 r3 s �zBuffer.validatec
� s� | j tjkrdS d}| j}| jrnz| j�| j�I dH W n( ty` } z|}W Y d}~n
d}~0 0 | j|krnq |r|tj| _ ntj| _ || _ t
� � � q dS )a�
Asynchronous version of `validate()`.
This one doesn't set the cursor position.
We have both variants, because a synchronous version is required.
Handling the ENTER key needs to be completely synchronous, otherwise
stuff like type-ahead is going to give very weird results. (People
could type input while the ENTER key is still processed.)
An asynchronous version is required if we have `validate_while_typing`
enabled.
N) r� r4 r7 rk rd Zvalidate_asyncr% r6 r5 r� r
Z
invalidate)r? �errorrk r4 r2 r2 r3 �_validate_async" s
zBuffer._validate_asyncc C s8 | j r4| j�� }t|�r&|d | j kr4| j�| j � dS )z:
Append the current input to the history.
rZ N)rM rc r rF Z
append_string)r? r r2 r2 r3 r� L s
zBuffer.append_to_historyr ztuple[int, int] | None)� search_state�include_current_positionr� r= c s� |dks J �|j �|j� |�� �dddd�� ����fdd� }�j}�j}t|�D ]$}|||�}|du rn dS |\}}qR||jfS ) z�
Execute search. Return (working_index, cursor_position) tuple when this
search is applied. Returns `None` when this text cannot be found.
r r\ r ztuple[int, Document] | None)r� rk r= c sD � t jkr�|j���d�}|dur8| t|j|j| �fS t| d t�j�d �D ]N}|t�j�; }t�j| d�}|j�d�d�}|durP|t|j|�f S qPn�|j ��d�}|dur�| t|j|j| �fS t| d dd�D ]`}|t�j�; }t�j| t�j| ��}|j ��d�}|dur�|t|jt|j�| �f S q�dS ) zd
Do search one time.
Return (working_index, document) or `None`
)r8 � ignore_caseNr r T)r9 ���rZ )
r �FORWARDr+ r rM rN r
rF r� Zfind_backwards)r� rk Z new_indexr �� directionr9 r8 r? rM r2 r3 � search_onceg sH
�� �����
z#Buffer._search.<locals>.search_onceN)rM r= r9 r� rk r
rN ) r? r7 r8 r� r> r� rk �_r� r2 r< r3 �_searchW s
=
zBuffer._search)r7 r= c C sR | j |dd�}|du r | jS |\}}|| jkr6| j}nd}t| j| ||d�S dS )a#
Return a :class:`~prompt_toolkit.document.Document` instance that has
the text/cursor position for this search, if we would apply it. This
will be used in the
:class:`~prompt_toolkit.layout.BufferControl` to display feedback while
searching.
T)r8 N)� selection)r@ rk r� r� r r� )r? r7 �
search_resultr� rN rA r2 r2 r3 �document_for_search� s
�zBuffer.document_for_searchc C s. | j |||d�}|du r | jS |\}}|S dS )z�
Get the cursor position for this search.
(This operation won't change the `working_index`. It's won't go through
the history. Vi text objects can't span multiple items.)
�r8 r� N)r@ rN �r? r7 r8 r� rB r� rN r2 r2 r3 �get_search_position� s �zBuffer.get_search_positionc C s0 | j |||d�}|dur,|\}}|| _|| _dS )zi
Apply search. If something is found, set `working_index` and
`cursor_position`.
rD N)r@ r� rN rE r2 r2 r3 � apply_search� s
�zBuffer.apply_searchc C s
d | _ d S r> )r� rG r2 r2 r3 �exit_selection� s zBuffer.exit_selectionz tuple[str, Callable[[], None]]c sP t | j�}t�|�\}� t�|| j�d�� t�|� dd�� fdd� }� |fS )za
Simple (file) tempfile implementation.
Return (tempfile, cleanup_func).
�utf-8r9 rB c s t �� � d S r> )�os�unlinkr2 ��filenamer2 r3 �cleanup� s z/Buffer._editor_simple_tempfile.<locals>.cleanup) r$ re rf �mkstemprJ �writerM �encode�close)r? �suffixZ
descriptorrN r2 rL r3 �_editor_simple_tempfile� s
z Buffer._editor_simple_tempfilec s� t | j�}|s| �� S t|�}tj�|�\}}tj�|�rF|dd � }t�� � |r`tj� � |�� t�
� � tj� � |�}t |ddd�� }|� | j
� W d � n1 s�0 Y dd�� fdd� }||fS ) Nr r rI )�encodingr9 rB c s t �� � d S r> )�shutil�rmtreer2 ��dirpathr2 r3 rN s z0Buffer._editor_complex_tempfile.<locals>.cleanup)r$ rf rT rA rJ �pathr� �isabs�mkdtempr� �makedirs�openrP rM )r? Zheadtail�head�tailrM �fhrN r2 rX r3 �_editor_complex_tempfile s
*z Buffer._editor_complex_tempfilezasyncio.Task[None])�validate_and_handler= c sT �� � rt� ��jr"��� \�� n ��� \�� dd�� ���fdd� }t� �|� �S )ze
Open code in editor.
This returns a future, and runs in a thread executor.
r9 rB c � s� z�t ��fdd�dd�I d H } | r�t�d��F}|�� �d�}|�d�rR|d d� }t|t|�d ��_W d � n1 sx0 Y �r���� W � � n� � 0 d S )
Nc s
�� � �S r> )�_open_file_in_editorr2 )rM r? r2 r3 �<lambda>6 r� z4Buffer.open_in_editor.<locals>.run.<locals>.<lambda>T)Z in_executor�rbrI r� rZ r� ) r r^ �read�decode�endswithr rF rk rc )�successr� rM �Z cleanup_funcrM r? rc r2 r3 �run/ s �
0
z"Buffer.open_in_editor.<locals>.run)rm r' rf rb rT r
r� )r? rc rl r2 rk r3 �open_in_editor s zBuffer.open_in_editor)rM r= c C st t j�d�}t j�d�}||dddddg}|D ]@}|r.z$t�t�|�|g �}|dkW S tyl Y q.0 q.d S )
zc
Call editor executable.
Return True when we received a zero return code.
ZVISUALZEDITORz/usr/bin/editorz
/usr/bin/nanoz
/usr/bin/picoz /usr/bin/viz/usr/bin/emacsr F)rJ �environ�get�
subprocess�call�shlexr� �OSError)r? rM �visualZeditorZeditorsr4 �
returncoder2 r2 r3 rd O s$ � zBuffer._open_file_in_editor�CompleteEvent | None�� select_first� select_last�insert_common_part�complete_eventr= c C s< || | dksJ �t � �| j||||p0tdd�d�� dS )z�
Start asynchronous autocompletion of this buffer.
(This will do nothing if a previous completion was still in progress.)
r T)Zcompletion_requested)rx ry rz r{ N)r
r� r} r )r? rx ry rz r{ r2 r2 r3 �start_completions s ��zBuffer.start_completionz(Callable[..., Coroutine[Any, Any, None]]c s8 dddd�dd�� t ddddd d
d �� �fd d
�
�}|S )z�
Create function for asynchronous autocompletion.
(This consumes the asynchronous completer generator, which possibly
runs the completion algorithm in another thread.)
r r r� )rk r r= c S s& | j }|t|�|j d� }||jkS )z�
Return `True` if applying this completion doesn't have any effect.
(When it doesn't insert any new text.
N)rO rF rQ rM )rk r rO Z
replaced_textr2 r2 r3 �completion_does_nothing� s
�zCBuffer._create_completer_coroutine.<locals>.completion_does_nothingFNrv r9 rw c � sh �j }|ptdd�}�js �js$d S t�j d����_dd���fdd� }t�� �dd���fd d
� }t�|� �}z�t�j� ||��4 I d H �^}|2 z>3 d H W } �j
� | � �� � |� s� q�t
�j
��jkr� q�q�6 W d �I d H �q1 I d H s�0 Y W |�� �j�� n|�� �j�� 0 �j
}
t
|
�d k�rZ�||
d ��rZ|
d d �= |� �r:�j�rx�jjd u�r|d S |
�s�d �_�j�� d S | �r���d � n�|�r�t
|
�d � nv|�rdt||
�� � �r ��� � t
|
�d k�r� fd
d�|
D �|
d d �< �j|
d� nd �_nt
|
�d k�rd��d � n*�j j|jk�rNd S �j j�|j��rdt�d S )NT)Z
text_inserted)r: r� rB c s
�j � kS )ziKeep retrieving completions. Input text has not yet changed
while generating completions.)r� r2 )r� r? r2 r3 �proceed� s zLBuffer._create_completer_coroutine.<locals>.async_completer.<locals>.proceedr9 c � s6 �j �� � �� t�d�I dH � �� I dH q dS )a� Background loop to refresh the UI at most 3 times a second
while the completion are loading. Calling
`on_completions_changed.fire()` for every completion that we
receive is too expensive when there are many completions. (We
could tune `Application.max_render_postpone_time` and
`Application.min_redraw_interval`, but having this here is a
better approach.)
g333333�?N)rs r� �clearr� �sleep�waitr2 )�refresh_neededr? r2 r3 �refresh_while_loading� s
zZBuffer._create_completer_coroutine.<locals>.async_completer.<locals>.refresh_while_loadingr r c s g | ]}|� t� ���qS r2 )Z new_completion_from_positionrF )r� rR )� common_partr2 r3 r�
s �zOBuffer._create_completer_coroutine.<locals>.async_completer.<locals>.<listcomp>r� )rk r r� ra r) r� r# �
ensure_futurer Zget_completions_asyncr; r� r� rF ro r� rs r� r< r� r r r� rO r� �_Retry) rx ry rz r{ rk r~ r� Z refresh_task�async_generatorr r; �r} r? )r� r� r� r3 �async_completer� s� � ��6 � �
�
�
� �z;Buffer._create_completer_coroutine.<locals>.async_completer)FFFN��_only_one_at_a_time)r? r� r2 r� r3 r| � s �
z"Buffer._create_completer_coroutinez'Callable[[], Coroutine[Any, Any, None]]c s t dd�� fdd� �}|S )zl
Create function for asynchronous auto suggestion.
(This can be in another thread.)
r9 rB c � sN � j } � js� jsd S � j�� | �I d H }� j | krF|� _� j�� nt�d S r> )rk r� rb Zget_suggestion_asyncrt r� r� )rk r� rG r2 r3 �async_suggestor3 s
z>Buffer._create_auto_suggest_coroutine.<locals>.async_suggestorr� )r? r� r2 rG r3 rz - s z%Buffer._create_auto_suggest_coroutinec s t dd�� fdd� �}|S )zv
Create a function for asynchronous validation while typing.
(This can be in another thread.)
r9 rB c � s � � � I d H d S r> )r6 r2 rG r2 r3 �async_validatorP s z?Buffer._create_auto_validate_coroutine.<locals>.async_validatorr� )r? r� r2 rG r3 r~ H s z&Buffer._create_auto_validate_coroutinec C s> | j dd�}|r:| jr"| �| �}nd}| �� |s:| �� dS )z?
Validate buffer and handle the accept action.
T)r2 FN)r3 rl r� r� )r? ZvalidZ keep_textr2 r2 r3 rc V s zBuffer.validate_and_handle)NNNNr[ r[ r[ FFFNNFTr` NNNNN)NF)F)T)r )r )r )r )r F)r F)r )r )r� )r� )r F)r F)r )r )NF)N)F)T)T)T)FTT)F)Fr )Tr )Tr )F)FFFN)Pr. r/ r0 r1 r@ rH r� r� r� r� rX rM �setterrN r� r� r� rk r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r r� r r r r� r� r r r" Z
CHARACTERSr r r r r r r# r& r' r r0 r1 r3 r6 r� r@ rC rF rG rH rT rb rm rd r| r| rz r~ rc r2 r2 r2 r3 r( � s� = �8Q �A7 #
� � �$
3� �
�4 * �X � � /& � #�_T.)�bound)� coroutiner= c s. d�t � �dddd�� �fdd� �}tt|�S )a
Decorator that only starts the coroutine only if the previous call has
finished. (Used to make sure that we have only one autocompleter, auto
suggestor and validator running at a time.)
When the coroutine raises `_Retry`, it is restarted.
Fr )r� �kwr= c � s\ �rd S d�zDz� | i |��I d H W n t y< Y qY q0 W d�d S qW d�nd�0 d S )NTF)r� )r� r� �r� �runningr2 r3 �
new_coroutinev s
�z*_only_one_at_a_time.<locals>.new_coroutine)r r r� )r� r� r2 r� r3 r� l s r� c @ s e Zd ZdZdS )r� z Retry in `_only_one_at_a_time`.Nr- r2 r2 r2 r3 r� � s r� r\ r9 )�buffer�from_row�to_rowr� r= c sh | j j}| j j}t||�}d| � | �|� fdd��}t|t|��|d��| _ | j|t� � 7 _dS )z3
Indent text of a :class:`.Buffer` object.
� c s � | S r> r2 )r� �Zindent_contentr2 r3 re � r� zindent.<locals>.<lambda>r N� rk r� r� r
r� r Ztranslate_row_col_to_indexrN rF )r� r� r� r� � current_row� current_col�
line_rangerT r2 r� r3 r* � s
�r* c st | j j}| j j}t||�}d| � ddd�� fdd� }| �||�}t|t|��|d��| _ | j|t� � 7 _dS )z5
Unindent text of a :class:`.Buffer` object.
r� rA )rM r= c s* � }| � |�r | t|�d � S | �� S d S r> )r� rF r� )rM �remover� r2 r3 � transform� s
zunindent.<locals>.transformr Nr� ) r� r� r� r� r� r� r� r� rT r2 r� r3 r+ � s
�r+ )r� r� r� r= c C sJ | j �d�}|d|� }||d d� }|||d � }|�rFt�d|d �}|rZ|�� nd}|d d|� �dd�} d�|��� }
| jp�dt | � } | g} d}
|
D ]^}|
r�t |�|
d | kr�| �
d� | �
| � d}
n| �
d � |
d7 }
| �
|� |
t |�7 }
q�| d
dk�r | �
d� t d�|| | �t d�|| ��d �| _ dS ) zi
Reformat text, taking the width into account.
`to_row` is included.
(Vi 'gq' operator.)
TNr z^\s*r r� r[ �P r� rZ r� )
rM r� �re�search�end�replacer� r� rw rF r� r rk )r� r� r� r� Z lines_beforeZ lines_afterZlines_to_reformat�match�lengthr* r �widthZ
reshaped_textZ
current_widthr r2 r2 r3 r, � s8
�r, )r )r )Ur1 �
__future__r r� �loggingrJ r� rr rV rp rf � collectionsr �enumr � functoolsr �typingr r r r r
r Zapplication.currentr
Zapplication.run_in_terminalr rb r r �cacher Z clipboardr r r r r r r rk r Z eventloopr �filtersr r rc r r r� r r rA r r! r" �utilsr# r$ Z
validationr% r& �__all__� getLoggerr. r� � Exceptionr' r4 r) �compiler rY ZBufferEventHandlerr� ZBufferAcceptHandlerr( r� r� r� r* r+ r, r2 r2 r2 r3 �<module> sp
B
[ "