

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

			def 					SCREAMING_SNAKE_CASE				(					self				:						Any       )   ->    str:
						return datasets.DatasetInfo(
						    features=datasets.Features({"""content""": datasets.Value("""string"""       )}       )    ,				supervised_keys=__UpperCAmelCase    ,				)

			def 					SCREAMING_SNAKE_CASE				(					self				:						List[str]    ,				__UpperCAmelCase				:						int    ,				__UpperCAmelCase				:						List[Any]       )   ->    int:
						return [datasets.SplitGenerator(name=datasets.Split.TRAIN    ,				gen_kwargs={"""examples""": get_test_dummy_examples()}       )]





			def 					SCREAMING_SNAKE_CASE				(					self				:						str    ,				__UpperCAmelCase				:						Tuple    ,				__UpperCAmelCase				:						Optional[Any]       )   ->    Tuple:
						import apache_beam as beam

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





class    lowerCamelCase						(datasets.BeamBasedBuilder			):

			def 					SCREAMING_SNAKE_CASE				(					self				:						Union[str, Any]       )   ->    Union[str, Any]:
						return datasets.DatasetInfo(
						    features=datasets.Features({"""a""": datasets.Sequence({"""b""": datasets.Value("""string"""       )}       )}       )    ,				supervised_keys=__UpperCAmelCase    ,				)

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





			def 					SCREAMING_SNAKE_CASE				(					self				:						int    ,				__UpperCAmelCase				:						Any    ,				__UpperCAmelCase				:						Optional[int]       )   ->    List[str]:
						import apache_beam as beam

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

def 	A       (     ):




			'''simple docstring'''


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

def 	A       (     ):




			'''simple docstring'''


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





class    lowerCamelCase						(A__			):

			@require_beam
			def 					SCREAMING_SNAKE_CASE				(					self				:						Optional[int]       )   ->    List[Any]:
						SCREAMING_SNAKE_CASE__								=      len(get_test_dummy_examples()       )
						with tempfile.TemporaryDirectory() as tmp_cache_dir:
									SCREAMING_SNAKE_CASE__								=      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"""       )}       )       )
									SCREAMING_SNAKE_CASE__								=      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				:						List[Any]       )   ->    Optional[Any]:
						import apache_beam as beam

						SCREAMING_SNAKE_CASE__								=      beam.io.parquetio.WriteToParquet

						SCREAMING_SNAKE_CASE__								=      len(get_test_dummy_examples()       )
						with tempfile.TemporaryDirectory() as tmp_cache_dir:
									SCREAMING_SNAKE_CASE__								=      DummyBeamDataset(cache_dir=__UpperCAmelCase    ,				beam_runner="""DirectRunner"""       )
									with patch("""apache_beam.io.parquetio.WriteToParquet"""       ) as write_parquet_mock:
												SCREAMING_SNAKE_CASE__								=      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"""       )}       )       )
									SCREAMING_SNAKE_CASE__								=      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				:						List[str]       )   ->    List[Any]:
						with tempfile.TemporaryDirectory() as tmp_cache_dir:
									SCREAMING_SNAKE_CASE__								=      DummyBeamDataset(cache_dir=__UpperCAmelCase       )
									self.assertRaises(datasets.builder.MissingBeamOptions    ,				builder.download_and_prepare       )





			@require_beam
			def 					SCREAMING_SNAKE_CASE				(					self				:						Optional[Any]       )   ->    Dict:
						SCREAMING_SNAKE_CASE__								=      len(get_test_nested_examples()       )
						with tempfile.TemporaryDirectory() as tmp_cache_dir:
									SCREAMING_SNAKE_CASE__								=      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"""       )}       )}       )       )
									SCREAMING_SNAKE_CASE__								=      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"""




# Copyright 2023 The HuggingFace Team. All rights reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
from typing import TYPE_CHECKING

# rely on isort to merge the imports
from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available, is_vision_available


A_							:			Dict											= {
    "configuration_efficientnet": [
        "EFFICIENTNET_PRETRAINED_CONFIG_ARCHIVE_MAP",
        "EfficientNetConfig",
        "EfficientNetOnnxConfig",
    ]
}

try:
						if not is_vision_available():
												raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
						pass
else:
						A_							:			List[Any]											= ["EfficientNetImageProcessor"]

try:
						if not is_torch_available():
												raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
						pass
else:
						A_							:			Dict											= [
						    "EFFICIENTNET_PRETRAINED_MODEL_ARCHIVE_LIST",
						    "EfficientNetForImageClassification",
						    "EfficientNetModel",
						    "EfficientNetPreTrainedModel",
						]

if TYPE_CHECKING:
						from .configuration_efficientnet import (
						    EFFICIENTNET_PRETRAINED_CONFIG_ARCHIVE_MAP,
						    EfficientNetConfig,
						    EfficientNetOnnxConfig,
						)

						try:
												if not is_vision_available():
																		raise OptionalDependencyNotAvailable()
						except OptionalDependencyNotAvailable:
												pass
						else:
												from .image_processing_efficientnet import EfficientNetImageProcessor

						try:
												if not is_torch_available():
																		raise OptionalDependencyNotAvailable()
						except OptionalDependencyNotAvailable:
												pass
						else:
												from .modeling_efficientnet import (
												    EFFICIENTNET_PRETRAINED_MODEL_ARCHIVE_LIST,
												    EfficientNetForImageClassification,
												    EfficientNetModel,
												    EfficientNetPreTrainedModel,
												)

else:
						import sys

						A_							:			List[Any]											= _LazyModule(__name__, globals()["__file__"], _import_structure)


