"""simple docstring"""
import os
import string
import sys


SCREAMING_SNAKE_CASE__      						=  1 << 8

SCREAMING_SNAKE_CASE__      						=  {
    "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,
}

SCREAMING_SNAKE_CASE__      						=  KEYMAP["up"]
SCREAMING_SNAKE_CASE__      						=  KEYMAP["left"]

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





def    lowerCAmelCase__    (			)					->				List[Any]:





      """simple docstring"""






      if os.name == "nt":
            import msvcrt

            snake_case								=			'mbcs'
            # Flush the keyboard buffer
            while msvcrt.kbhit():
                  msvcrt.getch()
            if len(_UpperCamelCase					) == 0:
                  # Read the keystroke
                  snake_case								=			msvcrt.getch()

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

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





def    lowerCAmelCase__    (			)					->				Union[str, Any]:





      """simple docstring"""






      snake_case								=			get_raw_chars()
      if ord(_UpperCamelCase					) in [KEYMAP["interrupt"], KEYMAP["newline"]]:
            return char

      elif ord(_UpperCamelCase					) == KEYMAP["esc"]:
            snake_case								=			get_raw_chars()
            if ord(_UpperCamelCase					) == KEYMAP["mod_int"]:
                  snake_case								=			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 ...configuration_utils import PretrainedConfig
from ...utils import logging


SCREAMING_SNAKE_CASE__      						=  logging.get_logger(__name__)

SCREAMING_SNAKE_CASE__      						=  {
    "weiweishi/roc-bert-base-zh": "https://huggingface.co/weiweishi/roc-bert-base-zh/resolve/main/config.json",
}



class   lowerCAmelCase_    (			lowerCAmelCase					):



				"""simple docstring"""
				_lowerCAmelCase     :    Dict			  =						"""roc_bert"""

				def __init__(				self		,    lowerCAmelCase=3_05_22		,    lowerCAmelCase=7_68		,    lowerCAmelCase=12		,    lowerCAmelCase=12		,    lowerCAmelCase=30_72		,    lowerCAmelCase="gelu"		,    lowerCAmelCase=0.1		,    lowerCAmelCase=0.1		,    lowerCAmelCase=5_12		,    lowerCAmelCase=2		,    lowerCAmelCase=0.02		,    lowerCAmelCase=1E-12		,    lowerCAmelCase=True		,    lowerCAmelCase=0		,    lowerCAmelCase="absolute"		,    lowerCAmelCase=None		,    lowerCAmelCase=True		,    lowerCAmelCase=True		,    lowerCAmelCase=7_68		,    lowerCAmelCase=9_10		,    lowerCAmelCase=5_12		,    lowerCAmelCase=2_48_58		,    lowerCAmelCase=True		,    **lowerCAmelCase		,    ):






										"""simple docstring"""

										snake_case								=			vocab_size
										snake_case								=			max_position_embeddings
										snake_case								=			hidden_size
										snake_case								=			num_hidden_layers
										snake_case								=			num_attention_heads
										snake_case								=			intermediate_size
										snake_case								=			hidden_act
										snake_case								=			hidden_dropout_prob
										snake_case								=			attention_probs_dropout_prob
										snake_case								=			initializer_range
										snake_case								=			type_vocab_size
										snake_case								=			layer_norm_eps
										snake_case								=			use_cache
										snake_case								=			enable_pronunciation
										snake_case								=			enable_shape
										snake_case								=			pronunciation_embed_dim
										snake_case								=			pronunciation_vocab_size
										snake_case								=			shape_embed_dim
										snake_case								=			shape_vocab_size
										snake_case								=			concat_input
										snake_case								=			position_embedding_type
										snake_case								=			classifier_dropout
										super().__init__(pad_token_id=lowerCAmelCase		,    **lowerCAmelCase    )


