
import os
import string
import sys


lowerCamelCase_    :			str    =	1 << 8

lowerCamelCase_    :			Dict    =	{
    """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_    :			Dict    =	KEYMAP["""left"""]

if sys.platform == "win32":
							lowerCamelCase_    :			Optional[int]    =	[]
							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_    :			str    =	ord(str(i))







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

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

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

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







def 							A__       (    )	->						Tuple:
				UpperCamelCase_:				str						=    get_raw_chars()
				if ord(lowerCamelCase    ) in [KEYMAP["interrupt"], KEYMAP["newline"]]:
								return char

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

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








from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_tf_available, is_torch_available


lowerCamelCase_    :			Union[str, Any]    =	{
    """configuration_tapas""": ["""TAPAS_PRETRAINED_CONFIG_ARCHIVE_MAP""", """TapasConfig"""],
    """tokenization_tapas""": ["""TapasTokenizer"""],
}

try:
							if not is_torch_available():
														raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
							pass
else:
							lowerCamelCase_    :			List[Any]    =	[
							    """TAPAS_PRETRAINED_MODEL_ARCHIVE_LIST""",
							    """TapasForMaskedLM""",
							    """TapasForQuestionAnswering""",
							    """TapasForSequenceClassification""",
							    """TapasModel""",
							    """TapasPreTrainedModel""",
							    """load_tf_weights_in_tapas""",
							]
try:
							if not is_tf_available():
														raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
							pass
else:
							lowerCamelCase_    :			Optional[Any]    =	[
							    """TF_TAPAS_PRETRAINED_MODEL_ARCHIVE_LIST""",
							    """TFTapasForMaskedLM""",
							    """TFTapasForQuestionAnswering""",
							    """TFTapasForSequenceClassification""",
							    """TFTapasModel""",
							    """TFTapasPreTrainedModel""",
							]


if TYPE_CHECKING:
							from .configuration_tapas import TAPAS_PRETRAINED_CONFIG_ARCHIVE_MAP, TapasConfig
							from .tokenization_tapas import TapasTokenizer

							try:
														if not is_torch_available():
																					raise OptionalDependencyNotAvailable()
							except OptionalDependencyNotAvailable:
														pass
							else:
														from .modeling_tapas import (
														    TAPAS_PRETRAINED_MODEL_ARCHIVE_LIST,
														    TapasForMaskedLM,
														    TapasForQuestionAnswering,
														    TapasForSequenceClassification,
														    TapasModel,
														    TapasPreTrainedModel,
														    load_tf_weights_in_tapas,
														)

							try:
														if not is_tf_available():
																					raise OptionalDependencyNotAvailable()
							except OptionalDependencyNotAvailable:
														pass
							else:
														from .modeling_tf_tapas import (
														    TF_TAPAS_PRETRAINED_MODEL_ARCHIVE_LIST,
														    TFTapasForMaskedLM,
														    TFTapasForQuestionAnswering,
														    TFTapasForSequenceClassification,
														    TFTapasModel,
														    TFTapasPreTrainedModel,
														)


else:
							import sys

							lowerCamelCase_    :			Any    =	_LazyModule(__name__, globals()["""__file__"""], _import_structure, module_spec=__spec__)






