





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



    def 					__lowerCamelCase						(  self					):
     return datasets.DatasetInfo(
         features=datasets.Features({'content': datasets.Value('string'					)}					)     ,			supervised_keys=UpperCAmelCase_     ,			)



    def 					__lowerCamelCase						(  self     ,			__A     ,			__A					):
     return [datasets.SplitGenerator(name=datasets.Split.TRAIN     ,			gen_kwargs={'examples': get_test_dummy_examples()}					)]




    def 					__lowerCamelCase						(  self     ,			__A     ,			__A					):
     import apache_beam as beam

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






class UpperCAmelCase							(		datasets.BeamBasedBuilder							):



    def 					__lowerCamelCase						(  self					):
     return datasets.DatasetInfo(
         features=datasets.Features({'a': datasets.Sequence({'b': datasets.Value('string'					)}					)}					)     ,			supervised_keys=UpperCAmelCase_     ,			)



    def 					__lowerCamelCase						(  self     ,			__A     ,			__A					):
     return [
         datasets.SplitGenerator(name=datasets.Split.TRAIN     ,			gen_kwargs={'examples': get_test_nested_examples()}					)
     ]




    def 					__lowerCamelCase						(  self     ,			__A     ,			__A					):
     import apache_beam as beam

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







def _lowerCAmelCase     (      )->     Dict:
 return [(i, {"content": content}) for i, content in enumerate(['foo', 'bar', 'foobar']    )]







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






class UpperCAmelCase							(		snake_case__							):



    @require_beam
    def 					__lowerCamelCase						(  self					):
     __UpperCAmelCase     :   Union[str, Any]					=   len(get_test_dummy_examples()					)
     with tempfile.TemporaryDirectory() as tmp_cache_dir:
      __UpperCAmelCase     :   Union[str, 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'					)}					)					)
      __UpperCAmelCase     :   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_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 					__lowerCamelCase						(  self					):
     import apache_beam as beam

     __UpperCAmelCase     :   Any					=   beam.io.parquetio.WriteToParquet

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



     with tempfile.TemporaryDirectory() as tmp_cache_dir:
      __UpperCAmelCase     :   List[Any]					=   DummyBeamDataset(cache_dir=UpperCAmelCase_					)
      self.assertRaises(datasets.builder.MissingBeamOptions     ,			builder.download_and_prepare					)




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




from ...configuration_utils import PretrainedConfig
from ...utils import logging


_A:					Tuple							=				logging.get_logger(__name__)






class UpperCAmelCase							(		UpperCAmelCase_							):
    _A :			List[Any]						   =       """timm_backbone"""



    def __init__(  self     ,			__A=None     ,			__A=3     ,			__A=True     ,			__A=True     ,			__A=None     ,			**__A     ,			):
     super().__init__(**__A					)
     __UpperCAmelCase					=   backbone
     __UpperCAmelCase					=   num_channels
     __UpperCAmelCase					=   features_only
     __UpperCAmelCase					=   use_pretrained_backbone
     __UpperCAmelCase					=   True
     __UpperCAmelCase					=   out_indices if out_indices is not None else (-1,)





