
    fLd                       d dl mZ 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s
d 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 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Z5 G d de0      Z6 G d de6      Z7 G d d      Z8 G d d      Z9e		 	 	 	 	 	 d&d        Z:e	d'd!       Z; G d" d#      Z< G d$ d%e<      Z=y)(    )annotationsN)abstractmethod)get_running_loop)contextmanager   )SPHINX_AUTODOC_RUNNINGwin32)windll)Arraypointer)DWORDHANDLE)CallableContextManagerIterableIterator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                  4    e Zd ZdZddZeedd              Zy)_Win32InputBasez;
    Base class for `Win32Input` and `Win32PipeInput`.
    c                "    t               | _        y N)_Win32Handleswin32_handlesselfs    U/var/www/cvtools/html/venv/lib/python3.12/site-packages/prompt_toolkit/input/win32.py__init__z_Win32InputBase.__init__=   s    *_    c                     y r.    r1   s    r3   handlez_Win32InputBase.handle@   s     	r5   NreturnNoner:   r   )__name__
__module____qualname____doc__r4   propertyr   r8   r7   r5   r3   r,   r,   8   s(    -   r5   r,   c                       e Zd ZdZdd fdZddZddZddZddZe	dd       Z
ddZdd	Zdd
ZddZddZe	dd       Z xZS )r$   z<
    `Input` class that reads from the Windows console.
    c                @    t         |           t               | _        y r.   )superr4   r%   console_input_reader)r2   stdin	__class__s     r3   r4   zWin32Input.__init__K   s    $6$8!r5   c                    t        | |      S )zj
        Return a context manager that makes this input active in the current
        event loop.
        )r(   )r2   input_ready_callbacks     r3   attachzWin32Input.attachO   s    
 "$(<==r5   c                    t        |       S )z{
        Return a context manager that makes sure that this input is not active
        in the current event loop.
        )r)   r1   s    r3   detachzWin32Input.detachV   s    
 "$''r5   c                H    t        | j                  j                               S r.   )listrE   readr1   s    r3   	read_keyszWin32Input.read_keys]   s    D--22455r5   c                     y r.   r7   r1   s    r3   flushzWin32Input.flush`   s    r5   c                     y)NFr7   r1   s    r3   closedzWin32Input.closedc   s    r5   c                    t               S r.   )r&   r1   s    r3   r&   zWin32Input.raw_modeg   s
    zr5   c                    t               S r.   )r'   r1   s    r3   r'   zWin32Input.cooked_modej   s
    }r5   c                >    t         j                  j                         S r.   )sysrF   filenor1   s    r3   rY   zWin32Input.filenom   s    
 yy!!r5   c                     y)Nzwin32-inputr7   r1   s    r3   typeahead_hashzWin32Input.typeahead_hasht   s    r5   c                8    | j                   j                          y r.   )rE   closer1   s    r3   r]   zWin32Input.closew   s    !!'')r5   c                .    | j                   j                  S r.   )rE   r8   r1   s    r3   r8   zWin32Input.handlez   s    ((///r5   r.   )rF   zTextIO | Noner:   r;   )rI   Callable[[], None]r:   ContextManager[None])r:   r`   )r:   list[KeyPress]r9   )r:   bool)r:   int)r:   strr<   )r=   r>   r?   r@   r4   rJ   rL   rP   rR   rA   rT   r&   r'   rY   r[   r]   r8   __classcell__)rG   s   @r3   r$   r$   F   sb    9>(6  "* 0 0r5   r$   c                  "   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j0                  dej2                  dej4                  dej6                  dej8                  dej:                  dej<                  dej>                  dej@                  dejB                  dejD                  d ejF                  d!ejH                  d"ejJ                  Z&i d#ejN                  d$ejP                  d%ejR                  d&ejT                  d'ejV                  d(ejX                  d)ejZ                  d*ej\                  d+ej^                  d,ej`                  d-ejb                  d.ejd                  d/ejf                  d0ejh                  d1ejj                  d2ejl                  d3ejn                  ejp                  ejr                  ejt                  ejv                  ejx                  d4Z=d5Z>d6Z?d7Z@d8ZAd9ZBdDdEd:ZCdFd;ZDdGd<ZEdHd=ZF	 	 	 	 	 	 dId>ZGeHdJd?       ZIeHdKd@       ZJdLdAZKdMdBZLyC)Nr%   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*   c                   d | _         || _        |  t        j                  j	                         r2t        t        j                  j                  t                    | _
        y t        j                  dt        j                  t        j                  z        | _         t        t        j                   | j                               | _
        y )NzCONIN$)_fdconrecognize_pasterX   rF   isattyr   r
   kernel32GetStdHandler   r8   osopenO_RDWRO_BINARYmsvcrtget_osfhandle)r2   r   s     r3   r4   zConsoleInputReader.__init__   s|    . 	99 !=!=>N!OPDK''(BII,CDDK !5!5dkk!BCDKr5   c                \    | j                    t        j                  | j                          yy)zClose fdcon.N)r   r   r]   r1   s    r3   r]   zConsoleInputReader.close   s!    ;;"HHT[[! #r5   c              #     K   d}t        d      }t        |z  } |       }t        | j                  gd      syt        j
                  j                  | j                  t        |      |t        |             t        | j                  ||            }|D cg c]  }| j                  |       }}t        | j                  |            }| j                  r| j                  |      rt        |      }|D ]  }g }	|rt        |j                   t"              r,|j                   t"        j$                  t"        j&                  hv rq|	j)                  |j*                         	 t-        |      }|rHt        |j                   t"              sD|j                   t"        j$                  t"        j&                  hv rq|	r+t1        t"        j2                  dj5                  |	             ||  y|E d{    yc c}w # t.        $ r d}Y w xY w7 w)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   )timeoutN )r   r   r   r8   r
   r   ReadConsoleInputWr   rN   	_get_keys_insert_key_data_merge_paired_surrogatesr   	_is_pasteiter
isinstancekeyr   ControlJControlMappenddatanextStopIterationr   BracketedPastejoin)
r2   	max_countrO   arrtypeinput_recordsall_keysr   genkr   s
             r3   rO   zConsoleInputReader.read   s     	Qx*	  q9 	))KK/GDM	
 t];< ;CC3D))#.CC 55h?@DNN8$<x.C   "155$/uu >>KK'! I "155$/uu >> "4#6#6FF=G#&  9 D( ) ! !  sU   BHG6.B0HG;*H,H4/H$H0H1
H;H	HH		Hc                    |j                   r|S t        |j                  t              r!t	        j
                  |j                  d      }nd}t        |j                  |      S )z@
        Insert KeyPress data, for vt100 compatibility.
        r   )r   r   r   r   r"   getr   )r2   	key_pressr   s      r3   r   z#ConsoleInputReader._insert_key_data  sK     >>immT*)--immR@DD	t,,r5   c              #    K   t        |j                        D ]  }||   }|j                  t        v st	        |j
                  t        |j                           }t        |t              r&|j                  r| j                  |      E d{    xt        |t              s| j                  |      E d{     y7 27 	w)zR
        Generator that yields `KeyPress` objects from the input records.
        N)rangevalue	EventTyper    getattrEventr   r   KeyDown_event_to_key_pressesr   _handle_mouse)r2   rO   r   iirevs         r3   r   zConsoleInputReader._get_keys+  s      tzz" 	6Aq!B ||z)RXXz",,'?@ b"23

#99"===$67#11"555!	6 > 6s/   0CAC
B=C!C5B?6C?Cc              #    K   d}| D ]  }t        |j                  t               }|xr d|j                  cxk  xr dk  nc }|xr d|j                  cxk  xr dk  nc }|rM|rE|j                  |j                  z   j                  dd      j	                  d      }t        ||      }n| d}|r|}|  |r| yyw)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   )key_pressesbuffered_high_surrogater   is_textis_high_surrogateis_low_surrogatefullchars          r3   r   z+ConsoleInputReader._merge_paired_surrogatesC  s      #' 	C$SWWd33G ' KH,K8,K&J8sww+J(+J&# 144sww>_=, 
 #8X6C11*.' *-'	+	. #)) #s   CCc                    d}d}| D ]D  }t        |j                  t              s|dz  }|j                  t        j                  k(  s@|dz  }F |dk\  xr |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   )keys
text_countnewline_countr   s       r3   r   zConsoleInputReader._is_pasted  sd     
 	#AaeeT*a
uu%"		# !5jAo5r5   c                h   t        |t              r|j                  sJ d}|j                  }|j                  j
                  }|j                  dd      }|dk(  r<|j                  | j                  v rzt        | j                  |j                     d      }nV|| j                  v r<| j                  |   t        j                  k(  rd}t        | j                  |   |      }nt        ||      }|| j                  z  s|| j                  z  rN|| j                  z  r>|r;t        j                   t        j"                  t        j$                  t        j&                  t        j(                  t        j*                  t        j,                  t        j.                  t        j0                  t        j2                  t        j4                  t        j6                  t        j8                  t        j:                  t        j<                  t        j>                  t        j@                  t        jB                  i	}|jE                  |jF                  |jF                        |_#        || j                  z  s|| j                  z  r\|rYt        j                   t        jH                  t        j$                  t        jJ                  t        j(                  t        jL                  t        j,                  t        jN                  t        j0                  t        jP                  t        j4                  t        jR                  t        j8                  t        jT                  t        jV                  t        jX                  t        j<                  t        jZ                  t        j@                  t        j\                  i
}|jE                  |jF                  |jF                        |_#        || j                  z  rz|rwt        j^                  t        j`                  t        j                   t        jb                  t        j$                  t        jd                  t        j(                  t        jf                  t        j,                  t        jh                  t        j0                  t        jj                  t        j4                  t        jl                  t        j8                  t        jn                  t        jV                  t        jp                  t        j<                  t        jr                  t        j@                  t        jt                  i}|jE                  |jF                  |jF                        |_#        || j                  z  s|| j                  z  r+|r)|jv                  dk(  rt        t        jx                  d      }|| j                  z  s|| j                  z  r;|r9|jF                  t        j                  k(  rt        t        jz                  d      |gS |r0|| j|                  z  }|rt        t        jz                  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_presseds           r3   r   z(ConsoleInputReader._event_to_key_pressesz  s    "./BJJ>>"&..%%]]7O<
 V  DMM1!$--0A0A"BBGT]]*==,=  "$--
";VD!&&1
 "D$:$::$t'>'>>!D$6$66 		400

D22,,		400		400$..T44T44t88
'G !VZZ<FJ  6 66 4#:#::		4++

D--		4++		4++$//T//T//T//t33G !VZZ<FJ t111f$,,		4>>

DOO		4>>		4>>$--T--T--T--t11G !VZZ<FJ
 "D$:$::$t'>'>>s"d//5F "D$:$::$t'>'>>

dmm+T[["-v66 ,t/D/DDL b16::x Ir5   c                   |j                   }|j                  }d}t        j                  }|t        z  r'|dkD  rt
        j                  }nDt
        j                  }n3|t        k(  rt        j                  }n|t        k(  rt        j                  }|t        z  rt
        j                  }|&|dkD  rt
        j                  }nt
        j                  }dj!                  |j"                  |j"                  t%        |j&                  j(                        t%        |j&                  j*                        g      }t-        t.        j0                  |      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   rd   MousePositionXYr   r   WindowsMouseEvent)r2   r   event_flagsbutton_state
event_typebuttonr   s          r3   r   z ConsoleInputReader._handle_mouse  s    mm~~,0
).. &a+55
+77
 ;;$))!99$** $'22J a+66
 ,44
xx  B$$&&'B$$&&'	
 //677r5   N)T)r   rb   r:   r;   r9   )r:   zIterable[KeyPress])r   r   r:   r   )rO   r   r   zArray[INPUT_RECORD]r:   Iterator[KeyPress])r   ra   r:   r:  )r   ra   r:   rb   )r   r   r:   ra   )r   r   r:   ra   )Mr=   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   r4   r]   rO   r   r   staticmethodr   r   r   r   r7   r5   r3   r%   r%      s   """"" 	" 		"
 	" 	" 	" 	" 	" 	" 	" 	" 	" 	" 	"  	!"" 	#"$ 	%"& 	'"( 	)"* 	+", 	-". 	/"0 	1"2 	3"4 	5"6 	7"8 	9": 	&&;"< 	((="> 	''?"@ 	''A"B 	C"HJ
DKK 	DMM 	DHH	
 	DII 	DII 	DGG 	DJJ 	DII 	DKK 	DKK 	TWW 	TWW  	TWW!" 	TWW#$ 	TWW%& 	TWW'( 	TWW)* WWWWXXXXXX3H8 MD"
< |-66*=6	60 * *@ 6 6*BH-8r5   r%   c                  (    e Zd ZdZddZddZddZy)	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`.
    c                     i | _         i | _        y r.   )_handle_callbacks_remove_eventsr1   s    r3   r4   z_Win32Handles.__init__>  s    @B 24r5   c                   j                   }|t        d      | j                         t               | j                  |<   t               | j                  |<   dfddfdt               y)z7
        Add a Win32 handle to the event loop.
        NInvalid handle.c                 T    	           t               y # t               w xY w)Nloopr   )callbackrn  waits   r3   readyz-_Win32Handles.add_win32_handle.<locals>.readyY  s#    >
,T=,T=s    'c                     t        g      } | u r t        j                  j                         y j	                         y r.   )r   r
   r   CloseHandlecall_soon_threadsafe)r  r8   rn  rq  remove_events    r3   rp  z,_Win32Handles.add_win32_handle.<locals>.waitc  s?     &|V&<=F%++L9))%0r5   rm  r9   )r   
ValueErrorremove_win32_handler   rh  r   ri  r   )r2   r8   ro  handle_valuern  rq  ru  rp  s    `` @@@@r3   add_win32_handlez_Win32Handles.add_win32_handleE  s}     ||.// 	  (!/7|, *+,8L)	>		1 		1 	%T5r5   c                .   |j                   y	 | j                  j                  |j                         }t        j                  j                  |       	 | j                  j                  |j                         S # t        $ r Y 1w xY w# t        $ r Y yw xY w)zt
        Remove a Win32 handle from the event loop.
        Return either the registered handler or `None`.
        N)r   ri  popr
   r   SetEventKeyErrorrh  )r2   r8   events      r3   rw  z!_Win32Handles.remove_win32_handlep  s    
 <<	,''++FLL9E OO$$U+	))--fll;;  		  		s#   %A9 $B 9	BB	BBNr9   )r8   r   ro  r_   r:   r;   )r8   r   r:   zCallable[[], None] | None)r=   r>   r?   r@   r4   ry  rw  r7   r5   r3   r/   r/   .  s    4)6Vr5   r/   c              #  \  K   | j                   }| j                  }|j                  t        d      |j	                  |      }|j                  ||       	 d |j	                  |       |r|j                  ||       yy# |j	                  |       |r|j                  ||       w w xY 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.
    Nrk  r0   r8   r   rv  rw  ry  )inputro  r0   r8   previous_callbacks        r3   r(   r(     s      ''M\\F||*++ &99&A""684F))&1**63DE  	))&1**63DE s   AB,B 'B,(B))B,c              #     K   | j                   }| j                  }|j                  t        d      |j	                  |      }	 d  |r|j                  ||       y y # |r|j                  ||       w w xY ww)Nrk  r  )r  r0   r8   r  s       r3   r)   r)     s}     ''M\\F||*++%99&AF**63DE **63DE s   AA8A A8A55A8c                  2    e Zd ZdZdddZd	dZd	dZd
dZy)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`.
    Nc                f    t        t        j                  j                  t                    | _        y r.   )r   r
   r   r   r   r8   )r2   rY   s     r3   r4   zraw_mode.__init__  s    V__99:JKLr5   c                    t               }t        j                  j                  | j                  t        |             || _        | j                          y r.   )r   r
   r   GetConsoleModer8   r   original_mode_patch)r2   r  s     r3   	__enter__zraw_mode.__enter__  s7    &&t{{GM4JK*r5   c                    d}d}d}t         j                  j                  | j                  | j                  j
                  ||z  |z   z         y Nr*   r   r!   r
   r   SetConsoleModer8   r  r   r2   ENABLE_ECHO_INPUTENABLE_LINE_INPUTENABLE_PROCESSED_INPUTs       r3   r  zraw_mode._patch  sT    ""!'&&KK$$!$558NNOP	
r5   c                l    t         j                  j                  | j                  | j                         y r.   )r
   r   r  r8   r  )r2   as     r3   __exit__zraw_mode.__exit__  s     &&t{{D4F4FGr5   r.   )rY   z
int | Noner:   r;   r9   )r  objectr:   r;   )r=   r>   r?   r@   r4   r  r  r  r7   r5   r3   r&   r&     s    M

Hr5   r&   c                      e Zd ZdZddZy)r'   zx
    ::

        with cooked_mode(stdin):
            ''' The pseudo-terminal stdin is now used in cooked mode. '''
    c                    d}d}d}t         j                  j                  | j                  | j                  j
                  ||z  |z  z         y r  r  r  s       r3   r  zcooked_mode._patch  sQ    ""!'&&KK$$ #447MMO	
r5   Nr9   )r=   r>   r?   r@   r  r7   r5   r3   r'   r'     s    

r5   r'   )r  r,   ro  r_   r:   Iterator[None])r  r,   r:   r  )>
__future__r   r   rX   abcr   asyncior   
contextlibr   utilsr   platformr   ctypesr
   r   r   ctypes.wintypesr   r   typingr   r   r   r   r   prompt_toolkit.eventloopr   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'   r7   r5   r3   <module>r     s   " 	 
  $ % *
||w   ! ) G G A O = $ C  :   #  e 60 60rl8 l8^U Up FF&8FF F8 F F $H $HN
( 
r5   