


"""simple docstring"""


import os
import string
import sys


__lowerCamelCase      :Dict	    =		1 << 8

__lowerCamelCase      :Any	    =		{
    'tab': ord('\t'),
    'newline': ord('\r'),
    'esc': 27,
    'up': 65 + ARROW_KEY_FLAG,
    'down': 66 + ARROW_KEY_FLAG,
    'right': 67 + ARROW_KEY_FLAG,
    'left': 68 + ARROW_KEY_FLAG,
    'mod_int': 91,
    'undefined': sys.maxsize,
    'interrupt': 3,
    'insert': 50,
    'delete': 51,
    'pg_up': 53,
    'pg_down': 54,
}

__lowerCamelCase      :Optional[Any]	    =		KEYMAP['up']
__lowerCamelCase      :Optional[Any]	    =		KEYMAP['left']

if sys.platform == "win32":
    __lowerCamelCase      :Dict	    =		[]
    __lowerCamelCase      :List[Any]	    =		{
        b'\xe0H': KEYMAP['up'] - ARROW_KEY_FLAG,
        b'\x00H': KEYMAP['up'] - ARROW_KEY_FLAG,
        b'\xe0P': KEYMAP['down'] - ARROW_KEY_FLAG,
        b'\x00P': KEYMAP['down'] - ARROW_KEY_FLAG,
        b'\xe0M': KEYMAP['right'] - ARROW_KEY_FLAG,
        b'\x00M': KEYMAP['right'] - ARROW_KEY_FLAG,
        b'\xe0K': KEYMAP['left'] - ARROW_KEY_FLAG,
        b'\x00K': KEYMAP['left'] - ARROW_KEY_FLAG,
    }

for i in range(10):
    __lowerCamelCase      :int	    =		ord(str(i))




def   snake_case		(     )   ->      int:
      if os.name == "nt":
            import msvcrt

            lowerCamelCase					:					Optional[Any]        =	"""mbcs"""
            # Flush the keyboard buffer
            while msvcrt.kbhit():
                  msvcrt.getch()
            if len(UpperCamelCase__    ) == 0:
                  # Read the keystroke
                  lowerCamelCase					:					Optional[int]        =	msvcrt.getch()

                  # If it is a prefix char, get second part
                  if ch in (b"\x00", b"\xe0"):
                        lowerCamelCase					:					str        =	ch + msvcrt.getch()
                        # Translate actual Win chars to bullet char types
                        try:
                              lowerCamelCase					:					Dict        =	chr(WIN_KEYMAP[cha]    )
                              WIN_CH_BUFFER.append(chr(KEYMAP["""mod_int"""]    )    )
                              WIN_CH_BUFFER.append(UpperCamelCase__    )
                              if ord(UpperCamelCase__    ) in (
                                  KEYMAP["insert"] - 1 << 9,
                                  KEYMAP["delete"] - 1 << 9,
                                  KEYMAP["pg_up"] - 1 << 9,
                                  KEYMAP["pg_down"] - 1 << 9,
                              ):
                                    WIN_CH_BUFFER.append(chr(126    )    )
                              lowerCamelCase					:					List[Any]        =	chr(KEYMAP["""esc"""]    )
                        except KeyError:
                              lowerCamelCase					:					Dict        =	cha[1]
                  else:
                        lowerCamelCase					:					Any        =	ch.decode(UpperCamelCase__    )
            else:
                  lowerCamelCase					:					str        =	WIN_CH_BUFFER.pop(0    )
      elif os.name == "posix":
            import termios
            import tty

            lowerCamelCase					:					Dict        =	sys.stdin.fileno()
            lowerCamelCase					:					Optional[int]        =	termios.tcgetattr(UpperCamelCase__    )
            try:
                  tty.setraw(UpperCamelCase__    )
                  lowerCamelCase					:					int        =	sys.stdin.read(1    )
            finally:
                  termios.tcsetattr(UpperCamelCase__			,				termios.TCSADRAIN			,				UpperCamelCase__    )
      return ch






def   snake_case		(     )   ->      Dict:
      lowerCamelCase					:					Tuple        =	get_raw_chars()
      if ord(UpperCamelCase__    ) in [KEYMAP["interrupt"], KEYMAP["newline"]]:
            return char

      elif ord(UpperCamelCase__    ) == KEYMAP["esc"]:
            lowerCamelCase					:					str        =	get_raw_chars()
            if ord(UpperCamelCase__    ) == KEYMAP["mod_int"]:
                  lowerCamelCase					:					Dict        =	get_raw_chars()
                  if ord(UpperCamelCase__    ) >= KEYMAP["arrow_begin"] - ARROW_KEY_FLAG and ord(UpperCamelCase__    ) <= KEYMAP["arrow_end"] - ARROW_KEY_FLAG:
                        return chr(ord(UpperCamelCase__    ) + ARROW_KEY_FLAG    )
                  else:
                        return KEYMAP["undefined"]
            else:
                  return get_raw_chars()

      else:
            if char in string.printable:
                  return char
            else:
                  return KEYMAP["undefined"]








"""simple docstring"""


from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_sentencepiece_available


__lowerCamelCase      :str	    =		{}

try:
    if not is_sentencepiece_available():
        raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
    pass
else:
    __lowerCamelCase      :Optional[Any]	    =		['GPTSw3Tokenizer']


if TYPE_CHECKING:
    try:
        if not is_sentencepiece_available():
            raise OptionalDependencyNotAvailable()
    except OptionalDependencyNotAvailable:
        pass
    else:
        from .tokenization_gpt_swa import GPTSwaTokenizer

else:
    import sys

    __lowerCamelCase      :Tuple	    =		_LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)




