



import os
import string
import sys


a_								=       1 << 8

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

a_								=       KEYMAP["""up"""]
a_								=       KEYMAP["""left"""]

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





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

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

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

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





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

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











from typing import Callable, Optional

from .. import Features
from ..packaged_modules.generator.generator import Generator
from .abc import AbstractDatasetInputStream



class 			__lowerCAmelCase  (						lowerCAmelCase__ ):




 def __init__(    self						,					__UpperCAmelCase						,					__UpperCAmelCase = None						,					__UpperCAmelCase = None						,					__UpperCAmelCase = False						,					__UpperCAmelCase = False						,					__UpperCAmelCase = None						,					__UpperCAmelCase = None						,					**__UpperCAmelCase						,					):



    '''simple docstring'''
    super().__init__(
        features=__UpperCAmelCase						,					cache_dir=__UpperCAmelCase						,					keep_in_memory=__UpperCAmelCase						,					streaming=__UpperCAmelCase						,					num_proc=__UpperCAmelCase						,					**__UpperCAmelCase						,					)
    __lowerCamelCase    				=     Generator(
        cache_dir=__UpperCAmelCase						,					features=__UpperCAmelCase						,					generator=__UpperCAmelCase						,					gen_kwargs=__UpperCAmelCase						,					**__UpperCAmelCase						,					)




 def 							lowerCamelCase   (    self					):



    '''simple docstring'''
    # Build iterable dataset
    if self.streaming:
       __lowerCamelCase    				=     self.builder.as_streaming_dataset(split='''train'''					)
    # Build regular (map-style) dataset
    else:
       __lowerCamelCase    				=     None
       __lowerCamelCase    				=     None
       __lowerCamelCase    				=     None
       __lowerCamelCase    				=     None

       self.builder.download_and_prepare(
           download_config=__UpperCAmelCase						,					download_mode=__UpperCAmelCase						,					verification_mode=__UpperCAmelCase						,					base_path=__UpperCAmelCase						,					num_proc=self.num_proc						,					)
       __lowerCamelCase    				=     self.builder.as_dataset(
           split='''train'''						,					verification_mode=__UpperCAmelCase						,					in_memory=self.keep_in_memory					)
    return dataset






