



"""simple docstring"""







import os
import string
import sys


UpperCamelCase     =							1 << 8

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

UpperCamelCase     =							KEYMAP["""up"""]
UpperCamelCase     =							KEYMAP["""left"""]

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

def       _lowerCamelCase				(							)	-> int:






	"""simple docstring"""





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

		A__											=					"mbcs"
		# Flush the keyboard buffer
		while msvcrt.kbhit():
			msvcrt.getch()
		if len(UpperCAmelCase_     ) == 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(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(126     )     )
					A__											=					chr(KEYMAP["esc"]     )
				except KeyError:
					A__											=					cha[1]
			else:
				A__											=					ch.decode(UpperCAmelCase_     )
		else:
			A__											=					WIN_CH_BUFFER.pop(0     )
	elif os.name == "posix":
		import termios
		import tty

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




def       _lowerCamelCase				(							)	-> List[str]:






	"""simple docstring"""





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

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






import os
from tempfile import TemporaryDirectory
from unittest import TestCase

import pytest
from absl.testing import parameterized

from datasets import config
from datasets.arrow_reader import HF_GCP_BASE_URL
from datasets.builder import DatasetBuilder
from datasets.dataset_dict import IterableDatasetDict
from datasets.iterable_dataset import IterableDataset
from datasets.load import dataset_module_factory, import_main_class
from datasets.utils.file_utils import cached_path


_lowercase							=				[
    {'''dataset''': '''wikipedia''', '''config_name''': '''20220301.de'''},
    {'''dataset''': '''wikipedia''', '''config_name''': '''20220301.en'''},
    {'''dataset''': '''wikipedia''', '''config_name''': '''20220301.fr'''},
    {'''dataset''': '''wikipedia''', '''config_name''': '''20220301.frr'''},
    {'''dataset''': '''wikipedia''', '''config_name''': '''20220301.it'''},
    {'''dataset''': '''wikipedia''', '''config_name''': '''20220301.simple'''},
    {'''dataset''': '''snli''', '''config_name''': '''plain_text'''},
    {'''dataset''': '''eli5''', '''config_name''': '''LFQA_reddit'''},
    {'''dataset''': '''wiki40b''', '''config_name''': '''en'''},
    {'''dataset''': '''wiki_dpr''', '''config_name''': '''psgs_w100.nq.compressed'''},
    {'''dataset''': '''wiki_dpr''', '''config_name''': '''psgs_w100.nq.no_index'''},
    {'''dataset''': '''wiki_dpr''', '''config_name''': '''psgs_w100.multiset.no_index'''},
    {'''dataset''': '''natural_questions''', '''config_name''': '''default'''},
]



def      lowerCAmelCase__			(		__magic_name__=True      )						->int:
			if with_config:
						return [
						    {
						        "testcase_name": d["dataset"] + "/" + d["config_name"],
						        "dataset": d["dataset"],
						        "config_name": d["config_name"],
						    }
						    for d in DATASETS_ON_HF_GCP
						]
			else:
						return [
						    {"testcase_name": dataset, "dataset": dataset} for dataset in {d["dataset"] for d in DATASETS_ON_HF_GCP}
						]

@parameterized.named_parameters(list_datasets_on_hf_gcp_parameters(with_config=__a       )       )
class 					__a     ( __a       ):



							'''simple docstring'''







							_lowerCamelCase					:			int          =   None
							_lowerCamelCase					:			int          =   None
							def   SCREAMING_SNAKE_CASE						(     self  ,    _lowerCamelCase  ,    _lowerCamelCase       )			->							Optional[Any]:




										'''simple docstring'''
										with TemporaryDirectory() as tmp_dir:
													__lowercase       =       dataset_module_factory(_lowerCamelCase  ,    cache_dir=_lowerCamelCase       )

													__lowercase       =       import_main_class(dataset_module.module_path  ,    dataset=_lowerCamelCase       )

													__lowercase       =       builder_cls(
													    cache_dir=_lowerCamelCase  ,    config_name=_lowerCamelCase  ,    hash=dataset_module.hash  ,    )

													__lowercase       =       "/".join(
													    [
													        HF_GCP_BASE_URL,
													        builder_instance._relative_data_dir(with_hash=_lowerCamelCase       ).replace(os.sep  ,    "/"       ),
													        config.DATASET_INFO_FILENAME,
													    ]       )
													__lowercase       =       cached_path(_lowerCamelCase  ,    cache_dir=_lowerCamelCase       )
													self.assertTrue(os.path.exists(_lowerCamelCase       )       )





@pytest.mark.integration
def      lowerCAmelCase__			(		__magic_name__      )						->str:
			__lowercase       =       tmp_path_factory.mktemp("test_hf_gcp"      ) / "test_wikipedia_simple"
			__lowercase       =       dataset_module_factory("wikipedia"			,   cache_dir=__magic_name__      )
			__lowercase       =       import_main_class(dataset_module.module_path      )
			__lowercase       =       builder_cls(
			    cache_dir=__magic_name__			,   config_name="20220301.frr"			,   hash=dataset_module.hash			,   )
			# use the HF cloud storage, not the original download_and_prepare that uses apache-beam
			__lowercase       =       None
			builder_instance.download_and_prepare()
			__lowercase       =       builder_instance.as_dataset()
			assert ds







@pytest.mark.integration
def      lowerCAmelCase__			(		__magic_name__      )						->Any:
			__lowercase       =       dataset_module_factory("wikipedia"			,   cache_dir=__magic_name__      )
			__lowercase       =       import_main_class(dataset_module.module_path			,   dataset=__magic_name__      )
			__lowercase       =       builder_cls(
			    cache_dir=__magic_name__			,   config_name="20220301.frr"			,   hash=dataset_module.hash			,   )
			__lowercase       =       builder_instance.as_streaming_dataset()
			assert ds
			assert isinstance(__magic_name__			,   __magic_name__      )
			assert "train" in ds
			assert isinstance(ds["train"]			,   __magic_name__      )
			assert next(iter(ds["train"]      )      )





