



"""simple docstring"""






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     A__     (						datasets.BeamBasedBuilder							):




	'''simple docstring'''





	def 							_SCREAMING_SNAKE_CASE     (  self:	Optional[Any])       -> Dict:

				"""simple docstring"""

				return datasets.DatasetInfo(
				    features=datasets.Features({"content": datasets.Value("string")}) ,    supervised_keys=UpperCamelCase__ ,    )

	def 							_SCREAMING_SNAKE_CASE     (  self:	Dict ,    _SCREAMING_SNAKE_CASE:	Optional[int] ,    _SCREAMING_SNAKE_CASE:	Optional[Any])       -> str:

				"""simple docstring"""

				return [datasets.SplitGenerator(name=datasets.Split.TRAIN ,    gen_kwargs={"examples": get_test_dummy_examples()})]







	def 							_SCREAMING_SNAKE_CASE     (  self:	Optional[Any] ,    _SCREAMING_SNAKE_CASE:	int ,    _SCREAMING_SNAKE_CASE:	Dict)       -> Any:

				"""simple docstring"""

				import apache_beam as beam

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






class     A__     (						datasets.BeamBasedBuilder							):




	'''simple docstring'''





	def 							_SCREAMING_SNAKE_CASE     (  self:	Dict)       -> Dict:

				"""simple docstring"""

				return datasets.DatasetInfo(
				    features=datasets.Features({"a": datasets.Sequence({"b": datasets.Value("string")})}) ,    supervised_keys=UpperCamelCase__ ,    )

	def 							_SCREAMING_SNAKE_CASE     (  self:	str ,    _SCREAMING_SNAKE_CASE:	List[Any] ,    _SCREAMING_SNAKE_CASE:	Dict)       -> List[Any]:

				"""simple docstring"""

				return [
				    datasets.SplitGenerator(name=datasets.Split.TRAIN ,    gen_kwargs={"examples": get_test_nested_examples()})
				]







	def 							_SCREAMING_SNAKE_CASE     (  self:	Union[str, Any] ,    _SCREAMING_SNAKE_CASE:	Tuple ,    _SCREAMING_SNAKE_CASE:	str)       -> Optional[int]:

				"""simple docstring"""

				import apache_beam as beam

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






def     _lowercase       (						)		->     List[Any]:
			return [(i, {"content": content}) for i, content in enumerate(["foo", "bar", "foobar"]			)]


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





class     A__     (						lowercase_							):




	'''simple docstring'''





	@require_beam
	def 							_SCREAMING_SNAKE_CASE     (  self:	Any)       -> Dict:

				"""simple docstring"""

				__lowerCAmelCase   :						Dict				= len(get_test_dummy_examples())
				with tempfile.TemporaryDirectory() as tmp_cache_dir:
							__lowerCAmelCase   :						Any				= DummyBeamDataset(cache_dir=UpperCamelCase__ ,    beam_runner="DirectRunner")
							builder.download_and_prepare()
							self.assertTrue(
							    os.path.exists(
							        os.path.join(UpperCamelCase__ ,    builder.name ,    "default" ,    "0.0.0" ,    F"""{builder.name}-train.arrow""")))
							self.assertDictEqual(builder.info.features ,    datasets.Features({"content": datasets.Value("string")}))
							__lowerCAmelCase   :						Union[str, Any]				= builder.as_dataset()
							self.assertEqual(dset["train"].num_rows ,    UpperCamelCase__)
							self.assertEqual(dset["train"].info.splits["train"].num_examples ,    UpperCamelCase__)
							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(UpperCamelCase__ ,    builder.name ,    "default" ,    "0.0.0" ,    "dataset_info.json")))
							del dset

	@require_beam
	def 							_SCREAMING_SNAKE_CASE     (  self:	Dict)       -> Optional[Any]:

				"""simple docstring"""

				import apache_beam as beam

				__lowerCAmelCase   :						Any				= beam.io.parquetio.WriteToParquet

				__lowerCAmelCase   :						Dict				= len(get_test_dummy_examples())
				with tempfile.TemporaryDirectory() as tmp_cache_dir:
							__lowerCAmelCase   :						Optional[Any]				= DummyBeamDataset(cache_dir=UpperCamelCase__ ,    beam_runner="DirectRunner")
							with patch("apache_beam.io.parquetio.WriteToParquet") as write_parquet_mock:
										__lowerCAmelCase   :						List[str]				= partial(UpperCamelCase__ ,    num_shards=2)
										builder.download_and_prepare()
							self.assertTrue(
							    os.path.exists(
							        os.path.join(
							            UpperCamelCase__ ,    builder.name ,    "default" ,    "0.0.0" ,    F"""{builder.name}-train-00000-of-00002.arrow""")))
							self.assertTrue(
							    os.path.exists(
							        os.path.join(
							            UpperCamelCase__ ,    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")}))
							__lowerCAmelCase   :						Union[str, Any]				= builder.as_dataset()
							self.assertEqual(dset["train"].num_rows ,    UpperCamelCase__)
							self.assertEqual(dset["train"].info.splits["train"].num_examples ,    UpperCamelCase__)
							# 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(UpperCamelCase__ ,    builder.name ,    "default" ,    "0.0.0" ,    "dataset_info.json")))
							del dset

	@require_beam
	def 							_SCREAMING_SNAKE_CASE     (  self:	Any)       -> int:

				"""simple docstring"""

				with tempfile.TemporaryDirectory() as tmp_cache_dir:
							__lowerCAmelCase   :						Tuple				= DummyBeamDataset(cache_dir=UpperCamelCase__)
							self.assertRaises(datasets.builder.MissingBeamOptions ,    builder.download_and_prepare)







	@require_beam
	def 							_SCREAMING_SNAKE_CASE     (  self:	int)       -> Union[str, Any]:

				"""simple docstring"""

				__lowerCAmelCase   :						Union[str, Any]				= len(get_test_nested_examples())
				with tempfile.TemporaryDirectory() as tmp_cache_dir:
							__lowerCAmelCase   :						Optional[Any]				= NestedBeamDataset(cache_dir=UpperCamelCase__ ,    beam_runner="DirectRunner")
							builder.download_and_prepare()
							self.assertTrue(
							    os.path.exists(
							        os.path.join(UpperCamelCase__ ,    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")})}))
							__lowerCAmelCase   :						Dict				= builder.as_dataset()
							self.assertEqual(dset["train"].num_rows ,    UpperCamelCase__)
							self.assertEqual(dset["train"].info.splits["train"].num_examples ,    UpperCamelCase__)
							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(UpperCamelCase__ ,    builder.name ,    "default" ,    "0.0.0" ,    "dataset_info.json")))
							del dset




"""simple docstring"""






def     _lowercase       (						__snake_case      ,__snake_case			)		->     list:
			__lowerCAmelCase   :						List[str]				= len(__snake_case			)
			__lowerCAmelCase   :						Dict				= []
			for i in range(len(__snake_case			) - pat_len + 1			):
						__lowerCAmelCase   :						List[Any]				= True
						for j in range(__snake_case			):
									if s[i + j] != pattern[j]:
												__lowerCAmelCase   :						Union[str, Any]				= False
												break
						if match_found:
									position.append(__snake_case			)
			return position


if __name__ == "__main__":
	assert naive_pattern_search('ABCDEFG', 'DE') == [3]
	print(naive_pattern_search('ABAAABCDBBABCDDEBCABC', 'ABC'))