

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    __magic_name__       (		self :	Optional[int]       ):






      '''simple docstring'''




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

 def    __magic_name__       (		self :	List[str]     ,						A_ :	str     ,						A_ :	int       ):






      '''simple docstring'''




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


 def    __magic_name__       (		self :	str     ,						A_ :	Dict     ,						A_ :	Dict       ):






      '''simple docstring'''




      import apache_beam as beam

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





class A__    ( datasets.BeamBasedBuilder ):



 """simple docstring"""







 def    __magic_name__       (		self :	str       ):






      '''simple docstring'''




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

 def    __magic_name__       (		self :	Tuple     ,						A_ :	List[Any]     ,						A_ :	Tuple       ):






      '''simple docstring'''




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


 def    __magic_name__       (		self :	str     ,						A_ :	List[str]     ,						A_ :	List[Any]       ):






      '''simple docstring'''




      import apache_beam as beam

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







def 	_snake_case		(    )       ->      str:

     """simple docstring"""







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







def 	_snake_case		(    )       ->      str:

     """simple docstring"""







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





class A__    ( A ):



 """simple docstring"""







 @require_beam
 def    __magic_name__       (		self :	List[str]       ):






      '''simple docstring'''




      _lowerCAmelCase   :					Optional[Any]        =    len(get_test_dummy_examples()       )
      with tempfile.TemporaryDirectory() as tmp_cache_dir:
           _lowerCAmelCase   :					int        =    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"       )}       )       )
           _lowerCAmelCase   :					Union[str, Any]        =    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    __magic_name__       (		self :	Union[str, Any]       ):






      '''simple docstring'''




      import apache_beam as beam

      _lowerCAmelCase   :					Dict        =    beam.io.parquetio.WriteToParquet

      _lowerCAmelCase   :					List[Any]        =    len(get_test_dummy_examples()       )
      with tempfile.TemporaryDirectory() as tmp_cache_dir:
           _lowerCAmelCase   :					Optional[int]        =    DummyBeamDataset(cache_dir=A_     ,						beam_runner="DirectRunner"       )
           with patch("apache_beam.io.parquetio.WriteToParquet"       ) as write_parquet_mock:
                _lowerCAmelCase   :					Optional[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"       )}       )       )
           _lowerCAmelCase   :					Optional[Any]        =    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    __magic_name__       (		self :	Any       ):






      '''simple docstring'''




      with tempfile.TemporaryDirectory() as tmp_cache_dir:
           _lowerCAmelCase   :					str        =    DummyBeamDataset(cache_dir=A_       )
           self.assertRaises(datasets.builder.MissingBeamOptions     ,						builder.download_and_prepare       )


 @require_beam
 def    __magic_name__       (		self :	List[str]       ):






      '''simple docstring'''




      _lowerCAmelCase   :					List[str]        =    len(get_test_nested_examples()       )
      with tempfile.TemporaryDirectory() as tmp_cache_dir:
           _lowerCAmelCase   :					str        =    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"       )}       )}       )       )
           _lowerCAmelCase   :					int        =    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_tensorflow_text_available, is_torch_available


__UpperCAmelCase    				=     {
    'configuration_ernie': ['ERNIE_PRETRAINED_CONFIG_ARCHIVE_MAP', 'ErnieConfig', 'ErnieOnnxConfig'],
}

try:
  if not is_torch_available():
    raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
  pass
else:
  __UpperCAmelCase    				=     [
      'ERNIE_PRETRAINED_MODEL_ARCHIVE_LIST',
      'ErnieForCausalLM',
      'ErnieForMaskedLM',
      'ErnieForMultipleChoice',
      'ErnieForNextSentencePrediction',
      'ErnieForPreTraining',
      'ErnieForQuestionAnswering',
      'ErnieForSequenceClassification',
      'ErnieForTokenClassification',
      'ErnieModel',
      'ErniePreTrainedModel',
  ]

if TYPE_CHECKING:
  from .configuration_ernie import ERNIE_PRETRAINED_CONFIG_ARCHIVE_MAP, ErnieConfig, ErnieOnnxConfig

  try:
    if not is_torch_available():
      raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
    pass
  else:
    from .modeling_ernie import (
        ERNIE_PRETRAINED_MODEL_ARCHIVE_LIST,
        ErnieForCausalLM,
        ErnieForMaskedLM,
        ErnieForMultipleChoice,
        ErnieForNextSentencePrediction,
        ErnieForPreTraining,
        ErnieForQuestionAnswering,
        ErnieForSequenceClassification,
        ErnieForTokenClassification,
        ErnieModel,
        ErniePreTrainedModel,
    )

else:
  import sys

  __UpperCAmelCase    				=     _LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)






