


import os
import string
import sys


snake_case				:			str	     = 1 << 8

snake_case				:			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,
}

snake_case				:			Optional[Any]	     = KEYMAP["""up"""]
snake_case				:			Dict	     = KEYMAP["""left"""]

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






def 				__lowercase  (					):
							if os.name == "nt":
														import msvcrt

														a__			 =	"""mbcs"""
														# Flush the keyboard buffer
														while msvcrt.kbhit():
																					msvcrt.getch()
														if len(__lowerCAmelCase  ) == 0:
																					# Read the keystroke
																					a__			 =	msvcrt.getch()

																					# If it is a prefix char, get second part
																					if ch in (b"\x00", b"\xe0"):
																												a__			 =	ch + msvcrt.getch()
																												# Translate actual Win chars to bullet char types
																												try:
																																			a__			 =	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_2_6  )  )
																																			a__			 =	chr(KEYMAP['esc']  )
																												except KeyError:
																																			a__			 =	cha[1]
																					else:
																												a__			 =	ch.decode(__lowerCAmelCase  )
														else:
																					a__			 =	WIN_CH_BUFFER.pop(0  )
							elif os.name == "posix":
														import termios
														import tty

														a__			 =	sys.stdin.fileno()
														a__			 =	termios.tcgetattr(__lowerCAmelCase  )
														try:
																					tty.setraw(__lowerCAmelCase  )
																					a__			 =	sys.stdin.read(1  )
														finally:
																					termios.tcsetattr(__lowerCAmelCase   ,       termios.TCSADRAIN   ,       __lowerCAmelCase  )
							return ch






def 				__lowercase  (					):
							a__			 =	get_raw_chars()
							if ord(__lowerCAmelCase  ) in [KEYMAP["interrupt"], KEYMAP["newline"]]:
														return char

							elif ord(__lowerCAmelCase  ) == KEYMAP["esc"]:
														a__			 =	get_raw_chars()
														if ord(__lowerCAmelCase  ) == KEYMAP["mod_int"]:
																					a__			 =	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__)






