
import os
import tempfile
from functools import partial
from unittest import TestCase
from unittest.mock import patch

import datasets
import datasets.config

from .utils import require_beam




class 					lowerCamelCase__				(							datasets.BeamBasedBuilder):




	'''simple docstring'''




	def   _lowerCamelCase							(   self						:int		)						->					List[Any]:
								return datasets.DatasetInfo(
								    features=datasets.Features({"content": datasets.Value("string"		)}		)	,  supervised_keys=a	,  )







	def   _lowerCamelCase							(   self						:List[Any]	,  a						:Optional[Any]	,  a						:List[Any]		)						->					Optional[Any]:
								return [datasets.SplitGenerator(name=datasets.Split.TRAIN	,  gen_kwargs={"examples": get_test_dummy_examples()}		)]







	def   _lowerCamelCase							(   self						:Optional[int]	,  a						:List[Any]	,  a						:Any		)						->					Dict:
								import apache_beam as beam

								return pipeline | "Load Examples" >> beam.Create(a		)




class 					lowerCamelCase__				(							datasets.BeamBasedBuilder):




	'''simple docstring'''




	def   _lowerCamelCase							(   self						:Dict		)						->					List[Any]:
								return datasets.DatasetInfo(
								    features=datasets.Features({"a": datasets.Sequence({"b": datasets.Value("string"		)}		)}		)	,  supervised_keys=a	,  )







	def   _lowerCamelCase							(   self						:int	,  a						:str	,  a						:Optional[int]		)						->					List[Any]:
								return [
								    datasets.SplitGenerator(name=datasets.Split.TRAIN	,  gen_kwargs={"examples": get_test_nested_examples()}		)
								]







	def   _lowerCamelCase							(   self						:Tuple	,  a						:Tuple	,  a						:Dict		)						->					Any:
								import apache_beam as beam

								return pipeline | "Load Examples" >> beam.Create(a		)




def       _SCREAMING_SNAKE_CASE   (						)   ->       Any:






							'''simple docstring'''





							return [(i, {"content": content}) for i, content in enumerate(["foo", "bar", "foobar"])]




def       _SCREAMING_SNAKE_CASE   (						)   ->       Dict:






							'''simple docstring'''





							return [(i, {"a": {"b": [content]}}) for i, content in enumerate(["foo", "bar", "foobar"])]




class 					lowerCamelCase__				(							__lowercase):




	'''simple docstring'''




	@require_beam
	def   _lowerCamelCase							(   self						:Any		)						->					str:
								__UpperCamelCase      :  Tuple       =   len(get_test_dummy_examples()		)
								with tempfile.TemporaryDirectory() as tmp_cache_dir:
															__UpperCamelCase      :  str       =   DummyBeamDataset(cache_dir=a	,  beam_runner="DirectRunner"		)
															builder.download_and_prepare()
															self.assertTrue(
															    os.path.exists(
															        os.path.join(a	,  builder.name	,  "default"	,  "0.0.0"	,  f'{builder.name}-train.arrow'		)		)		)
															self.assertDictEqual(builder.info.features	,  datasets.Features({"content": datasets.Value("string"		)}		)		)
															__UpperCamelCase      :  Dict       =   builder.as_dataset()
															self.assertEqual(dset["train"].num_rows	,  a		)
															self.assertEqual(dset["train"].info.splits["train"].num_examples	,  a		)
															self.assertDictEqual(dset["train"][0]	,  get_test_dummy_examples()[0][1]		)
															self.assertDictEqual(
															    dset["train"][expected_num_examples - 1]	,  get_test_dummy_examples()[expected_num_examples - 1][1]		)
															self.assertTrue(
															    os.path.exists(os.path.join(a	,  builder.name	,  "default"	,  "0.0.0"	,  "dataset_info.json"		)		)		)
															del dset







	@require_beam
	def   _lowerCamelCase							(   self						:int		)						->					Union[str, Any]:
								import apache_beam as beam

								__UpperCamelCase      :  Dict       =   beam.io.parquetio.WriteToParquet

								__UpperCamelCase      :  Optional[Any]       =   len(get_test_dummy_examples()		)
								with tempfile.TemporaryDirectory() as tmp_cache_dir:
															__UpperCamelCase      :  int       =   DummyBeamDataset(cache_dir=a	,  beam_runner="DirectRunner"		)
															with patch("apache_beam.io.parquetio.WriteToParquet"		) as write_parquet_mock:
																						__UpperCamelCase      :  int       =   partial(a	,  num_shards=2		)
																						builder.download_and_prepare()
															self.assertTrue(
															    os.path.exists(
															        os.path.join(
															            a	,  builder.name	,  "default"	,  "0.0.0"	,  f'{builder.name}-train-00000-of-00002.arrow'		)		)		)
															self.assertTrue(
															    os.path.exists(
															        os.path.join(
															            a	,  builder.name	,  "default"	,  "0.0.0"	,  f'{builder.name}-train-00000-of-00002.arrow'		)		)		)
															self.assertDictEqual(builder.info.features	,  datasets.Features({"content": datasets.Value("string"		)}		)		)
															__UpperCamelCase      :  Tuple       =   builder.as_dataset()
															self.assertEqual(dset["train"].num_rows	,  a		)
															self.assertEqual(dset["train"].info.splits["train"].num_examples	,  a		)
															# Order is not preserved when sharding, so we just check that all the elements are there
															self.assertListEqual(sorted(dset["train"]["content"]		)	,  sorted(["foo", "bar", "foobar"]		)		)
															self.assertTrue(
															    os.path.exists(os.path.join(a	,  builder.name	,  "default"	,  "0.0.0"	,  "dataset_info.json"		)		)		)
															del dset







	@require_beam
	def   _lowerCamelCase							(   self						:Any		)						->					Optional[int]:
								with tempfile.TemporaryDirectory() as tmp_cache_dir:
															__UpperCamelCase      :  Dict       =   DummyBeamDataset(cache_dir=a		)
															self.assertRaises(datasets.builder.MissingBeamOptions	,  builder.download_and_prepare		)







	@require_beam
	def   _lowerCamelCase							(   self						:Optional[int]		)						->					List[Any]:
								__UpperCamelCase      :  List[Any]       =   len(get_test_nested_examples()		)
								with tempfile.TemporaryDirectory() as tmp_cache_dir:
															__UpperCamelCase      :  Tuple       =   NestedBeamDataset(cache_dir=a	,  beam_runner="DirectRunner"		)
															builder.download_and_prepare()
															self.assertTrue(
															    os.path.exists(
															        os.path.join(a	,  builder.name	,  "default"	,  "0.0.0"	,  f'{builder.name}-train.arrow'		)		)		)
															self.assertDictEqual(
															    builder.info.features	,  datasets.Features({"a": datasets.Sequence({"b": datasets.Value("string"		)}		)}		)		)
															__UpperCamelCase      :  List[str]       =   builder.as_dataset()
															self.assertEqual(dset["train"].num_rows	,  a		)
															self.assertEqual(dset["train"].info.splits["train"].num_examples	,  a		)
															self.assertDictEqual(dset["train"][0]	,  get_test_nested_examples()[0][1]		)
															self.assertDictEqual(
															    dset["train"][expected_num_examples - 1]	,  get_test_nested_examples()[expected_num_examples - 1][1]		)
															self.assertTrue(
															    os.path.exists(os.path.join(a	,  builder.name	,  "default"	,  "0.0.0"	,  "dataset_info.json"		)		)		)
															del dset

from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_torch_available,
)


lowercase    :   List[str]						=			{
    'configuration_gpt_bigcode': ['GPT_BIGCODE_PRETRAINED_CONFIG_ARCHIVE_MAP', 'GPTBigCodeConfig'],
}

try:
		if not is_torch_available():
				raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
		pass
else:
		lowercase    :   List[str]						=			[
		    'GPT_BIGCODE_PRETRAINED_MODEL_ARCHIVE_LIST',
		    'GPTBigCodeForSequenceClassification',
		    'GPTBigCodeForTokenClassification',
		    'GPTBigCodeForCausalLM',
		    'GPTBigCodeModel',
		    'GPTBigCodePreTrainedModel',
		]

if TYPE_CHECKING:
		from .configuration_gpt_bigcode import GPT_BIGCODE_PRETRAINED_CONFIG_ARCHIVE_MAP, GPTBigCodeConfig

		try:
				if not is_torch_available():
						raise OptionalDependencyNotAvailable()
		except OptionalDependencyNotAvailable:
				pass
		else:
				from .modeling_gpt_bigcode import (
				    GPT_BIGCODE_PRETRAINED_MODEL_ARCHIVE_LIST,
				    GPTBigCodeForCausalLM,
				    GPTBigCodeForSequenceClassification,
				    GPTBigCodeForTokenClassification,
				    GPTBigCodeModel,
				    GPTBigCodePreTrainedModel,
				)


else:
		import sys

		lowercase    :   Tuple						=			_LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)