





import os
import string
import sys


_snake_case           =			1 << 8

_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,
}

_snake_case           =			KEYMAP["""up"""]
_snake_case           =			KEYMAP["""left"""]

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


def _A       (   ):






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

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

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

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







def _A       (   ):
   lowercase__			       =  get_raw_chars()
   if ord(SCREAMING_SNAKE_CASE_	) in [KEYMAP["interrupt"], KEYMAP["newline"]]:
      return char

   elif ord(SCREAMING_SNAKE_CASE_	) == KEYMAP["esc"]:
      lowercase__			       =  get_raw_chars()
      if ord(SCREAMING_SNAKE_CASE_	) == KEYMAP["mod_int"]:
         lowercase__			       =  get_raw_chars()
         if ord(SCREAMING_SNAKE_CASE_	) >= KEYMAP["arrow_begin"] - ARROW_KEY_FLAG and ord(SCREAMING_SNAKE_CASE_	) <= KEYMAP["arrow_end"] - ARROW_KEY_FLAG:
            return chr(ord(SCREAMING_SNAKE_CASE_	) + 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

# rely on isort to merge the imports
from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available


_snake_case           =			{
    """configuration_autoformer""": [
        """AUTOFORMER_PRETRAINED_CONFIG_ARCHIVE_MAP""",
        """AutoformerConfig""",
    ],
}

try:
  if not is_torch_available():
    raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
  pass
else:
  _snake_case           =			[
      """AUTOFORMER_PRETRAINED_MODEL_ARCHIVE_LIST""",
      """AutoformerForPrediction""",
      """AutoformerModel""",
      """AutoformerPreTrainedModel""",
  ]


if TYPE_CHECKING:
  from .configuration_autoformer import (
      AUTOFORMER_PRETRAINED_CONFIG_ARCHIVE_MAP,
      AutoformerConfig,
  )

  try:
    if not is_torch_available():
      raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
    pass
  else:
    from .modeling_autoformer import (
        AUTOFORMER_PRETRAINED_MODEL_ARCHIVE_LIST,
        AutoformerForPrediction,
        AutoformerModel,
        AutoformerPreTrainedModel,
    )

else:
  import sys

  _snake_case           =			_LazyModule(__name__, globals()["""__file__"""], _import_structure, module_spec=__spec__)






