403Webshell
Server IP : 3.96.16.70  /  Your IP : 216.73.216.15
Web Server : Apache
System : Linux ip-172-31-26-103.ca-central-1.compute.internal 6.1.163-186.299.amzn2023.x86_64 #1 SMP PREEMPT_DYNAMIC Tue Feb 24 16:35:42 UTC 2026 x86_64
User : ec2-user ( 1000)
PHP Version : 8.4.18
Disable Function : NONE
MySQL : OFF  |  cURL : ON  |  WGET : ON  |  Perl : ON  |  Python : OFF  |  Sudo : ON  |  Pkexec : OFF
Directory :  /lib/python3.9/site-packages/prompt_toolkit/__pycache__/

Upload File :
current_dir [ Writeable ] document_root [ Writeable ]

 

Command :

[ Back ]     

Current File : /lib/python3.9/site-packages/prompt_toolkit/__pycache__/buffer.cpython-39.pyc
a

tK�a��@sndZddlZddlZddlZddlZddlZddlZddlZddlZddl	m
Z
ddlmZddl
mZddlmZmZmZmZmZmZmZmZmZmZmZmZddlmZdd	lmZdd
l m!Z!m"Z"ddl#m$Z$ddl%m&Z&dd
l'm(Z(m)Z)m*Z*m+Z+m,Z,ddl-m.Z.ddl/m0Z0m1Z1ddl2m3Z3m4Z4ddl5m6Z6m7Z7ddl8m9Z9m:Z:m;Z;ddl<m=Z=m>Z>ddl?m@Z@mAZAgd�ZBe�CeD�ZEGdd�deF�ZGGdd�de�ZHGdd�d�ZIe�Jd�ZKGdd�d�ZLedgdfZMedgeNfZOGd d�d�ZPed!ed"edfd#�ZQeQeQd$�d%d&�ZRGd'd(�d(eF�ZSd1ePeTeTeTdd)�d*d+�ZUd2ePeTeTeTdd)�d,d-�ZVePeTeTdd.�d/d0�ZWdS)3zU
Data structures for the Buffer.
It holds the text, cursor position, history, etc...
�N)�deque)�Enum)�wraps)�Any�	Awaitable�Callable�Deque�Iterable�List�Optional�Set�Tuple�TypeVar�Union�cast�)�get_app)�run_in_terminal)�AutoSuggest�
Suggestion)�
FastDictCache)�
ClipboardData)�
CompleteEvent�	Completer�
Completion�DummyCompleter�get_common_complete_suffix)�Document)�FilterOrBool�	to_filter)�History�InMemoryHistory)�SearchDirection�SearchState)�	PasteMode�SelectionState�
SelectionType)�Event�to_str)�ValidationError�	Validator)�EditReadOnlyBuffer�Buffer�CompletionState�indent�unindent�reshape_textc@seZdZdZdS)r+z.Attempt editing of read-only :class:`.Buffer`.N��__name__�
__module__�__qualname__�__doc__�r6r6�9/usr/lib/python3.9/site-packages/prompt_toolkit/buffer.pyr+?sr+c@seZdZdZdZdZdZdS)�ValidationStatezCThe validation state of a buffer. This is set after the validation.�VALID�INVALID�UNKNOWNN)r2r3r4r5r9r:r;r6r6r6r7r8Csr8c@s�eZdZdZddeedeedd�dd�Zed�d	d
�Z	eedd�dd
�Z
eeefd�dd�Ze
edd�dd��ZdS)r-z;
    Immutable class that contains a completion state.
    Nrr)�original_document�completions�complete_index�returncCs||_|pg|_||_dS�N)r<r=r>)�selfr<r=r>r6r6r7�__init__Os
zCompletionState.__init__�r?cCsd|jj|jt|j�|jfS)Nz"%s(%r, <%r> completions, index=%r))�	__class__r2r<�lenr=r>�rAr6r6r7�__repr__as�zCompletionState.__repr__��indexr?cCs8|jr4|dus.d|kr(t|j�ks.nJ�||_dS)z�
        Create a new :class:`.CompletionState` object with the new index.

        When `index` is `None` deselect the completion.
        Nr)r=rEr>�rArIr6r6r7�go_to_indexis(zCompletionState.go_to_indexcCs�|jdur|jj|jjfS|jj}|jj}|j|j}|jdkrF|}n|d|j�}||j|}t|�t|j�}||fSdS)zM
        Return (new_text, new_cursor_position) for this completion.
        Nr)	r>r<�text�cursor_position�text_before_cursor�text_after_cursorr=�start_positionrE)rAZoriginal_text_before_cursorZoriginal_text_after_cursor�c�before�new_text�new_cursor_positionr6r6r7�new_text_and_positionss

z%CompletionState.new_text_and_positioncCs|jdur|j|jSdS)zi
        Return the current completion, or return `None` when no completion is
        selected.
        N)r>r=rFr6r6r7�current_completion�s
z"CompletionState.current_completion)NN)r2r3r4r5rr
�intrB�strrGrKr
rU�propertyrVr6r6r6r7r-Js�
�
r-z(\s+|".*?"|'.*?')c@s4eZdZdZdeeedd�dd�Zed	�d
d�ZdS)
�YankNthArgStatezT
    For yank-last-arg/yank-nth-arg: Keep track of where we are in the history.
    r����N)�history_position�n�previous_inserted_wordr?cCs||_||_||_dSr@)r]r_r^)rAr]r^r_r6r6r7rB�szYankNthArgState.__init__rCcCsd|jj|j|j|jfS)Nz8%s(history_position=%r, n=%r, previous_inserted_word=%r))rDr2r]r^r_rFr6r6r7rG�s�zYankNthArgState.__repr__)rr[r\)r2r3r4r5rWrXrBrGr6r6r6r7rZ�s��rZr,c@seZdZdZd�eeeeeeeee	e
ege
ffe	e
ege
ffe
eeeee
eeeeeeeeeeeeeed�dd�Ze
d	�d
d�Zd�ee
edd�d
d�Zdd	�dd�Ze
ed�dd�Zeed�dd�Zee
d	�dd��Zeje
dd�dd��Zeed	�dd��Zejedd�dd��Zeed	�dd��Zejedd�dd��Zdd	�dd �Zdd	�d!d"�Zee
d	�d#d$��Zeje
dd�d%d$��Zd�e
edd&�d'd(�Z eed	�d)d*��Z!d�edd+�d,d-�Z"e#eee
ge
fe
d.�d/d0�Z$ee
ge
fdd1�d2d3�Z%eeee
ge
fdd4�d5d6�Z&d�edd8�d9d:�Z'd�edd8�d;d<�Z(d�edd8�d=d>�Z)d�edd8�d?d@�Z*d�eeddA�dBdC�Z+d�eeddA�dDdE�Z,d�ee
d8�dFdG�Z-d�ee
d8�dHdI�Z.d�e
ddK�dLdM�Z/d�e
ddK�dNdO�Z0dd	�dPdQ�Z1eddR�dSdT�Z2d�eeddU�dVdW�Z3d�eeddU�dXdY�Z4dd	�dZd[�Z5e6e7e8d\�d]d^�Z9dd	�d_d`�Z:eeddR�dadb�Z;e7ddc�ddde�Z<dd	�dfdg�Z=eedh�didj�Z>d�edd8�dkdl�Z?d�edd8�dmdn�Z@d�eeeddo�dpdq�ZAd�eeddr�dsdt�ZBeCjDfeCddu�dvdw�ZEd�eeFdx�dydz�ZGeFd	�d{d|�ZHeIjJd7feFeIedd}�d~d�ZKd�edd��d�d��ZLd�edd��d�d��ZMd�edd��d�d��ZNd�e
eeedd��d�d��ZOdd	�d�d��ZPdd	�d�d��ZQd�eed��d�d��ZRdd	�d�d��ZSdd	�d�d��ZTd�eUeeeeVeefd��d�d��ZWeUe
d��d�d��ZXd�eUeeed��d�d��ZYd�eUeedd��d�d��ZZdd	�d�d��Z[eVe
egdffd	�d�d��Z\eVe
egdffd	�d�d��Z]d�ed�d��d�d��Z^e
ed��d�d��Z_d�eeeee`dd��d�d��Zaed�ebdfd	�d�d��Zcegebdfd	�d�d��Zdegebdfd	�d�d��Zedd	�d�d��ZfdS)�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.

    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)�	completer�auto_suggest�history�	validator�tempfile_suffix�tempfile�name�complete_while_typing�validate_while_typing�enable_history_search�document�accept_handler�	read_only�	multiline�on_text_changed�on_text_insert�on_cursor_position_changed�on_completions_changed�on_suggestion_setcCst|
�}
t|�}t|	�}	t|
�}
t|�}|p0t�|_||_||_||_||_||_||_||_	|	|_
|
|_|
|_||_
d|_|dur�t�n||_d|_t||�|_t||�|_t||�|_t||�|_t||�|_ttdd�|_|��|_|��|_|��|_ d|_!|j"|d�dS)Nr�
)�size)rj)#rrr`rarcrdrerfrkrgrhrirlrm�
text_widthr!rb�_Buffer__cursor_positionr'rnrorprqrrrr�_document_cache�_create_auto_suggest_coroutine�_async_suggester�_create_completer_coroutine�_async_completer�_create_auto_validate_coroutine�_async_validator�_load_history_task�reset)rAr`rarbrcrdrerfrgrhrirjrkrlrmrnrorprqrrr6r6r7rB�sH��
�


zBuffer.__init__rCcCs<t|j�dkr|j}n|jdd�d}d|j|t|�fS)N��z...z <Buffer(name=%r, text=%r) at %r>)rErLrf�id)rArLr6r6r7rG:szBuffer.__repr__)rj�append_to_historyr?cCs�|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�rrMrv�validation_errorr8r;�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~ZcancelrrL�_working_lines�_Buffer__working_index)rArjr�r6r6r7rBs*


zBuffer.resetcsL�jdurHdd��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.
        NrCc�s8�j��2z&3dHW}�j�|��jd7_q
6dS)Nr)rb�loadr��
appendleftr�)�itemrFr6r7�load_history�sz;Buffer.load_history_if_not_yet_loaded.<locals>.load_historyzasyncio.Future[None])�fr?cSsPz|��Wn>tjy Yn,ty0YntyJt�d�Yn0dS)z�
                Handle `load_history` result when either done, cancelled, or
                when an exception was raised.
                zLoading history failedN)�result�asyncioZCancelledError�
GeneratorExit�
BaseException�logger�	exception)r�r6r6r7�load_history_done�sz@Buffer.load_history_if_not_yet_loaded.<locals>.load_history_done)r~r�create_background_taskZadd_done_callback)rAr�r�r6rFr7�load_history_if_not_yet_loaded�s

z%Buffer.load_history_if_not_yet_loaded)�valuer?cCs@|j}|j}||}|||<t|�t|�kr0dS||kr<dSdS)z=set text at current working_index. Return whether it changed.TF)�
working_indexr�rE)rAr�r�Z
working_lines�original_valuer6r6r7�	_set_text�szBuffer._set_textcCs|j}td|�|_|j|kS)z/Set cursor position. Return whether it changed.r)rv�max)rAr�Zoriginal_positionr6r6r7�_set_cursor_position�szBuffer._set_cursor_positioncCs|j|jSr@)r�r�rFr6r6r7rL�szBuffer.textcCsF|jt|�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)rMrErlr+r��
_text_changedr��rAr�Zchangedr6r6r7rL�s

cCs|jSr@)rvrFr6r6r7rM�szBuffer.cursor_positioncCsLt|t�sJ�|t|j�kr&t|j�}|dkr2d}|�|�}|rH|��dS)z*
        Setting cursor position.
        rN)�
isinstancerWrErLr��_cursor_position_changedr�r6r6r7rM�s

cCs|jSr@)r�rFr6r6r7r�	szBuffer.working_indexcCs"|j|kr||_d|_|��dS)Nr)r�rMr��rAr�r6r6r7r�
s
cCs^d|_tj|_d|_d|_d|_d|_d|_d|_	|j
��|jrZ|�
�rZt��|���dSr@)r�r8r;r�r�r�r�r�r�r�rn�firercrhrr�r}rFr6r6r7r�s
zBuffer._text_changedcCs&d|_d|_d|_d|_|j��dSr@)r�r�r�r�rpr�rFr6r6r7r�+s
zBuffer._cursor_position_changedcCs|j|j|j|jfS)z�
        Return :class:`~prompt_toolkit.document.Document` instance from the
        current text, cursor position and selection state.
        )rwrLrMr�rFr6r6r7rj=s�zBuffer.documentcCs|�|�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�r6r6r7rjGs)r��bypass_readonlyr?cCsL|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)	rlr+r�rLr�rMr�r�r�)rAr�r�Ztext_changedZcursor_position_changedr6r6r7r�QszBuffer.set_documentcCs
t|j�S)z?
        True when there is something handling accept.
        )�boolrkrFr6r6r7�
is_returnabletszBuffer.is_returnable)�clear_redo_stackr?cCsX|jr6|jdd|jkr6|jdd|jf|jd<n|j�|j|jf�|rTg|_dS)zy
        Safe current state (input text and cursor position), so that we can
        restore it by calling undo.
        r[rN)r�rLrM�appendr�)rAr�r6r6r7�save_to_undo_stack}s
zBuffer.save_to_undo_stack)�line_index_iterator�transform_callbackr?c	CsH|j�d�}|D],}z|||�||<Wqty:Yq0qd�|�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.
        �
)rL�split�
IndexError�join)rAr�r��linesrIr6r6r7�transform_lines�szBuffer.transform_lines)r�r?cCsV|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)rjrM�get_start_of_line_position�get_end_of_line_positionrL)rAr�rj�a�br6r6r7�transform_current_line�s���zBuffer.transform_current_line)�from_�tor�r?cCsH||ks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�rL)rAr�r�r�r6r6r7�transform_region�s����zBuffer.transform_regionr)�countr?cCs|j|jj|d�7_dS�N�r�)rMrjZget_cursor_left_position�rAr�r6r6r7�cursor_left�szBuffer.cursor_leftcCs|j|jj|d�7_dSr�)rMrjZget_cursor_right_positionr�r6r6r7�cursor_right�szBuffer.cursor_rightcCs2|jp|jj}|j|jj||d�7_||_dS)z7(for multiline edit). Move cursor to the previous line.�r�r�N)r�rj�cursor_position_colrMZget_cursor_up_position�rAr�Zoriginal_columnr6r6r7�	cursor_up�s
�
zBuffer.cursor_upcCs2|jp|jj}|j|jj||d�7_||_dS)z3(for multiline edit). Move cursor to the next line.r�N)r�rjr�rMZget_cursor_down_positionr�r6r6r7�cursor_down�s
�
zBuffer.cursor_down)r��&go_to_start_of_line_if_history_changesr?cCs\|jr|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�rN)	r��complete_previousrj�cursor_position_rowr�r��history_backwardrMr��rAr�r�r6r6r7�auto_up�szBuffer.auto_upcCsd|jr|j|d�nL|jj|jjdkr6|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�rN)
r��
complete_nextrjr�Z
line_countr�r��history_forwardrMr�r�r6r6r7�	auto_down�szBuffer.auto_downcCsr|dksJ�d}|jdkrn|j|j||j�}|jd|j|�|j|jd�}|jt|�}t||�|_|S)zj
        Delete specified number of characters before cursor and return the
        deleted text.
        rr\N)rMrLrErrj)rAr��deletedrSrTr6r6r7�delete_before_cursors
��zBuffer.delete_before_cursorcCsV|jt|j�krN|jjd|�}|jd|j�|j|jt|�d�|_|SdSdS)zT
        Delete specified number of characters and Return the deleted text.
        Nr\)rMrErLrjrO)rAr�r�r6r6r7�delete%s��z
Buffer.delete� )�	separatorr?cCsD|jjs@|j|j��7_|��|jj||jj�d�|_dS)zs
        Join the next line to the current one by deleting the line ending after
        the current line.
        r�N)	rjZon_last_linerMr�r�rNrO�lstriprL)rAr�r6r6r7�join_next_line3s���zBuffer.join_next_linec	s�|js
J�t|j|jjg�\}}|jd|�}|j||���}|j|d�}�fdd�|D�}t|d�|�|t|d�|dd���dd�|_	dS)z*
        Join the selected lines.
        Ncsg|]}|�d���qS)r�)r�)�.0�l�r�r6r7�
<listcomp>S�z.Buffer.join_selected_lines.<locals>.<listcomp>r\r[r�rLrM)
r��sortedrMZoriginal_cursor_positionrL�
splitlinesrr�rErj)rAr�r�r�rRr�Zafterr6r�r7�join_selected_linesCs
��zBuffer.join_selected_linescCsX|j}|dkrT|j|d}|j|d}|jd|d�|||j|d�|_dS)zA
        Swap the last two characters before the cursor.
        �rN)rMrL)rA�posr�r�r6r6r7�swap_characters_before_cursor[s
z$Buffer.swap_characters_before_cursorrHcCs$|t|j�kr ||_t|j�|_dS)z1
        Go to this item in the history.
        N)rEr�r�rLrMrJr6r6r7�
go_to_historygszBuffer.go_to_history)r��disable_wrap_aroundr?cCsf|jrbt|jj�}|jjdur$d}n4|jj|dkrBd}|rXdSnt|d|jj|�}|�|�dS)zd
        Browse to the next completions.
        (Does nothing if there are no completion.)
        Nrr)r�rEr=r>�min�go_to_completion)rAr�r�Zcompletions_countrIr6r6r7r�os�zBuffer.complete_nextcCs^|jrZ|jjdkr d}|rPdSn0|jjdur>t|jj�d}ntd|jj|�}|�|�dS)zh
        Browse to the previous completions.
        (Does nothing if there are no completion.)
        rNr)r�r>rEr=r�r�)rAr�r�rIr6r6r7r��s	zBuffer.complete_previouscCs|jr|�d�d|_dS)zB
        Cancel completion, go back to the original text.
        N)r�r�rFr6r6r7�cancel_completion�s
zBuffer.cancel_completion)r=r?cCs t|j|d�|_|j��|jS)z�
        Start completions. (Generate list of completions and initialize.)

        By default, no completion will be selected.
        )r<r=)r-rjr�rqr�)rAr=r6r6r7�_set_completions�s
�
zBuffer._set_completionsc		Cs�t�}g}|jj��}t|j�D]�\}}t|�d��D]v\}}|��}|r6|�|�r6||vr6|�	|�||j
kr~d|d}nd|d|df}|�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 %srzHistory %s, line %s)rLrP�display_metaNr[�r=r)�setrjZcurrent_line_before_cursorr��	enumerater�r��strip�
startswith�addr�r�rrEr�r�)	rAZfound_completionsr=Zcurrent_line�i�string�jr�r�r6r6r7�start_history_lines_completion�s*

��z%Buffer.start_history_lines_completioncCs<|js
J�|j}|�|�|��\}}t||�|_||_dS)zK
        Select a completion from the list of current completions.
        N)r�rKrUrrj)rArI�staterSrTr6r6r7r��s

zBuffer.go_to_completion)�
completionr?cCs4|jr|�d�d|_|�|j�|�|j�dS)z,
        Insert a given completion.
        N)r�r�r�rP�insert_textrL)rAr�r6r6r7�apply_completion�s

zBuffer.apply_completioncCs(|��r|jdur$|jj|_nd|_dS)zy
        Set `history_search_text`.
        (The text before the cursor will be used for filtering the history.)
        N)rir�rjrNrFr6r6r7�_set_history_search�s
zBuffer._set_history_search)r�r?cCs|jdup|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�)rAr�r6r6r7�_history_matchess�zBuffer._history_matchescCsr|��d}t|jdt|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.
        FrTrN)	r��ranger�rEr�r�rMrjr��rAr�Zfound_somethingr�r6r6r7r�	s
zBuffer.history_forwardcCs`|��d}t|jddd�D],}|�|�r>||_|d8}d}|dkrqLq|r\t|j�|_dS)z1
        Move backwards through history.
        Frr[TrN)r�rr�r�rErLrMrr6r6r7r�!s
zBuffer.history_backward)r^�_yank_last_argr?c	Cs|dust|t�sJ�|j��}t|�s,dS|jdurJt|r@dndd�}n|j}|dur^||_|jd}|t|�krzd}||}dd�t	�
|�D�}dd�|D�}z||j}Wnty�d}Yn0|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.
        Nr[r)r^cSsg|]}|���qSr6)r��r��wr6r6r7r�Yr�z'Buffer.yank_nth_arg.<locals>.<listcomp>cSsg|]}|r|�qSr6r6rr6r6r7r�Zr�r\)r�rWrb�get_stringsrEr�rZr^r]�_QUOTED_WORDS_REr�r�r_r�r�)	rAr^r�history_stringsr�Znew_pos�line�wordsZwordr6r6r7�yank_nth_arg6s2




zBuffer.yank_nth_arg)r^r?cCs|j|dd�dS)zp
        Like `yank_nth_arg`, but if no argument has been given, yank the last
        word by default.
        T)r^rN)r
)rAr^r6r6r7�
yank_last_argkszBuffer.yank_last_arg)�selection_typer?cCst|j|�|_dS)zR
        Take the current cursor position as the start of this selection.
        N)r%rMr�)rArr6r6r7�start_selectionrszBuffer.start_selection)�_cutr?cCs"|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)rj�
cut_selectionr�)rArZnew_documentZclipboard_datar6r6r7�copy_selectionzs
zBuffer.copy_selectioncCs|jdd�S)zS
        Delete selected text and return :class:`.ClipboardData` instance.
        T)r)rrFr6r6r7r�szBuffer.cut_selection)�data�
paste_moder�r?cCsJt|t�sJ�|tjtjtjfvs&J�|j}|jj|||d�|_||_dS)z5
        Insert the data from the clipboard.
        )rr�N)	r�rr$Z	VI_BEFOREZVI_AFTER�EMACSrj�paste_clipboard_datar�)rArrr�r<r6r6r7r�s	�zBuffer.paste_clipboard_data)�copy_marginr?cCs&|r|�d|jj�n
|�d�dS)z?
        Insert a line ending at the current position.
        r�N)r�rj�"leading_whitespace_in_current_line)rArr6r6r7�newline�szBuffer.newlinecCsF|r|jjd}nd}|j|j��7_|�|�|jd8_dS)z:
        Insert a new line above the current one.
        r�rN)rjrrMr�r��rAr�insertr6r6r7�insert_line_above�s
zBuffer.insert_line_abovecCs8|rd|jj}nd}|j|j��7_|�|�dS)z:
        Insert a new line below the current one.
        r�N)rjrrMr�r�rr6r6r7�insert_line_below�s
zBuffer.insert_line_below)r�	overwrite�move_cursor�
fire_eventr?c
Cs�|j}|j}|rd|||t|��}d|vr>|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)rLrMrE�findrrjror�r`rgrr�r{rary)
rArrrrZotextZocposZoverwritten_textrLZcposr6r6r7r��s$&
zBuffer.insert_textcCsH|jrD|j��\}}||jkr|j�|j|jf�t||d�|_qDqdS)N�rM)r��poprLr�r�rMrrj�rArLr�r6r6r7�undo�s
zBuffer.undocCs2|jr.|jdd�|j��\}}t||d�|_dS)NF)r�r )r�r�r!rrjr"r6r6r7�redoszBuffer.redo)�
set_cursorr?c
Cs�|jtjkr|jtjkS|jr�z|j�|j�WnRty�}z:|r^tt	d|j
�t|j��|_
tj
|_||_WYd}~dSd}~00tj|_d|_dS)zv
        Returns `True` if valid.

        :param set_cursor: Set the cursor position, if an error was found.
        rNFT)r�r8r;r9rc�validaterjr)r�r�rMrErLr:r�)rAr%�er6r6r7r&s �zBuffer.validatec
�s�|jtjkrdSd}|j}|jrnz|j�|j�IdHWn(ty`}z|}WYd}~n
d}~00|j|krnq|r|tj|_ntj|_||_	t
���qdS)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�r8r;rjrcZvalidate_asyncr)r:r9r�rZ
invalidate)rA�errorrjr'r6r6r7�_validate_async6s 

zBuffer._validate_asynccCs8|jr4|j��}t|�r&|d|jkr4|j�|j�dS)z:
        Append the current input to the history.
        r[N)rLrbrrEZ
append_string)rArr6r6r7r�`s
zBuffer.append_to_history)�search_state�include_current_positionr�r?c	s�|dksJ�|j�|j�|���ttttttfd������fdd�}�j}�j}t	|�D]$}|||�}|durzdS|\}}q^||j
fS)z�
        Execute search. Return (working_index, cursor_position) tuple when this
        search is applied. Returns `None` when this text cannot be found.
        r)r�rjr?csD�tjkr�|j���d�}|dur8|t|j|j|�fSt|dt�j�d�D]N}|t�j�;}t�j|d�}|j�d�d�}|durP|t|j|�fSqPn�|j	��d�}|dur�|t|j|j|�fSt|ddd�D]`}|t�j�;}t�j|t�j|��}|j	��d�}|dur�|t|jt|j�|�fSq�dS)	zd
            Do search one time.
            Return (working_index, document) or `None`
            )r+�ignore_caseNrrT)r,���r[)
r"ZFORWARDrrrLrMrrEr�Zfind_backwards)r�rjZ	new_indexr���	directionr,r+rArLr6r7�search_once{sH
�������
z#Buffer._search.<locals>.search_onceN)rLr/r,rWrrr
r�rjrrM)	rAr*r+r�r0r�rj�_r�r6r.r7�_searchks
�=

zBuffer._search)r*r?cCsR|j|dd�}|dur|jS|\}}||jkr6|j}nd}t|j|||d�SdS)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)r+N)�	selection)r2rjr�r�rr�)rAr*�
search_resultr�rMr3r6r6r7�document_for_search�s
�zBuffer.document_for_searchcCs.|j|||d�}|dur|jS|\}}|SdS)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.)
        �r+r�N)r2rM�rAr*r+r�r4r�rMr6r6r7�get_search_position�s�zBuffer.get_search_positioncCs0|j|||d�}|dur,|\}}||_||_dS)zi
        Apply search. If something is found, set `working_index` and
        `cursor_position`.
        r6N)r2r�rMr7r6r6r7�apply_search�s
�zBuffer.apply_searchcCs
d|_dSr@)r�rFr6r6r7�exit_selectionszBuffer.exit_selectioncsPt|j�}t�|�\}�t�||j�d��t�|�dd��fdd�}�|fS)za
        Simple (file) tempfile implementation.
        Return (tempfile, cleanup_func).
        �utf-8NrCcst���dSr@)�os�unlinkr6��filenamer6r7�cleanupsz/Buffer._editor_simple_tempfile.<locals>.cleanup)	r(rdreZmkstempr<�writerL�encode�close)rA�suffixZ
descriptorr@r6r>r7�_editor_simple_tempfiles

zBuffer._editor_simple_tempfilecs�t|j�}|s|��St|�}tj�|�\}}tj�|�rF|dd�}t���|r`tj�	�|��t�
��tj�	�|�}t|ddd��}|�|j
�Wd�n1s�0Ydd��fdd�}||fS)Nrrr;)�encodingrCcst���dSr@)�shutilZrmtreer6��dirpathr6r7r@/sz0Buffer._editor_complex_tempfile.<locals>.cleanup)r(rerErXr<�pathr��isabsZmkdtempr��makedirs�openrArL)rAZheadtail�head�tailr?Zfhr@r6rHr7�_editor_complex_tempfiles 

*zBuffer._editor_complex_tempfilezasyncio.Task[None])�validate_and_handler?csT���rt���jr"���\��n���\��dd�����fdd�}t��|��S)ze
        Open code in editor.

        This returns a future, and runs in a thread executor.
        NrCc�s�z�t��fdd�dd�IdH}|r�t�d��F}|���d�}|�d�rR|dd�}t|t|�d	��_Wd�n1sx0Y�r����W��n��0dS)
Ncs
����Sr@)�_open_file_in_editorr6)r?rAr6r7�<lambda>Jr�z4Buffer.open_in_editor.<locals>.run.<locals>.<lambda>T)Zin_executor�rbr;r�r[r�)	rrM�read�decode�endswithrrErjrQ)Zsuccesr�rL�Zcleanup_funcr?rArQr6r7�runCs�
0
z"Buffer.open_in_editor.<locals>.run)rlr+rerPrErr�)rArQrYr6rXr7�open_in_editor4szBuffer.open_in_editor)r?r?c	Csttj�d�}tj�d�}||dddddg}|D]@}|r.z$t�t�|�|g�}|dkWStylYq.0q.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/emacsrF)r<�environ�get�
subprocessZcall�shlexr��OSError)rAr?ZvisualZeditorZeditorsr'�
returncoder6r6r7rRcs$�zBuffer._open_file_in_editor��select_first�select_last�insert_common_part�complete_eventr?c	Cs<|||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.)
        rT)Zcompletion_requested)rbrcrdreN)rr�r{r)rArbrcrdrer6r6r7�start_completion�s��zBuffer.start_completion.cs<tttd�dd��td	tttttdd���fdd�
�}|S)
z�
        Create function for asynchronous autocompletion.

        (This consumes the asynchronous completer generator, which possibly
        runs the completion algorithm in another thread.)
        )rjr�r?cSs&|j}|t|�|jd�}||jkS)z�
            Return `True` if applying this completion doesn't have any effect.
            (When it doesn't insert any new text.
            N)rNrErPrL)rjr�rNZ
replaced_textr6r6r7�completion_does_nothing�s
�zCBuffer._create_completer_coroutine.<locals>.completion_does_nothingFNrac�s��j}|ptdd�}�js �js$dSt�jd����_td���fdd�}�j�||�2z,3dHW}�j�|��j	�
�|�sXq�qX6�j}t|�dkr��||d�r�|dd�=|��r��jr̈jjdur�dS|s�d�_�j	�
�dS|r���
d�n�|�r��
t|�d�nv|�r�t||����rp����t|�dk�rh�fd	d
�|D�|dd�<�j|d�nd�_nt|�dk�r���
d�n*�jj|jk�r�dS�jj�|j��r�t�dS)NT)Z
text_inserted)r<rCcs
�j�kS)ziKeep retrieving completions. Input text has not yet changed
                while generating completions.)r�r6)r�rAr6r7�proceed�szLBuffer._create_completer_coroutine.<locals>.async_completer.<locals>.proceedrrcsg|]}|�t����qSr6)Znew_completion_from_positionrE)r�rQ)�common_partr6r7r�s�zOBuffer._create_completer_coroutine.<locals>.async_completer.<locals>.<listcomp>r�)rjrr�r`r-r�Zget_completions_asyncr=r�rqr�rEr>r�rr�r�rNr��_Retry)rbrcrdrerjrhr�r=�rgrA)rir�r7�async_completer�sf�
�
�
�



��z;Buffer._create_completer_coroutine.<locals>.async_completer)FFFN)rrr��_only_one_at_a_timerr)rArlr6rkr7rz�s��lz"Buffer._create_completer_coroutinecstdd��fdd��}|S)zl
        Create function for asynchronous auto suggestion.
        (This can be in another thread.)
        NrCc�sN�j}�js�jsdS�j��|�IdH}�j|krF|�_�j��nt�dSr@)rjr�raZget_suggestion_asyncrrr�rj)rjr�rFr6r7�async_suggestor's
z>Buffer._create_auto_suggest_coroutine.<locals>.async_suggestor�rm)rArnr6rFr7rx!sz%Buffer._create_auto_suggest_coroutinecstdd��fdd��}|S)zv
        Create a function for asynchronous validation while typing.
        (This can be in another thread.)
        NrCc�s���IdHdSr@)r)r6rFr6r7�async_validatorBsz?Buffer._create_auto_validate_coroutine.<locals>.async_validatorro)rArpr6rFr7r|<sz&Buffer._create_auto_validate_coroutinecCs>|jdd�}|r:|jr"|�|�}nd}|��|s:|��dS)z?
        Validate buffer and handle the accept action.
        T)r%FN)r&rkr�r)rAZvalidZ	keep_textr6r6r7rQHszBuffer.validate_and_handle)NNNNr\r\r\FFFNNFTNNNNN)NF)F)T)r)r)r)r)rF)rF)r)r)r�)r�)rF)rF)r)r)NF)N)F)T)T)T)FTT)F)Fr)Tr)Tr)F)FFFN)gr2r3r4r5rrrr r*rrXrrr�BufferAcceptHandler�BufferEventHandlerrBrGr�rr�r�rWr�rYrL�setterrMr�r�r�rjr�r�r�r	r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r
rr-r�r�r�r�r�r�r�r�r
rr&Z
CHARACTERSr
rrrr$rrrrrr�r#r$r&r)r�r#r
r2r5r8r9r:rErPrZrRrrfrrzrxr|rQr6r6r6r7r,�s�:��R	��A7			#� �
������$
	��5��	��	
��4	*��X����/&���_T.)�bound)�	coroutiner?cs.d�t��tttd���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.
    F)r��kwr?c�s\�rdSd�zDz�|i|��IdHWnty<YqYq0Wd�dSqWd�nd�0dS)NTF)rj)r�rw�rvZrunningr6r7�
new_coroutinehs
�z*_only_one_at_a_time.<locals>.new_coroutine)rrrrt)rvryr6rxr7rm^srmc@seZdZdZdS)rjzRetry in `_only_one_at_a_time`.Nr1r6r6r6r7rj�srj)�buffer�from_row�to_rowr�r?csZ|jj}t||�}|�|�fdd��}t|t|��|d��|_|j|jjdd�7_dS)z3
    Indent text of a :class:`.Buffer` object.
    csd�|S�Nz    r6)r�r�r6r7rS�r�zindent.<locals>.<lambda>rT�Zafter_whitespaceN)rjr�rr�r�translate_row_col_to_indexrMr�)rzr{r|r��current_row�
line_rangerSr6r�r7r.�s
��r.csf|jj}t||�}ttd��fdd�}|�||�}t|t|��|d��|_|j|jjdd�7_dS)z5
    Unindent text of a :class:`.Buffer` object.
    )rLr?cs.d�}|�|�r"|t|�d�S|��SdSr})r�rEr�)rL�remover�r6r7�	transform�s
zunindent.<locals>.transformrTr~N)	rjr�rrXr�rrrMr�)rzr{r|r�r�r�r�rSr6r�r7r/�s
��r/)rzr{r|r?cCsJ|j�d�}|d|�}||dd�}|||d�}|�rFt�d|d�}|rZ|��nd}|dd|��dd�}	d�|���}
|jp�dt	|	�}|	g}d}
|
D]^}|
r�t	|�|
d|kr�|�
d�|�
|	�d}
n|�
d	�|
d7}
|�
|�|
t	|�7}
q�|d
dk�r|�
d�td�|||�t	d�||��d�|_dS)zi
    Reformat text, taking the width into account.
    `to_row` is included.
    (Vi 'gq' operator.)
    TNrz^\s*rr�r\�Pr�r[r�)
rLr��re�search�end�replacer�r�rurEr�rrj)rzr{r|r�Zlines_beforeZlines_afterZlines_to_reformat�matchZlengthr.r	�widthZ
reshaped_textZ
current_widthrr6r6r7r0�s8




�r0)r)r)Xr5r�Zloggingr<r�r^rGr]re�collectionsr�enumr�	functoolsr�typingrrrrr	r
rrr
rrrZapplication.currentrZapplication.run_in_terminalrrarr�cacherZ	clipboardrr�rrrrrrjr�filtersrrrbr r!r�r"r#r3r$r%r&Zutilsr'r(Z
validationr)r*�__all__Z	getLoggerr2r��	Exceptionr+r8r-�compilerrZrrr�rqr,rtrmrjrWr.r/r0r6r6r6r7�<module>sl8	
H
9"

Youez - 2016 - github.com/yon3zu
LinuXploit