



"""simple docstring"""






from collections import Counter
from pathlib import Path
from typing import Optional, Tuple

import yaml



class     UpperCAmelCase    (	yaml.SafeLoader  ):



   def    __UpperCAmelCase    (       self    :	Tuple							,       __lowerCamelCase    :	List[str]				):



     """simple docstring"""
     _snake_case   	=      [self.constructed_objects[key_node] for key_node, _ in node.value]
     _snake_case   	=      [tuple(__lowerCamelCase				) if isinstance(__lowerCamelCase							,       __lowerCamelCase				) else key for key in keys]
     _snake_case   	=      Counter(__lowerCamelCase				)
     _snake_case   	=      [key for key in counter if counter[key] > 1]
     if duplicate_keys:
       raise TypeError(f"""Got duplicate yaml keys: {duplicate_keys}"""				)





   def    __UpperCAmelCase    (       self    :	str							,       __lowerCamelCase    :	Any							,       __lowerCamelCase    :	Optional[Any]=False				):



     """simple docstring"""
     _snake_case   	=      super().construct_mapping(__lowerCamelCase							,       deep=__lowerCamelCase				)
     self._check_no_duplicates_on_constructed_node(__lowerCamelCase				)
     return mapping




def 			snake_case		(		lowerCAmelCase_	)						->				Tuple[Optional[str], str]:
  _snake_case   	=      list(readme_content.splitlines()	)
  if full_content and full_content[0] == "---" and "---" in full_content[1:]:
    _snake_case   	=      full_content[1:].index('''---'''	) + 1
    _snake_case   	=      '''\n'''.join(full_content[1:sep_idx]	)
    return yamlblock, "\n".join(full_content[sep_idx + 1 :]	)

  return None, "\n".join(lowerCAmelCase_	)



class     UpperCAmelCase    (	__SCREAMING_SNAKE_CASE  ):
   # class attributes
   A__		:	int           =  {'''train_eval_index'''}  # train-eval-index in the YAML metadata



   @classmethod
   def    __UpperCAmelCase    (       cls    :	str							,       __lowerCamelCase    :	Path				):



     """simple docstring"""
     with open(__lowerCamelCase							,       encoding='''utf-8'''				) as readme_file:
       _snake_case	,     _snake_case   	=      _split_yaml_from_readme(readme_file.read()				)
     if yaml_string is not None:
       return cls.from_yaml_string(__lowerCamelCase				)
     else:
       return cls()



   def    __UpperCAmelCase    (       self    :	List[Any]							,       __lowerCamelCase    :	Path				):



     """simple docstring"""
     if path.exists():
       with open(__lowerCamelCase							,       encoding='''utf-8'''				) as readme_file:
         _snake_case   	=      readme_file.read()
     else:
       _snake_case   	=      None
     _snake_case   	=      self._to_readme(__lowerCamelCase				)
     with open(__lowerCamelCase							,       '''w'''							,       encoding='''utf-8'''				) as readme_file:
       readme_file.write(__lowerCamelCase				)



   def    __UpperCAmelCase    (       self    :	Union[str, Any]							,       __lowerCamelCase    :	Optional[str] = None				):



     """simple docstring"""
     if readme_content is not None:
       _snake_case	,     _snake_case   	=      _split_yaml_from_readme(__lowerCamelCase				)
       _snake_case   	=      '''---\n''' + self.to_yaml_string() + '''---\n''' + content
     else:
       _snake_case   	=      '''---\n''' + self.to_yaml_string() + '''---\n'''
     return full_content



   @classmethod
   def    __UpperCAmelCase    (       cls    :	Tuple							,       __lowerCamelCase    :	str				):



     """simple docstring"""
     _snake_case   	=      yaml.load(__lowerCamelCase							,       Loader=_NoDuplicateSafeLoader				) or {}

     # Convert the YAML keys to DatasetMetadata fields
     _snake_case   	=      {
         (key.replace('''-'''							,       '''_'''				) if key.replace('''-'''							,       '''_'''				) in cls._FIELDS_WITH_DASHES else key): value
         for key, value in metadata_dict.items()
     }
     return cls(**__lowerCamelCase				)





   def    __UpperCAmelCase    (       self    :	Dict				):



     """simple docstring"""
     return yaml.safe_dump(
         {
             (key.replace('''_'''							,       '''-'''				) if key in self._FIELDS_WITH_DASHES else key): value
             for key, value in self.items()
         }							,       sort_keys=__lowerCamelCase							,       allow_unicode=__lowerCamelCase							,       encoding='''utf-8'''							,       ).decode('''utf-8'''				)

snake_case   					=				{
    '''image-classification''': [],
    '''translation''': [],
    '''image-segmentation''': [],
    '''fill-mask''': [],
    '''automatic-speech-recognition''': [],
    '''token-classification''': [],
    '''sentence-similarity''': [],
    '''audio-classification''': [],
    '''question-answering''': [],
    '''summarization''': [],
    '''zero-shot-classification''': [],
    '''table-to-text''': [],
    '''feature-extraction''': [],
    '''other''': [],
    '''multiple-choice''': [],
    '''text-classification''': [],
    '''text-to-image''': [],
    '''text2text-generation''': [],
    '''zero-shot-image-classification''': [],
    '''tabular-classification''': [],
    '''tabular-regression''': [],
    '''image-to-image''': [],
    '''tabular-to-text''': [],
    '''unconditional-image-generation''': [],
    '''text-retrieval''': [],
    '''text-to-speech''': [],
    '''object-detection''': [],
    '''audio-to-audio''': [],
    '''text-generation''': [],
    '''conversational''': [],
    '''table-question-answering''': [],
    '''visual-question-answering''': [],
    '''image-to-text''': [],
    '''reinforcement-learning''': [],
    '''voice-activity-detection''': [],
    '''time-series-forecasting''': [],
    '''document-question-answering''': [],
}


if __name__ == "__main__":
     from argparse import ArgumentParser

     snake_case   					=				ArgumentParser(usage='''Validate the yaml metadata block of a README.md file.''')
     ap.add_argument('''readme_filepath''')
     snake_case   					=				ap.parse_args()

     snake_case   					=				Path(args.readme_filepath)
     snake_case   					=				DatasetMetadata.from_readme(readme_filepath)
     print(dataset_metadata)
     dataset_metadata.to_readme(readme_filepath)







import inspect
import unittest
from typing import List

import numpy as np

from transformers import EfficientFormerConfig
from transformers.testing_utils import require_tf, require_vision, slow
from transformers.utils import cached_property, is_tf_available, is_vision_available

from ...test_configuration_common import ConfigTester
from ...test_modeling_tf_common import TFModelTesterMixin, floats_tensor, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_tf_available():
     import tensorflow as tf

     from transformers import (
         TFEfficientFormerForImageClassification,
         TFEfficientFormerForImageClassificationWithTeacher,
         TFEfficientFormerModel,
     )
     from transformers.models.efficientformer.modeling_tf_efficientformer import (
         TF_EFFICIENTFORMER_PRETRAINED_MODEL_ARCHIVE_LIST,
     )


if is_vision_available():
     from PIL import Image

     from transformers import EfficientFormerImageProcessor




class        _SCREAMING_SNAKE_CASE	:
      def __init__(      self		,						lowerCamelCase		,						lowerCamelCase = 13		,						lowerCamelCase = 64		,						lowerCamelCase = 2		,						lowerCamelCase = 3		,						lowerCamelCase = 3		,						lowerCamelCase = True		,						lowerCamelCase = True		,						lowerCamelCase = 1_28		,						lowerCamelCase=[16, 32, 64, 1_28]		,						lowerCamelCase = 7		,						lowerCamelCase = 4		,						lowerCamelCase = 37		,						lowerCamelCase = "gelu"		,						lowerCamelCase = 0.1		,						lowerCamelCase = 0.1		,						lowerCamelCase = 10		,						lowerCamelCase = 0.0_2		,						lowerCamelCase = 2		,						lowerCamelCase = 1		,						lowerCamelCase = 1_28		,						lowerCamelCase = [2, 2, 2, 2]		,						lowerCamelCase = 2		,						lowerCamelCase = 2		,						):
          snake_case__    =					parent
          snake_case__    =					batch_size
          snake_case__    =					image_size
          snake_case__    =					patch_size
          snake_case__    =					num_channels
          snake_case__    =					is_training
          snake_case__    =					use_labels
          snake_case__    =					hidden_size
          snake_case__    =					num_hidden_layers
          snake_case__    =					num_attention_heads
          snake_case__    =					intermediate_size
          snake_case__    =					hidden_act
          snake_case__    =					hidden_dropout_prob
          snake_case__    =					attention_probs_dropout_prob
          snake_case__    =					type_sequence_label_size
          snake_case__    =					initializer_range
          snake_case__    =					encoder_stride
          snake_case__    =					num_attention_outputs
          snake_case__    =					embed_dim
          snake_case__    =					embed_dim + 1
          snake_case__    =					resolution
          snake_case__    =					depths
          snake_case__    =					hidden_sizes
          snake_case__    =					dim
          snake_case__    =					mlp_expansion_ratio
      def A_      (      self			):
          snake_case__    =					floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]			)

          snake_case__    =					None
          if self.use_labels:
              snake_case__    =					ids_tensor([self.batch_size]		,						self.type_sequence_label_size			)

          snake_case__    =					self.get_config()

          return config, pixel_values, labels
      def A_      (      self			):
          return EfficientFormerConfig(
              image_size=self.image_size		,						patch_size=self.patch_size		,						num_channels=self.num_channels		,						hidden_size=self.hidden_size		,						num_hidden_layers=self.num_hidden_layers		,						num_attention_heads=self.num_attention_heads		,						intermediate_size=self.intermediate_size		,						hidden_act=self.hidden_act		,						hidden_dropout_prob=self.hidden_dropout_prob		,						attention_probs_dropout_prob=self.attention_probs_dropout_prob		,						is_decoder=lowerCamelCase		,						initializer_range=self.initializer_range		,						encoder_stride=self.encoder_stride		,						resolution=self.resolution		,						depths=self.depths		,						hidden_sizes=self.hidden_sizes		,						dim=self.dim		,						mlp_expansion_ratio=self.mlp_expansion_ratio		,						)
      def A_      (      self		,						lowerCamelCase		,						lowerCamelCase		,						lowerCamelCase			):
          snake_case__    =					TFEfficientFormerModel(config=lowerCamelCase			)
          snake_case__    =					model(lowerCamelCase		,						training=lowerCamelCase			)
          self.parent.assertEqual(result.last_hidden_state.shape		,						(self.batch_size, self.seq_length, self.hidden_size)			)
      def A_      (      self		,						lowerCamelCase		,						lowerCamelCase		,						lowerCamelCase			):
          snake_case__    =					self.type_sequence_label_size
          snake_case__    =					TFEfficientFormerForImageClassification(lowerCamelCase			)
          snake_case__    =					model(lowerCamelCase		,						labels=lowerCamelCase		,						training=lowerCamelCase			)
          self.parent.assertEqual(result.logits.shape		,						(self.batch_size, self.type_sequence_label_size)			)

          # test greyscale images
          snake_case__    =					1
          snake_case__    =					TFEfficientFormerForImageClassification(lowerCamelCase			)

          snake_case__    =					floats_tensor([self.batch_size, 1, self.image_size, self.image_size]			)
          snake_case__    =					model(lowerCamelCase		,						labels=lowerCamelCase			)
          self.parent.assertEqual(result.logits.shape		,						(self.batch_size, self.type_sequence_label_size)			)



      def A_      (      self			):
          snake_case__    =					self.prepare_config_and_inputs()
          snake_case__    ,       snake_case__    ,       snake_case__    =					config_and_inputs
          snake_case__    =					{"pixel_values": pixel_values}
          return config, inputs_dict





@require_tf
class        _SCREAMING_SNAKE_CASE	(   __UpperCamelCase							,       __UpperCamelCase							,       unittest.TestCase			):
      _A    :		str     						=  (
          (
              TFEfficientFormerModel,
              TFEfficientFormerForImageClassificationWithTeacher,
              TFEfficientFormerForImageClassification,
          )
          if is_tf_available()
          else ()
      )
      _A    :		List[str]     						=  (
          {
              'feature-extraction': TFEfficientFormerModel,
              'image-classification': (
                  TFEfficientFormerForImageClassification,
                  TFEfficientFormerForImageClassificationWithTeacher,
              ),
          }
          if is_tf_available()
          else {}
      )

      _A    :		Optional[Any]     						=  False

      _A    :		List[Any]     						=  False
      _A    :		Tuple     						=  False
      _A    :		List[Any]     						=  False
      _A    :		Any     						=  False
      def A_      (      self			):
          snake_case__    =					TFEfficientFormerModelTester(self			)
          snake_case__    =					ConfigTester(
              self		,						config_class=lowerCamelCase		,						has_text_modality=lowerCamelCase		,						hidden_size=37			)
      def A_      (      self			):
          self.config_tester.run_common_tests()
      @unittest.skip(reason="EfficientFormer does not use inputs_embeds"			)
      def A_      (      self			):
          pass
      @unittest.skip(reason="EfficientFormer does not support input and output embeddings"			)
      def A_      (      self			):
          pass
      def A_      (      self			):
          snake_case__    ,       snake_case__    =					self.model_tester.prepare_config_and_inputs_for_common()

          for model_class in self.all_model_classes:
              snake_case__    =					model_class(lowerCamelCase			)
              snake_case__    =					inspect.signature(model.call			)
              # signature.parameters is an OrderedDict => so arg_names order is deterministic
              snake_case__    =					[*signature.parameters.keys()]

              snake_case__    =					["pixel_values"]
              self.assertListEqual(arg_names[:1]		,						lowerCamelCase			)
      def A_      (      self			):
          def check_hidden_states_output(lowerCamelCase		,						lowerCamelCase		,						lowerCamelCase			):
              snake_case__    =					model_class(lowerCamelCase			)

              snake_case__    =					model(**self._prepare_for_class(lowerCamelCase		,						lowerCamelCase			)		,						training=lowerCamelCase			)
              snake_case__    =					outputs.encoder_hidden_states if config.is_encoder_decoder else outputs.hidden_states

              snake_case__    =					getattr(
                  self.model_tester		,						"expected_num_hidden_layers"		,						self.model_tester.num_hidden_layers + 1			)
              self.assertEqual(len(lowerCamelCase			)		,						lowerCamelCase			)

              if hasattr(self.model_tester		,						"encoder_seq_length"			):
                  snake_case__    =					self.model_tester.encoder_seq_length
                  if hasattr(self.model_tester		,						"chunk_length"			) and self.model_tester.chunk_length > 1:
                      snake_case__    =					seq_length * self.model_tester.chunk_length
              else:
                  snake_case__    =					self.model_tester.seq_length

              self.assertListEqual(
                  list(hidden_states[-1].shape[-2:]			)		,						[seq_length, self.model_tester.hidden_size]		,						)

              if config.is_encoder_decoder:
                  snake_case__    =					outputs.decoder_hidden_states

                  self.asseretIsInstance(lowerCamelCase		,						(list, tuple)			)
                  self.assertEqual(len(lowerCamelCase			)		,						lowerCamelCase			)
                  snake_case__    =					getattr(self.model_tester		,						"seq_length"		,						lowerCamelCase			)
                  snake_case__    =					getattr(self.model_tester		,						"decoder_seq_length"		,						lowerCamelCase			)

                  self.assertListEqual(
                      list(hidden_states[-1].shape[-2:]			)		,						[decoder_seq_length, self.model_tester.hidden_size]		,						)

          snake_case__    ,       snake_case__    =					self.model_tester.prepare_config_and_inputs_for_common()

          for model_class in self.all_model_classes:
              snake_case__    =					True
              check_hidden_states_output(lowerCamelCase		,						lowerCamelCase		,						lowerCamelCase			)

              # check that output_hidden_states also work using config
              del inputs_dict["output_hidden_states"]
              snake_case__    =					True

              check_hidden_states_output(lowerCamelCase		,						lowerCamelCase		,						lowerCamelCase			)
      def A_      (      self		,						lowerCamelCase		,						lowerCamelCase		,						lowerCamelCase=False			):
          snake_case__    =					super()._prepare_for_class(lowerCamelCase		,						lowerCamelCase		,						return_labels=lowerCamelCase			)

          if return_labels:
              if model_class.__name__ == "TFEfficientFormerForImageClassificationWithTeacher":
                  del inputs_dict["labels"]

          return inputs_dict
      def A_      (      self			):
          snake_case__    =					self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_model(*lowerCamelCase			)
      @unittest.skip(reason="EfficientFormer does not implement masked image modeling yet"			)
      def A_      (      self			):
          snake_case__    =					self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_for_masked_image_modeling(*lowerCamelCase			)
      def A_      (      self			):
          snake_case__    =					self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_for_image_classification(*lowerCamelCase			)
      @slow
      def A_      (      self			):
          for model_name in TF_EFFICIENTFORMER_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
              snake_case__    =					TFEfficientFormerModel.from_pretrained(lowerCamelCase			)
              self.assertIsNotNone(lowerCamelCase			)
      def A_      (      self			):
          snake_case__    ,       snake_case__    =					self.model_tester.prepare_config_and_inputs_for_common()
          snake_case__    =					True

          snake_case__    =					getattr(self.model_tester		,						"seq_length"		,						lowerCamelCase			)
          snake_case__    =					getattr(self.model_tester		,						"encoder_seq_length"		,						lowerCamelCase			)
          snake_case__    =					getattr(self.model_tester		,						"key_length"		,						lowerCamelCase			)
          snake_case__    =					getattr(self.model_tester		,						"chunk_length"		,						lowerCamelCase			)

          if chunk_length is not None and hasattr(self.model_tester		,						"num_hashes"			):
              snake_case__    =					encoder_seq_length * self.model_tester.num_hashes

          for model_class in self.all_model_classes:
              snake_case__    =					True
              snake_case__    =					False
              snake_case__    =					True
              snake_case__    =					model_class(lowerCamelCase			)

              snake_case__    =					model(**self._prepare_for_class(lowerCamelCase		,						lowerCamelCase			)		,						training=lowerCamelCase			)
              snake_case__    =					outputs.encoder_attentions if config.is_encoder_decoder else outputs.attentions
              self.assertEqual(len(lowerCamelCase			)		,						self.model_tester.num_attention_outputs			)

              # check that output_attentions also work using config
              del inputs_dict["output_attentions"]
              snake_case__    =					True
              snake_case__    =					model_class(lowerCamelCase			)
              snake_case__    =					model(**self._prepare_for_class(lowerCamelCase		,						lowerCamelCase			)		,						training=lowerCamelCase			)

              snake_case__    =					outputs.encoder_attentions if config.is_encoder_decoder else outputs.attentions
              self.assertEqual(len(lowerCamelCase			)		,						self.model_tester.num_attention_outputs			)

              if chunk_length is not None:
                  self.assertListEqual(
                      list(attentions[0].shape[-4:]			)		,						[self.model_tester.num_attention_heads, encoder_seq_length, chunk_length, encoder_key_length]		,						)
              else:
                  self.assertListEqual(
                      list(attentions[0].shape[-3:]			)		,						[self.model_tester.num_attention_heads, encoder_seq_length, encoder_key_length]		,						)



      def A_      (      self			):
          # We use a simplified version of this test for EfficientFormer because it requires training=False
          # and Keras refuses to let us force that during functional construction
          snake_case__    ,       snake_case__    =					self.model_tester.prepare_config_and_inputs_for_common()

          for model_class in self.all_model_classes:
              # Prepare our model
              snake_case__    =					model_class(lowerCamelCase			)
              # These are maximally general inputs for the model, with multiple None dimensions
              # Hopefully this will catch any conditionals that fail for flexible shapes
              snake_case__    =					{
                  key: tf.keras.Input(shape=val.shape[1:]		,						dtype=val.dtype		,						name=lowerCamelCase			)
                  for key, val in model.input_signature.items()
                  if key in model.dummy_inputs
              }
              snake_case__    =					model(lowerCamelCase			)
              self.assertTrue(outputs_dict is not None			)





def 						SCREAMING_SNAKE_CASE__     (   ):
    snake_case__    =					Image.open("./tests/fixtures/tests_samples/COCO/000000039769.png"				)
    return image





@require_tf
@require_vision
class        _SCREAMING_SNAKE_CASE	(   unittest.TestCase			):
      @cached_property
      def A_      (      self			):
          return (
              EfficientFormerImageProcessor.from_pretrained("snap-research/efficientformer-l1-300"			)
              if is_vision_available()
              else None
          )
      @slow
      def A_      (      self			):
          snake_case__    =					TFEfficientFormerForImageClassification.from_pretrained("snap-research/efficientformer-l1-300"			)
          snake_case__    =					self.default_image_processor
          snake_case__    =					prepare_img()
          snake_case__    =					image_processor(images=lowerCamelCase		,						return_tensors="tf"			)
          # forward pass
          snake_case__    =					model(**lowerCamelCase		,						training=lowerCamelCase			)
          # verify the logits
          snake_case__    =					tf.TensorShape((1, 10_00)			)
          self.assertEqual(outputs.logits.shape		,						lowerCamelCase			)
          snake_case__    =					tf.constant([-0.0_5_5_5, 0.4_8_2_5, -0.0_8_5_2]			)
          self.assertTrue(np.allclose(outputs.logits[0, :3]		,						lowerCamelCase		,						atol=1e-4			)			)



      @slow
      def A_      (      self			):
          snake_case__    =					TFEfficientFormerForImageClassificationWithTeacher.from_pretrained(
              "snap-research/efficientformer-l1-300"			)
          snake_case__    =					self.default_image_processor
          snake_case__    =					prepare_img()
          snake_case__    =					image_processor(images=lowerCamelCase		,						return_tensors="tf"			)
          # forward pass
          snake_case__    =					model(**lowerCamelCase		,						training=lowerCamelCase			)
          # verify the logits
          snake_case__    =					tf.TensorShape((1, 10_00)			)
          self.assertEqual(outputs.logits.shape		,						lowerCamelCase			)
          snake_case__    =					tf.constant([-0.1_3_1_2, 0.4_3_5_3, -1.0_4_9_9]			)
          self.assertTrue(np.allclose(outputs.logits[0, :3]		,						lowerCamelCase		,						atol=1e-4			)			)



