o
    ˷eyd                     @   s  d dl Z d dlZd dlmZ d dlmZ d dlmZ ddlm	Z	 ej
dks'J e	s3d dl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mZmZmZmZmZmZmZ d dlmZ d dlmZmZ d dl m!Z! d dl"m#Z# d dl$m%Z%m&Z& d dl'm(Z(m)Z)m*Z*m+Z+m,Z, ddl-m.Z. ddl/m0Z0 g dZ1dZ2dZ3dZ4dZ5G dd de0Z6G dd de6Z7G dd dZ8G dd dZ9ede6d eg df d!ed fd"d#Z:ede6d!ed fd$d%Z;G d&d' d'Z<G d(d) d)e<Z=dS )*    N)abstractmethod)contextmanager)get_event_loop   )SPHINX_AUTODOC_RUNNINGwin32)windll)Arraypointer)DWORDHANDLE)CallableContextManagerDictIterableIteratorListOptionalTextIOrun_in_executor_with_context)create_win32_eventwait_for_handles)KeyPress)Keys)MouseButtonMouseEventType)INPUT_RECORDKEY_EVENT_RECORDMOUSE_EVENT_RECORDSTD_INPUT_HANDLE
EventTypes   )REVERSE_ANSI_SEQUENCES)Input)
Win32InputConsoleInputReaderraw_modecooked_modeattach_win32_inputdetach_win32_input   c                   @   s0   e Zd ZdZdddZeedefddZdS )	_Win32InputBasez;
    Base class for `Win32Input` and `Win32PipeInput`.
    returnNc                 C   s   t  | _d S N)_Win32Handleswin32_handlesself r3   Q/var/www/ideatree/venv/lib/python3.10/site-packages/prompt_toolkit/input/win32.py__init__E   s   z_Win32InputBase.__init__c                 C      d S r.   r3   r1   r3   r3   r4   handleH   s   z_Win32InputBase.handler-   N)	__name__
__module____qualname____doc__r5   propertyr   r   r7   r3   r3   r3   r4   r,   @   s    
r,   c                       s   e Zd ZdZddee ddf fddZdeg df ded fdd	Z	ded fd
dZ
dee fddZdddZedefddZded fddZded fddZdefddZdefddZdddZedefddZ  ZS ) r%   z<
    `Input` class that reads from the Windows console.
    Nstdinr-   c                    s   t    t | _d S r.   )superr5   r&   console_input_reader)r2   r>   	__class__r3   r4   r5   S   s   
zWin32Input.__init__input_ready_callbackc                 C   s
   t | |S )zj
        Return a context manager that makes this input active in the current
        event loop.
        )r)   )r2   rC   r3   r3   r4   attachW      
zWin32Input.attachc                 C   s   t | S )z{
        Return a context manager that makes sure that this input is not active
        in the current event loop.
        )r*   r1   r3   r3   r4   detach^   s   zWin32Input.detachc                 C   s   t | j S r.   )listr@   readr1   r3   r3   r4   	read_keyse      zWin32Input.read_keysc                 C   r6   r.   r3   r1   r3   r3   r4   flushh      zWin32Input.flushc                 C      dS )NFr3   r1   r3   r3   r4   closedk   s   zWin32Input.closedc                 C      t  S r.   )r'   r1   r3   r3   r4   r'   o      zWin32Input.raw_modec                 C   rO   r.   )r(   r1   r3   r3   r4   r(   r   rP   zWin32Input.cooked_modec                 C   s
   t j S r.   )sysr>   filenor1   r3   r3   r4   rR   u   rE   zWin32Input.filenoc                 C   rM   )Nzwin32-inputr3   r1   r3   r3   r4   typeahead_hash|   rL   zWin32Input.typeahead_hashc                 C   s   | j   d S r.   )r@   closer1   r3   r3   r4   rT      rJ   zWin32Input.closec                 C   s   | j jS r.   )r@   r7   r1   r3   r3   r4   r7      s   zWin32Input.handler.   r8   )r9   r:   r;   r<   r   r   r5   r   r   rD   rF   r   r   rI   rK   r=   boolrN   r'   r(   intrR   strrS   rT   r   r7   __classcell__r3   r3   rA   r4   r%   N   s     

r%   c                   @   s  e Zd ZdZi dejdejdejdejdej	dej
dejd	ejd
ejdejdejdejdejdejdejdejdeji dejdejdejdejdejdejdejdejdejdejdej dej!dej"d ej#d!ej$d"ej%Z&i d#ej'd$ej(d%ej)d&ej*d'ej+d(ej,d)ej-d*ej.d+ej/d,ej0d-ej1d.ej2d/ej3d0ej4d1ej5d2ej6d3ej7ej8ej9ej:ej;ej<d4Z=d5Z>d6Z?d7Z@d8ZAd9ZBdWd;eCd<d=fd>d?ZDdXd@dAZEd<eFeG fdBdCZHdDeGd<eGfdEdFZIdGeJdHdId<eKeG fdJdKZLeMdLeNeG d<eKeG fdMdNZOeMdOeNeG d<eCfdPdQZPdReQd<eNeG fdSdTZRdReSd<eNeG fdUdVZTd=S )Yr&   z|
    :param recognize_paste: When True, try to discover paste actions and turn
        the event into a BracketedPaste.
                                      	   
                                                               !   "   #   $   %   &   '   (   -   .   p   q   r   s   t   u   v   )w   x   y   z   {   r   r"         r+   Trecognize_paster-   Nc                 C   s\   d | _ || _|  tj rttjt	| _
d S tdtjtjB | _ tt| j | _
d S )NzCONIN$)_fdconr   rQ   r>   isattyr   r   kernel32GetStdHandler    r7   osopenO_RDWRO_BINARYmsvcrtget_osfhandle)r2   r   r3   r3   r4   r5      s   
zConsoleInputReader.__init__c                 C   s   | j durt| j  dS dS )zClose fdcon.N)r   r   rT   r1   r3   r3   r4   rT      s   
zConsoleInputReader.closec           	   	   #   sN   d}t d}t| }| }t jgddsdS tj jt||t| t 	||} fdd|D }t 
|} jr |rt|}|D ]Q}g }|rt|jtra|jtjtjhv r||j zt|}W n tyx   d}Y nw |rt|jtra|jtjtjhv sa|rttjd|V  |dur|V  qLdS |E dH  dS )z
        Return a list of `KeyPress` instances. It won't return anything when
        there was nothing to read.  (This function doesn't block.)

        http://msdn.microsoft.com/en-us/library/windows/desktop/ms684961(v=vs.85).aspx
        i   r   )timeoutNc                    s   g | ]}  |qS r3   )_insert_key_data).0keyr1   r3   r4   
<listcomp>  s    z+ConsoleInputReader.read.<locals>.<listcomp> )r   r   r   r7   r   r   ReadConsoleInputWr
   rG   	_get_keys_merge_paired_surrogatesr   	_is_pasteiter
isinstancer   r   ControlJControlMappenddatanextStopIterationr   BracketedPastejoin)	r2   	max_countrH   arrtypeinput_recordsall_keysgenkr   r3   r1   r4   rH      sL   

zConsoleInputReader.read	key_pressc                 C   s6   |j r|S t|jtrt|jd}nd}t|j|S )z@
        Insert KeyPress data, for vt100 compatibility.
        r   )r   r   r   r   r#   getr   )r2   r   r   r3   r3   r4   r   %  s   z#ConsoleInputReader._insert_key_datarH   r   zArray[INPUT_RECORD]c                 c   sz    t |jD ]4}|| }|jtv r:t|jt|j }t|tkr,|jr,| 	|E dH  qt|t
kr:| |E dH  qdS )zR
        Generator that yields `KeyPress` objects from the input records.
        N)rangevalue	EventTyper!   getattrEventtyper   KeyDown_event_to_key_pressesr   _handle_mouse)r2   rH   r   iirevr3   r3   r4   r   3  s   
zConsoleInputReader._get_keyskey_pressesc                 c   s    d}| D ]K}t |jt }|od|j  kodkn  }|o+d|j  ko)dkn  }|rH|rC|j|j ddd}t||}n|V  d}|rM|}q|V  q|rX|V  dS dS )zm
        Combines consecutive KeyPresses with high and low surrogates into
        single characters
        Nu   u   u   u   z	utf-16-lesurrogatepass)r   r   r   encodedecoder   )r   buffered_high_surrogater   is_textis_high_surrogateis_low_surrogatefullcharr3   r3   r4   r   K  s*   

z+ConsoleInputReader._merge_paired_surrogateskeysc                 C   sJ   d}d}| D ]}t |jts|d7 }|jtjkr|d7 }q|dko$|dkS )a<  
        Return `True` when we should consider this list of keys as a paste
        event. Pasted text on windows will be turned into a
        `Keys.BracketedPaste` event. (It's not 100% correct, but it is probably
        the best possible way to detect pasting of text and handle that
        correctly.)
        r   r"   )r   r   r   r   )r   
text_countnewline_countr   r3   r3   r4   r   l  s   zConsoleInputReader._is_paster   c                 C   s  t |tkr	|jsJ d}|j}|jj}|dd}|dkr.|j| jv r-t	| j|j d}n|| j
v rF| j
| tjkr=d}t	| j
| |}nt	||}|| j@ sU|| j@ r|| j@ r|rtjtjtjtjtjtjtjtjtjtjtjtjtjtjtjtjtj tj!i	}|"|j#|j#|_#|| j@ s|| j@ r|rtjtj$tjtj%tjtj&tjtj'tjtj(tjtj)tjtj*tj+tj,tjtj-tj tj.i
}|"|j#|j#|_#|| j@ r
|r
tj/tj0tjtj1tjtj2tjtj3tjtj4tjtj5tjtj6tjtj7tj+tj8tjtj9tj tj:i}|"|j#|j#|_#|| j@ s|| j@ r%|r%|j;dkr%t	tj<d}|| j@ s1|| j@ rC|rC|j#tjkrCt	tj=d|gS |rY|| j>@ }|rVt	tj=d|gS |gS g S )zU
        For this `KEY_EVENT_RECORD`, return a list of `KeyPress` instances.
        Nzutf-8r    r   
 )?r   r   r   ControlKeyStateuCharUnicodeCharr   VirtualKeyCodekeycodesr   mappingsr   r   LEFT_CTRL_PRESSEDRIGHT_CTRL_PRESSEDSHIFT_PRESSEDLeftControlShiftLeftRightControlShiftRightUpControlShiftUpDownControlShiftDownHomeControlShiftHomeEndControlShiftEndInsertControlShiftInsertPageUpControlShiftPageUpPageDownControlShiftPageDownr   r   ControlLeftControlRight	ControlUpControlDownControlHome
ControlEndControlInsertDeleteControlDeleteControlPageUpControlPageDownTabBackTab	ShiftLeft
ShiftRightShiftUp	ShiftDown	ShiftHomeShiftEndShiftInsertShiftDeleteShiftPageUpShiftPageDownr   ControlSpaceEscapeLEFT_ALT_PRESSED)r2   r   resultcontrol_key_stateu_char
ascii_charmappingmeta_pressedr3   r3   r4   r     s   

	

z(ConsoleInputReader._event_to_key_pressesc                 C   s   |j }|j}d}tj}|t@ r|dkrtj}ntj}n|tkr#tj	}n|t
kr*tj}|t@ r1tj}|du r@|dkr=tj}ntj}d|j|jt|jjt|jjg}ttj|gS )zK
        Handle mouse events. Return a list of KeyPress instances.
        Nr   ;)
EventFlagsButtonStater   NONEMOUSE_WHEELEDr   	SCROLL_UPSCROLL_DOWNFROM_LEFT_1ST_BUTTON_PRESSEDLEFTRIGHTMOST_BUTTON_PRESSEDRIGHTMOUSE_MOVED
MOUSE_MOVE
MOUSE_DOWNMOUSE_UPr   r   rW   MousePositionXYr   r   WindowsMouseEvent)r2   r   event_flagsbutton_state
event_typebuttonr   r3   r3   r4   r     s4   

z ConsoleInputReader._handle_mouse)Tr8   )Ur9   r:   r;   r<   r   r  r  ControlAControlBControlCControlDControlEControlFControlGControlHControlIr   ControlKControlLr   ControlNControlOControlPControlQControlRControlSControlTControlUControlVControlWControlXControlYControlZControlBackslashControlSquareCloseControlCircumflexControlUnderscore	Backspacer   r   r   r   r   r   r   r   r   r   r   F1F2F3F4F5F6F7F8F9F10F11F12r   r  RIGHT_ALT_PRESSEDr   r   r   rU   r5   rT   r   r   rH   r   r   r   r   staticmethodr   r   r   r   r   r   r   r3   r3   r3   r4   r&      s
   	
 !%	

>
  r&   c                   @   sV   e Zd ZdZdddZdedeg df ddfdd	Zdedeeg df  fd
dZ	dS )r/   a  
    Utility to keep track of which handles are connectod to which callbacks.

    `add_win32_handle` starts a tiny event loop in another thread which waits
    for the Win32 handle to become ready. When this happens, the callback will
    be called in the current asyncio event loop using `call_soon_threadsafe`.

    `remove_win32_handle` will stop this tiny event loop.

    NOTE: We use this technique, so that we don't have to use the
          `ProactorEventLoop` on Windows and we can wait for things like stdin
          in a `SelectorEventLoop`. This is important, because our inputhook
          mechanism (used by IPython), only works with the `SelectorEventLoop`.
    r-   Nc                 C   s   i | _ i | _d S r.   )_handle_callbacks_remove_eventsr1   r3   r3   r4   r5   F  s   
z_Win32Handles.__init__r7   callbackc                    sv   j }|du rtd|  t  | j|< t | j|< d	 fddd	fddtd dS )
z7
        Add a Win32 handle to the event loop.
        NInvalid handle.r-   c                
      s(   z   W t d d S t d w )Nloopr   r3   )rS  rV  waitr3   r4   readya  s   z-_Win32Handles.add_win32_handle.<locals>.readyc                     s2   t  g} | u rtj d S  d S r.   )r   r   r   CloseHandlecall_soon_threadsafe)r	  )r7   rV  rX  remove_eventr3   r4   rW  k  s
   z,_Win32Handles.add_win32_handle.<locals>.waitrU  r8   )r   
ValueErrorremove_win32_handler   rQ  r   rR  r   )r2   r7   rS  handle_valuer3   )rS  r7   rV  rX  r[  rW  r4   add_win32_handleM  s   



z_Win32Handles.add_win32_handlec                 C   sf   |j du rdS z	| j|j }W n	 ty   Y nw tj| z| j|j W S  ty2   Y dS w )zt
        Remove a Win32 handle from the event loop.
        Return either the registered handler or `None`.
        N)r   rR  popKeyErrorr   r   SetEventrQ  )r2   r7   eventr3   r3   r4   r]  x  s   
z!_Win32Handles.remove_win32_handler8   )
r9   r:   r;   r<   r5   r   r   r_  r   r]  r3   r3   r3   r4   r/   6  s
    
"+r/   inputrS  r-   c              
   c   s    | j }| j}|jdu rtd||}||| zdV  W || |r/||| dS dS || |r?||| w w )z
    Context manager that makes this input active in the current event loop.

    :param input: :class:`~prompt_toolkit.input.Input` object.
    :param input_ready_callback: Called when the input is ready to read.
    NrT  r0   r7   r   r\  r]  r_  )rd  rS  r0   r7   previous_callbackr3   r3   r4   r)     s"   




r)   c              
   c   s`    | j }| j}|jd u rtd||}zd V  W |r$||| d S d S |r/||| w w )NrT  re  )rd  r0   r7   rf  r3   r3   r4   r*     s   

r*   c                   @   sN   e Zd ZdZddee ddfddZdddZdd	d
Zde	ddfddZ
dS )r'   z
    ::

        with raw_mode(stdin):
            ''' the windows terminal is now in 'raw' mode. '''

    The ``fileno`` attribute is ignored. This is to be compatible with the
    `raw_input` method of `.vt100_input`.
    NrR   r-   c                 C   s   t tjt| _d S r.   )r   r   r   r   r    r7   )r2   rR   r3   r3   r4   r5     s   zraw_mode.__init__c                 C   s,   t  }tj| jt| || _|   d S r.   )r   r   r   GetConsoleModer7   r
   original_mode_patch)r2   rh  r3   r3   r4   	__enter__  s   zraw_mode.__enter__c                 C   s2   d}d}d}t j| j| jj||B |B  @  d S Nr+   r   r"   r   r   SetConsoleModer7   rh  r   r2   ENABLE_ECHO_INPUTENABLE_LINE_INPUTENABLE_PROCESSED_INPUTr3   r3   r4   ri    s   zraw_mode._patchac                 G   s   t j| j| j d S r.   )r   r   rm  r7   rh  )r2   rr  r3   r3   r4   __exit__  s   zraw_mode.__exit__r.   r8   )r9   r:   r;   r<   r   rV   r5   rj  ri  objectrs  r3   r3   r3   r4   r'     s    


r'   c                   @   s   e Zd ZdZdddZdS )r(   zx
    ::

        with cooked_mode(stdin):
            ''' The pseudo-terminal stdin is now used in cooked mode. '''
    r-   Nc                 C   s0   d}d}d}t j| j| jj||B |B B  d S rk  rl  rn  r3   r3   r4   ri    s   
zcooked_mode._patchr8   )r9   r:   r;   r<   ri  r3   r3   r3   r4   r(     s    r(   )>r   rQ   abcr   
contextlibr   prompt_toolkit.eventloopr   utilsr   platformr   ctypesr   r	   r
   ctypes.wintypesr   r   typingr   r   r   r   r   r   r   r   r   prompt_toolkit.eventloop.win32r   r   (prompt_toolkit.key_binding.key_processorr   prompt_toolkit.keysr   prompt_toolkit.mouse_eventsr   r   prompt_toolkit.win32_typesr   r   r   r    r!   ansi_escape_sequencesr#   baser$   __all__r  r  r  r  r,   r%   r&   r/   r)   r*   r'   r(   r3   r3   r3   r4   <module>   sZ    (9   2X
'