i^dZddlZddlZddlZddlZddlZddlmZmZddl m Z Gdde Z GddejZGd d e ZGd d eZy) z This module contains the base implementation. The actual interface to keyboard classes is defined here, but the implementation is located in a platform dependent module. N)AbstractListenerprefix)_loggercjeZdZdZgZd dZdZdZdZdZ dZ e d Z e d Z e d Zy) KeyCodezg A :class:`KeyCode` represents the description of a key code used by the operating system. Nc ||_|tj|nd|_||_|jr^ t j dt j|jz|_|jr|jst|d|_|jD]}t|||j|d!|r t|y#t$rd|_d|_YwxYw)Nz COMBINING F)vksix text_typecharis_dead unicodedatalookupname combiningKeyError_PLATFORM_EXTENSIONSsetattrpop ValueError)selfr r r kwargskeys _/home/obispo/Crisostomo_bridge/mision_env/lib/python3.12/site-packages/pynput/keyboard/_base.py__init__zKeyCode.__init__.s+/+;CMM$'  << &!,!3!3 ;#3#3DII#>>"@ ||DNNtn$!DN,, 6C D#vzz#t4 5 6 V$ $  &$ !% &s:CC43C4c|jrdt|jzS|jt|jSd|jzS)Nz[%s]z<%d>)r reprr r rs r__repr__zKeyCode.__repr__EsC <<DO+ + 99  ? "DGG# #ct|SN)rrs r__str__zKeyCode.__str__Ms Dzr c@tjsyj@j4jjk(xrjjk(Sjjk(xrt fdj DS)NFc3PK|]}t|t|k(ywr")getattr).0fotherrs r z!KeyCode.__eq__..Vs,/4a GE1$55/4s#&) isinstance __class__r r r allr)rr)s``r__eq__zKeyCode.__eq__Ps%0 99 UZZ%;99 *Lt||u}}/L L77ehh&43/422/4,4 4r c*tt|Sr")hashrrs r__hash__zKeyCode.__hash__ZsDJr c<|js t||jdk(s||k(r|j|jS|j@t j d|j|j z}|r|j|St|)aApplies this dead key to another key and returns the result. Joining a dead key with space (``' '``) or itself yields the non-dead version of this key, if one exists; for example, ``KeyCode.from_dead('~').join(KeyCode.from_char(' '))`` equals ``KeyCode.from_char('~')`` and ``KeyCode.from_dead('~').join(KeyCode.from_dead('~'))``. :param KeyCode key: The key to join with this key. :return: a key code :raises ValueError: if the keys cannot be joined  NFC)r rr from_charr normalizer)rrcombineds rjoinz KeyCode.join]s ||T" " 88s?dck>>$)), , 88 ",,4>>)+H~~h//or c |dd|i|S)zCreates a key from a virtual key code. :param vk: The virtual key code. :param kwargs: Any other parameters to pass. :return: a key code r r:)clsr rs rfrom_vkzKeyCode.from_vks#b#F##r c |dd|i|S)znCreates a key from a character. :param str char: The character. :return: a key code r r:r:r;r rs rr5zKeyCode.from_chars''''r c |d|dd|S)zCreates a dead key. :param char: The dead key. This should be the unicode character representing the stand alone character, such as ``'~'`` for *COMBINING TILDE*. :return: a key code T)r r r:r:r>s r from_deadzKeyCode.from_deads5d5f55r NNF)__name__ __module__ __qualname____doc__rrrr#r.r1r8 classmethodr<r5r@r:r rrr&sj %.$4  D $ $(( 6 6r rceZdZdZej dZej dZej dZej dZ ej dZ ej dZ ej dZ ej dZ ej dZej dZej dZej dZej dZej dZej dZej dZej dZej dZej dZej dZej dZej dZej dZej dZej dZej dZej dZ ej dZ!ej dZ"ej dZ#ej dZ$ej dZ%ej dZ&ej dZ'ej dZ(ej dZ)ej dZ*ej dZ+ej dZ,ej dZ-ej dZ.ej dZ/ej dZ0ej dZ1ej dZ2ej dZ3ej dZ4ej dZ5ej dZ6ej dZ7ej dZ8ej dZ9ej dZ:ej dZ;ej dZej dZ?ej dZ@ej dZAy)Keya(A class representing various buttons that may not correspond to letters. This includes modifier keys and function keys. The actual values for these items differ between platforms. Some platforms may have additional buttons, but these are guaranteed to be present everywhere. rN)BrBrCrDrErr<altalt_lalt_ralt_gr backspace caps_lockcmdcmd_lcmd_rctrlctrl_lctrl_rdeletedownendenterescf1f2f3f4f5f6f7f8f9f10f11f12f13f14f15f16f17f18f19f20homeleft page_downpage_uprightshiftshift_lshift_rspacetabupmedia_play_pausemedia_volume_mutemedia_volume_downmedia_volume_upmedia_previous media_nextinsertmenunum_lockpause print_screen scroll_lockr:r rrHrHs //! C OOA E OOA E__Q F"I"I //! C OOA E OOA E ??1 D__Q F__Q F__Q F ??1 D //! C OOA E //! C  B  B  B  B  B  B  B  B  B //! C //! C //! C //! C //! C //! C //! C //! C //! C //! C //! C ??1 D ??1 D"Iooa G OOA E OOA Eooa Gooa G OOA E //! C  Bq) * *ooa(O__Q'N#J__Q F ??1 Dq!H OOA E??1%L//!$Kr rHceZdZdZeZeZGddeZ GddeZ dZ dZ dZ d Zd Zej"d Zd Zeej"d ZedZedZedZedZdZdZdZdZy) ControllerzDA controller for sending virtual keyboard events to the system. ceZdZdZy)Controller.InvalidKeyExceptionzThe exception raised when an invalid ``key`` parameter is passed to either :meth:`Controller.press` or :meth:`Controller.release`. Its first argument is the ``key`` parameter. NrBrCrDrEr:r rInvalidKeyExceptionrHs  r rceZdZdZy)$Controller.InvalidCharacterExceptionzThe exception raised when an invalid character is encountered in the string passed to :meth:`Controller.type`. Its first argument is the index of the character in the string, and the second the character. Nrr:r rInvalidCharacterExceptionrPs  r rct|j|_tj|_t |_d|_d|_ y)NF) rr,_log threadingRLock_modifiers_lockset _modifiers _caps_lock _dead_keyrs rrzController.__init__Ys8DNN+ (0%r c|j|}||j||j|d||jjj k(r|j |_|}|jr |jj|}|jr||_y |j|dd|_y#t$r;|j|jd|j|jdYrwxYw#|j$rY||k7rJ|j|jd|j|jd|j|dYd|_ywxYw)aPresses a key. A key may be either a string of length 1, one of the :class:`Key` members or a :class:`KeyCode`. Strings will be transformed to :class:`KeyCode` using :meth:`KeyCode.char`. Members of :class:`Key` will be translated to their :meth:`~Key.value`. :param key: The key to press. :raises InvalidKeyException: if the key is invalid :raises ValueError: if ``key`` is a string, but its length is not ``1`` NTF) _resolver_update_modifiers_KeyrNvaluerrr8r_handler )rrresolvedoriginals rpresszController.press`sF ==%  **3/ / x. tyy**00 0"&//1DO >> 4>>..x8   %DN  - LL4 (# 4 T^^T2 T^^U3 4'' -8# T^^T2 T^^U3 Xt,  -s&;C+D AD D  AE43E4c|j|}||j||j|d|jry|j |dy)aRReleases a key. A key may be either a string of length 1, one of the :class:`Key` members or a :class:`KeyCode`. Strings will be transformed to :class:`KeyCode` using :meth:`KeyCode.char`. Members of :class:`Key` will be translated to their :meth:`~Key.value`. :param key: The key to release. If this is a string, it is passed to :meth:`touches` and the returned releases are used. :raises InvalidKeyException: if the key is invalid :raises ValueError: if ``key`` is a string, but its length is not ``1`` NF)rrrr r)rrrs rreleasezController.releasesU"==%  **3/ / x/     Xu%r cH|j||j|y)aSPresses and releases a key. This is equivalent to the following code:: controller.press(key) controller.release(key) :param key: The key to press. :raises InvalidKeyException: if the key is invalid :raises ValueError: if ``key`` is a string, but its length is not ``1`` Nrrrrs rtapzController.taps 3 Sr cN|r|j|y|j|y)a Calls either :meth:`press` or :meth:`release` depending on the value of ``is_press``. :param key: The key to press or release. :param bool is_press: Whether to press the key. :raises InvalidKeyException: if the key is invalid Nrrris_presss rtouchzController.touchs  JJsO LL r c'K|D]}|j| dt|D]}|j|y#t|D]}|j|wxYww)zaExecutes a block with some keys pressed. :param keys: The keys to keep pressed. N)rreversedr)rargsrs rpressedzController.pressedsh  C JJsO  " ~ " S! "x~ " S! "sA(A"A(#A%%A(cddlm}t|D]:\}}|j||} |j ||j |<y#t |jf$r|j||wxYw)aTypes a string. This method will send all key presses and releases necessary to type all characters in the string. :param str string: The string to type. :raises InvalidCharacterException: if an untypable character is encountered )_CONTROL_CODESN) r enumerategetrrrrr)rstringri characterrs rtypezController.types %%f- CLAy $$Y :C C 3 S!  C  8 89 C44Q BB Cs "A(A8c#Kj5tfdjDdddy#1swYyxYww)aThe currently pressed modifier keys. Please note that this reflects only the internal state of this controller, and not the state of the operating system keyboard buffer. This property cannot be used to determine whether a key is physically pressed. Only the generic modifiers will be set; when pressing either :attr:`Key.shift_l`, :attr:`Key.shift_r` or :attr:`Key.shift`, only :attr:`Key.shift` will be present. Use this property within a context block thus:: with controller.modifiers as modifiers: with_block() This ensures that the modifiers cannot be modified by another thread. c3@K|]}j|ywr") _as_modifier)r'modifierrs rr*z'Controller.modifiers..s$1!!(+1sN)rrrrs`r modifierszController.modifierssD* ! ! 11 $11 1 1 1 1s A!: AAAcv|j5}|jj|vcdddS#1swYyxYw)zWhether any *alt* key is pressed. Please note that this reflects only the internal state of this controller. See :attr:`modifiers` for more information. N)rrrIrrs r alt_pressedzController.alt_pressed s2^^ .y99==I- . . ./8cv|j5}|jj|vcdddS#1swYyxYw)zWhether *altgr* is pressed. Please note that this reflects only the internal state of this controller. See :attr:`modifiers` for more information. N)rrrLrs ralt_gr_pressedzController.alt_gr_presseds4^^ 1y99##y0 1 1 1rcv|j5}|jj|vcdddS#1swYyxYw)zWhether any *ctrl* key is pressed. Please note that this reflects only the internal state of this controller. See :attr:`modifiers` for more information. N)rrrRrs r ctrl_pressedzController.ctrl_presseds2^^ /y99>>Y. / / /rc|jry|j5}|jj|vcdddS#1swYyxYw)zWhether any *shift* key is pressed, or *caps lock* is toggled. Please note that this reflects only the internal state of this controller. See :attr:`modifiers` for more information. TN)rrrrsrs r shift_pressedzController.shift_pressed)s< ?? ^^ 0y99??i/ 0 0 0s <Ac|d|jDvr |jSt|tjr4t |dk7r t ||jj|St||jrO|jA|jr5|j|j|jjS|Sy)aResolves a key to a :class:`KeyCode` instance. This method will convert any key representing a character to uppercase if a shift modifier is active. :param key: The key to resolve. :return: a key code, or ``None`` if it cannot be resolved c3 K|]}|ywr"r:)r'ks rr*z&Controller._resolve..As(1(s rN)r r ) rrr+r string_typeslenr_KeyCoder5r rr upperrs rrzController._resolve6s (dii( (99  c3++ ,3x1} o%==**3/ / c4== )xx#(:(:}}SXX^^5E}FF *r c|j|rP|j5|r|jj|n |jj |dddyy#t $rYwxYw#1swYyxYw)zUpdates the current modifier list. If ``key`` is not a modifier, no action is taken. :param key: The key being pressed or released. N)rrraddremoverrs rrzController._update_modifiersQsz   S !%% OO'',..s3    "$   s(A2A## A/,A2.A//A22A;c2ddlm}|j|dS)afReturns a key as the modifier used internally if defined. This method will convert values like :attr:`Key.alt_r.value` and :attr:`Key.shift_l.value` to :attr:`Key.alt` and :attr:`Key.shift`. :param key: The possible modifier key. :return: the base modifier key, or ``None`` if ``key`` is not a modifier r)_NORMAL_MODIFIERSN)rrr)rrrs rrzController._as_modifiercs ( $$S$//r ct)zThe platform implementation of the actual emitting of keyboard events. This is a platform dependent implementation. :param Key key: The key to handle. :param bool is_press: Whether this is a key press event. )NotImplementedErrorrs rrzController._handleqs "##r N)rBrCrDrErrrHr Exceptionrrrrrrr contextlibcontextmanagerrrpropertyrrrrrrrrrr:r rrr?sH D i  I /b&8"  " "C*110..11// 0 06$ 0 $r rc*eZdZdZdfd ZdZxZS)Listenera A listener for keyboard events. Instances of this class can be used as context managers. This is equivalent to the following code:: listener.start() try: listener.wait() with_statements() finally: listener.stop() This class inherits from :class:`threading.Thread` and supports all its methods. It will set :attr:`daemon` to ``True`` when created. All callback arguments are optional; a callback may take less arguments than actually passed, but not more, unless they are optional. :param callable on_press: The callback to call when a button is pressed. It will be called with the arguments ``(key, injected)``, where ``key`` is a :class:`KeyCode`, a :class:`Key` or ``None`` if the key is unknown, and ``injected`` whether the event was injected and thus not generated by an actual input device. Please note that not all backends support ``injected`` and will always set it to ``False``. :param callable on_release: The callback to call when a button is released. It will be called with the arguments ``(key, injected)``, where ``key`` is a :class:`KeyCode`, a :class:`Key` or ``None`` if the key is unknown, and ``injected`` whether the event was injected and thus not generated by an actual input device. Please note that not all backends support ``injected`` and will always set it to ``False``. :param bool suppress: Whether to suppress events. Setting this to ``True`` will prevent the input events from being passed to the rest of the system. :param kwargs: Any non-standard platform dependent options. These should be prefixed with the platform name thus: ``darwin_``, ``uinput_``, ``xorg_`` or ``win32_``. Supported values are: ``darwin_intercept`` A callable taking the arguments ``(event_type, event)``, where ``event_type`` is ``Quartz.kCGEventKeyDown`` or ``Quartz.kCGEventKeyUp``, and ``event`` is a ``CGEventRef``. This callable can freely modify the event using functions like ``Quartz.CGEventSetIntegerValueField``. If this callable does not return the event, the event is suppressed system wide. ``uinput_device_paths`` A list of device paths. If this is specified, *pynput* will limit the number of devices checked for the capabilities needed to those passed, otherwise all system devices will be used. Passing this might be required if an incorrect device is chosen. ``win32_event_filter`` A callable taking the arguments ``(msg, data)``, where ``msg`` is the current message, and ``data`` associated data as a `KBDLLHOOKSTRUCT `_. If this callback returns ``False``, the event will not be propagated to the listener callback. If ``self.suppress_event()`` is called, the event is suppressed system wide. c rt|j|_tt|j}|j Dcic]%\}}|j |r|t|d|'c}}|_tt|+|j|d|j|d|ycc}}w)N)on_press on_releasesuppress) rr,rrritems startswithr_optionssuperr_wrap) rrrrr option_prefixrrr,s rrzListener.__init__sDNN+ x8 %lln.U~~m, M"# $e +.  h&ZZ!,zz*a0 '  .s *B3c|ddlm}m}m}t ||r5|j )|j |j jSt ||r|j|vr||jSt ||r;|jj%|j|jjS|S)aPerforms normalisation of a key. This method attempts to convert key events to their canonical form, so that events will equal regardless of modifier state. This method will convert upper case keys to lower case keys, convert any modifiers with a right and left version to the same value, and may slow perform additional platform dependent normalisation. :param key: The key to normalise. :type key: Key or KeyCode :return: a key :rtype: Key or KeyCode r)rHrr) pynput.keyboardrHrrr+r r5lowerrr r<)rrrHrrs r canonicalzListener.canonicals DC c7 #(<$$SXX^^%56 6 S !cii3D&D$SYY/ / S !ciill&>??399<<0 0Jr rA)rBrCrDrErr __classcell__)r,s@rrrsKX r r)rErenumrrr pynput._utilrrpynputrobjectrEnumrHrrr:r rrsa"  1y6fy6xZ%$))Z%z|$|$@ ssr