o PhXH @sdZddlZddlZddlZddlZddlmZddlmZm Z e dkr1ddl Z ddl mZn ddl Z ddlmZGdddeZd d Zd d Zd dZddZddZddZddZddZdZeeZeD] Zed7Zeede<qnge de j fe de j fe de j!fe de"fe d e j#fe d!e j!fd"e j$fd#e j%fd$e j&fd%e j'fd&e j(fd'e j)fd(e j*fd)e j+fd*e j,fd+e j-fd,e j,fd-e j.fd.e j/fd/e j fd0e0fd1e1fd2e2fd3e3fd4e4fd5e5fd6e6fd7e7fd8e8fd9e9fd:e:fd;e;fde>fd?e?fd@e@fdAe jAfdBe jBfdCe jCfdDe jDfdEe j/fdFe j.fdGe j-fdHe j,fdIe j$fdJe j%fdKe j&fdLe j'fdMe j,fdNe j-fdOe jEfdPe jFfdQe jGfdRe jHfRZIdSe jCfdTe jBfdUe j/fdVe j.fdWe j#fdXe j(fdYe j)fdZe jJfd[e jKfd\e jLfd]e jMff ZNd^aOd_d`ZPePdaZQdS)bz*Sub-module providing 'keyboard awareness'.N) OrderedDict)TextType unicode_chrWindows)_capability_namesc@sNeZdZdZdddZeddZdd Zeje_ed d Z ed d Z dS) Keystrokea A unicode-derived class for describing a single keystroke. A class instance describes a single keystroke received on input, which may contain multiple characters as a multibyte sequence, which is indicated by properties :attr:`is_sequence` returning ``True``. When the string is a known sequence, :attr:`code` matches terminal class attributes for comparison, such as ``term.KEY_LEFT``. The string-name of the sequence, such as ``u'KEY_LEFT'`` is accessed by property :attr:`name`, and is used by the :meth:`__repr__` method to display a human-readable form of the Keystroke this class instance represents. It may otherwise by joined, split, or evaluated just as as any other unicode string. NcCst||}||_||_|S)zClass constructor.)r__new___name_code)clsucscodenamenewrK/var/www/html/env_mimamsha/lib/python3.10/site-packages/blessed/keyboard.pyr +s zKeystroke.__new__cCs |jduS)z9Whether the value represents a multibyte sequence (bool).Nr selfrrr is_sequence2s zKeystroke.is_sequencecCs|jdur t|S|jS)zDocstring overwritten.N)r r__repr__rrrrr7szKeystroke.__repr__cC|jS)z;String-name of key sequence, such as ``u'KEY_LEFT'`` (str).)r rrrrr=zKeystroke.namecCr)z2Integer keycode value of multibyte sequence (int).rrrrrrBrzKeystroke.code)rNN) __name__ __module__ __qualname____doc__r propertyrrrrrrrrrrs   rcCs ddttD}dd|DS)a1 Return mapping of curses key-names paired by their keycode integer value. :rtype: dict :returns: Dictionary of (name, code) pairs for curses keyboard constant values and their mnemonic name. Such as code ``260``, with the value of its key-name identity, ``u'KEY_LEFT'``. cSsg|] }|dr|qS)KEY_ startswith).0attrrrr Qs z'get_curses_keycodes..cSsi|]}|tt|qSr)getattrcurses)r"keynamerrr Ssz'get_curses_keycodes..)dirr&) _keynamesrrrget_curses_keycodesHs r+cCsHtt}|t|ddtDtt| | S)a? Return mapping of keycode integer values paired by their curses key-name. :rtype: dict :returns: Dictionary of (code, name) pairs for curses keyboard constant values and their mnemonic name. Such as key ``260``, with the value of its identity, ``u'KEY_LEFT'``. These keys are derived from the attributes by the same of the curses module, with the following exceptions: * ``KEY_DELETE`` in place of ``KEY_DC`` * ``KEY_INSERT`` in place of ``KEY_IC`` * ``KEY_PGUP`` in place of ``KEY_PPAGE`` * ``KEY_PGDOWN`` in place of ``KEY_NPAGE`` * ``KEY_ESCAPE`` in place of ``KEY_EXIT`` * ``KEY_SUP`` in place of ``KEY_SR`` * ``KEY_SDOWN`` in place of ``KEY_SF`` This function is the inverse of :func:`get_curses_keycodes`. With the given override "mixins" listed above, the keycode for the delete key will map to our imaginary ``KEY_DELETE`` mnemonic, effectively erasing the phrase ``KEY_DC`` from our code vocabulary for anyone that wishes to use the return value to determine the key-name by keycode. css&|]\}}|dr||fVqdS)rNr )r"rvaluerrr ss  z%get_keyboard_codes..) rr+updateCURSES_KEYCODE_OVERRIDE_MIXINglobalscopyitemsdictzipvalueskeys)keycodesrrrget_keyboard_codesVs    r8cCs@i}|jr|jdkrtj||j<|jr|jdkrtj||j<|S)a Determine and return mapping of left and right arrow keys sequences. :arg blessed.Terminal term: :class:`~.Terminal` instance. :rtype: dict :returns: Dictionary of sequences ``term._cuf1``, and ``term._cub1``, valued as ``KEY_RIGHT``, ``KEY_LEFT`` (when appropriate). This function supports :func:`get_terminal_sequences` to discover the preferred input sequence for the left and right application keys. It is necessary to check the value of these sequences to ensure we do not use ``u' '`` and ``u'\b'`` for ``KEY_RIGHT`` and ``KEY_LEFT``, preferring their true application key sequence, instead.  )_cuf1r& KEY_RIGHT_cub1KEY_LEFT)termkeymaprrr_alternative_left_right|s   rAcsft|jrddddtDDndt|ttfddt t ddDS)a Return mapping of keyboard sequences paired by keycodes. :arg blessed.Terminal term: :class:`~.Terminal` instance. :returns: mapping of keyboard unicode sequences paired by keycodes as integer. This is used as the argument ``mapper`` to the supporting function :func:`resolve_sequence`. :rtype: OrderedDict Initialize and return a keyboard map and sequence lookup table, (sequence, keycode) from :class:`~.Terminal` instance ``term``, where ``sequence`` is a multibyte input sequence of unicode characters, such as ``u'\x1b[D'``, and ``keycode`` is an integer value, matching curses constant such as term.KEY_LEFT. The return value is an OrderedDict instance, with their keys sorted longest-first. css&|]\}}|r|d|fVqdS)latin1N)decode)r"seqvalrrrr-s  z)get_keyboard_sequences..css"|] \}}t||fVqdSN)r&tigetstr)r"rEcaprrrr-s  rc3s|] }||fVqdSrFr)r"rD sequence_maprrr-s  T)keyreverse) r3 does_stylingcapability_namesr2r.rADEFAULT_SEQUENCE_MIXINrsortedr6len)r?rrIrget_keyboard_sequencess    rRcCsdd|DS)a Return a set of proper prefixes for given sequence of strings. :arg iterable sequences :rtype: set :return: Set of all string prefixes Given an iterable of strings, all textparts leading up to the final string is returned as a unique set. This function supports the :meth:`~.Terminal.inkey` method by determining whether the given input is a sequence that **may** lead to a final matching pattern. >>> prefixes(['abc', 'abdf', 'e', 'jkl']) set([u'a', u'ab', u'abd', u'j', u'jk']) cSs,h|]}tdt|D]}|d|q qS)N)rangerQ)r"rDirrr s,z'get_leading_prefixes..r) sequencesrrrget_leading_prefixessrXcCsH|D]\}}||rt||||dSqt|r |dp!ddS)a Return a single :class:`Keystroke` instance for given sequence ``text``. :arg str text: string of characters received from terminal input stream. :arg OrderedDict mapper: unicode multibyte sequences, such as ``u'\x1b[D'`` paired by their integer value (260) :arg dict codes: a :type:`dict` of integer values (such as 260) paired by their mnemonic name, such as ``'KEY_LEFT'``. :rtype: Keystroke :returns: Keystroke instance for the given sequence The given ``text`` may extend beyond a matching sequence, such as ``u\x1b[Dxxx`` returns a :class:`Keystroke` instance of attribute :attr:`Keystroke.sequence` valued only ``u\x1b[D``. It is up to calls to determine that ``xxx`` remains unresolved. )r rrrr)r )r2r!r)textmappercodessequencerrrrresolve_sequences  r]cCs|r td|t|S|S)a Return time remaining since ``stime`` before given ``timeout``. This function assists determining the value of ``timeout`` for class method :meth:`~.Terminal.kbhit` and similar functions. :arg float stime: starting time for measurement :arg float timeout: timeout period, may be set to None to indicate no timeout (where None is always returned). :rtype: float or int :returns: time remaining as float. If no time is remaining, then the integer ``0`` is returned. r)maxtime)stimetimeoutrrr _time_leftsrbcCs~t}d\}} |jt||d}|r ||7}|jdd}|stj||d}|dur0 ||fS|dur>t||s> ||fSq )a? Convenience read-until-pattern function, supporting :meth:`~.get_location`. :arg blessed.Terminal term: :class:`~.Terminal` instance. :arg float timeout: timeout period, may be set to None to indicate no timeout (where 0 is always returned). :arg str pattern: target regular expression pattern to seek. :rtype: tuple :returns: tuple in form of ``(match, str)``, *match* may be :class:`re.MatchObject` if pattern is discovered in input stream before timeout has elapsed, otherwise None. ``str`` is any remaining text received exclusive of the matching pattern). The reason a tuple containing non-matching data is returned, is that the consumer should push such data back into the input buffer by :meth:`~.Terminal.ungetch` if any was received. For example, when a user is performing rapid input keystrokes while its terminal emulator surreptitiously responds to this in-band sequence, we must ensure any such keyboard data is well-received by the next call to term.inkey() without delay. )NrT)rar)patternstringN)r_inkeyrbresearch)r?rcrar`matchbufr rrr _read_untils  rj)TAB KP_MULTIPLYKP_ADD KP_SEPARATOR KP_SUBTRACT KP_DECIMAL KP_DIVIDEKP_EQUALKP_0KP_1KP_2KP_3KP_4KP_5KP_6KP_7KP_8KP_9rSr  zzzzzzzzzzzzzzOMzOjzOkzOlzOmzOnzOozOXzOpzOqzOrzOszOtzOuzOvzOwzOxzOyz[1~z[2~z[3~z[4~z[5~z[6~z[7~z[8~zAzBzCzDzFzHzOPzOQzORzOS KEY_DELETE KEY_INSERTKEY_PGUP KEY_PGDOWN KEY_ESCAPEKEY_SUP KEY_SDOWN KEY_UP_LEFT KEY_UP_RIGHT KEY_CENTER KEY_BEGINgffffff?cCs>tjdrz ttjddaWdStyYdSwdS)NESCDELAYg@@)osenvirongetintDEFAULT_ESCDELAY ValueErrorrrrr_reinit_escdelays  r)rr8rR)Rrrrfr_platform collectionsrblessed._compatrrsystemjinxedr&jinxed.has_keyrrNcurses.has_keyrr+r8rArRrXr]rbrj_CURSES_KEYCODE_ADDINSr^r5_LASTVAL keycode_namer0 KEY_ENTER KEY_BACKSPACEKEY_TABKEY_EXITKEY_UPKEY_DOWNr<r>KEY_SRKEY_SF KEY_SRIGHT KEY_SLEFTKEY_ENDKEY_HOME KEY_NPAGE KEY_PPAGEKEY_KP_MULTIPLY KEY_KP_ADDKEY_KP_SEPARATORKEY_KP_SUBTRACTKEY_KP_DECIMAL KEY_KP_DIVIDE KEY_KP_EQUALKEY_KP_0KEY_KP_1KEY_KP_2KEY_KP_3KEY_KP_4KEY_KP_5KEY_KP_6KEY_KP_7KEY_KP_8KEY_KP_9KEY_FINDKEY_ICKEY_DC KEY_SELECTKEY_F1KEY_F2KEY_F3KEY_F4rOKEY_A1KEY_A3KEY_B2KEY_BEGr/rr__all__rrrrs2   0&1@           !"#$%&'()*+,-./23456789:;<=>?DEFGN