




"""simple docstring"""


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 					lowercase:







 '''simple docstring'''





 def __init__(				self:		str,      a_:		List[str],      a_:		int = 13,      a_:		int = 64,      a_:		int = 2,      a_:		int = 3,      a_:		int = 3,      a_:		bool = True,      a_:		bool = True,      a_:		int = 128,      a_:		Optional[Any]=[16, 32, 64, 128],      a_:		int = 7,      a_:		int = 4,      a_:		int = 37,      a_:		str = "gelu",      a_:		float = 0.1,      a_:		float = 0.1,      a_:		int = 10,      a_:		float = 0.02,      a_:		int = 2,      a_:		int = 1,      a_:		int = 128,      a_:		List[int] = [2, 2, 2, 2],      a_:		int = 2,      a_:		int = 2,      ):




   '''simple docstring'''



   _snake_case							:		Optional[int]								=  parent
   _snake_case							:		Tuple								=  batch_size
   _snake_case							:		List[str]								=  image_size
   _snake_case							:		List[Any]								=  patch_size
   _snake_case							:		str								=  num_channels
   _snake_case							:		Dict								=  is_training
   _snake_case							:		Optional[int]								=  use_labels
   _snake_case							:		Union[str, Any]								=  hidden_size
   _snake_case							:		Optional[Any]								=  num_hidden_layers
   _snake_case							:		int								=  num_attention_heads
   _snake_case							:		int								=  intermediate_size
   _snake_case							:		List[Any]								=  hidden_act
   _snake_case							:		Optional[int]								=  hidden_dropout_prob
   _snake_case							:		Union[str, Any]								=  attention_probs_dropout_prob
   _snake_case							:		Union[str, Any]								=  type_sequence_label_size
   _snake_case							:		Optional[Any]								=  initializer_range
   _snake_case							:		List[Any]								=  encoder_stride
   _snake_case							:		str								=  num_attention_outputs
   _snake_case							:		Tuple								=  embed_dim
   _snake_case							:		Tuple								=  embed_dim + 1
   _snake_case							:		List[str]								=  resolution
   _snake_case							:		Optional[Any]								=  depths
   _snake_case							:		Dict								=  hidden_sizes
   _snake_case							:		Union[str, Any]								=  dim
   _snake_case							:		str								=  mlp_expansion_ratio


 def  UpperCamelCase_   (				self:		int		):




   '''simple docstring'''



   _snake_case							:		str								=  floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]		)

   _snake_case							:		Optional[int]								=  None
   if self.use_labels:
     _snake_case							:		Dict								=  ids_tensor([self.batch_size],      self.type_sequence_label_size		)

   _snake_case							:		List[Any]								=  self.get_config()

   return config, pixel_values, labels


 def  UpperCamelCase_   (				self:		List[str]		):




   '''simple docstring'''



   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=__a,      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  UpperCamelCase_   (				self:		Union[str, Any],      a_:		Optional[Any],      a_:		int,      a_:		int		):




   '''simple docstring'''



   _snake_case							:		List[Any]								=  TFEfficientFormerModel(config=__a		)
   _snake_case							:		Optional[int]								=  model(__a,      training=__a		)
   self.parent.assertEqual(result.last_hidden_state.shape,      (self.batch_size, self.seq_length, self.hidden_size)		)


 def  UpperCamelCase_   (				self:		Optional[Any],      a_:		Tuple,      a_:		Tuple,      a_:		Tuple		):




   '''simple docstring'''



   _snake_case							:		List[Any]								=  self.type_sequence_label_size
   _snake_case							:		Optional[Any]								=  TFEfficientFormerForImageClassification(__a		)
   _snake_case							:		Union[str, Any]								=  model(__a,      labels=__a,      training=__a		)
   self.parent.assertEqual(result.logits.shape,      (self.batch_size, self.type_sequence_label_size)		)

   # test greyscale images
   _snake_case							:		Optional[Any]								=  1
   _snake_case							:		int								=  TFEfficientFormerForImageClassification(__a		)

   _snake_case							:		List[str]								=  floats_tensor([self.batch_size, 1, self.image_size, self.image_size]		)
   _snake_case							:		int								=  model(__a,      labels=__a		)
   self.parent.assertEqual(result.logits.shape,      (self.batch_size, self.type_sequence_label_size)		)


 def  UpperCamelCase_   (				self:		Optional[int]		):




   '''simple docstring'''



   _snake_case							:		Tuple								=  self.prepare_config_and_inputs()
   _snake_case							:		Union[str, Any]								=  config_and_inputs
   _snake_case							:		Any								=  {"""pixel_values""": pixel_values}
   return config, inputs_dict







@require_tf
class 					lowercase(     __a       ,			__a       ,			unittest.TestCase ):







 '''simple docstring'''





 lowercase__ 					=					(
     (
         TFEfficientFormerModel,
         TFEfficientFormerForImageClassificationWithTeacher,
         TFEfficientFormerForImageClassification,
     )
     if is_tf_available()
     else ()
 )
 lowercase__ 					=					(
     {
         '''feature-extraction''': TFEfficientFormerModel,
         '''image-classification''': (
             TFEfficientFormerForImageClassification,
             TFEfficientFormerForImageClassificationWithTeacher,
         ),
     }
     if is_tf_available()
     else {}
 )

 lowercase__ 					=					False

 lowercase__ 					=					False
 lowercase__ 					=					False
 lowercase__ 					=					False
 lowercase__ 					=					False


 def  UpperCamelCase_   (				self:		List[str]		):




   '''simple docstring'''



   _snake_case							:		Optional[int]								=  TFEfficientFormerModelTester(self		)
   _snake_case							:		str								=  ConfigTester(
       self,      config_class=__a,      has_text_modality=__a,      hidden_size=37		)


 def  UpperCamelCase_   (				self:		List[str]		):




   '''simple docstring'''



   self.config_tester.run_common_tests()


 @unittest.skip(reason="""EfficientFormer does not use inputs_embeds"""		)
 def  UpperCamelCase_   (				self:		List[str]		):




   '''simple docstring'''



   pass


 @unittest.skip(reason="""EfficientFormer does not support input and output embeddings"""		)
 def  UpperCamelCase_   (				self:		List[Any]		):




   '''simple docstring'''



   pass


 def  UpperCamelCase_   (				self:		Optional[Any]		):




   '''simple docstring'''



   _snake_case							:		str								=  self.model_tester.prepare_config_and_inputs_for_common()

   for model_class in self.all_model_classes:
     _snake_case							:		Optional[int]								=  model_class(__a		)
     _snake_case							:		List[Any]								=  inspect.signature(model.call		)
     # signature.parameters is an OrderedDict => so arg_names order is deterministic
     _snake_case							:		str								=  [*signature.parameters.keys()]

     _snake_case							:		int								=  ["""pixel_values"""]
     self.assertListEqual(arg_names[:1],      __a		)


 def  UpperCamelCase_   (				self:		List[Any]		):




   '''simple docstring'''



   def check_hidden_states_output(a_:		Any,      a_:		str,      a_:		Any		):
     _snake_case							:		Dict								=  model_class(__a		)

     _snake_case							:		Tuple								=  model(**self._prepare_for_class(__a,      __a		),      training=__a		)
     _snake_case							:		int								=  outputs.encoder_hidden_states if config.is_encoder_decoder else outputs.hidden_states

     _snake_case							:		Dict								=  getattr(
         self.model_tester,      """expected_num_hidden_layers""",      self.model_tester.num_hidden_layers + 1		)
     self.assertEqual(len(__a		),      __a		)

     if hasattr(self.model_tester,      """encoder_seq_length"""		):
       _snake_case							:		Union[str, Any]								=  self.model_tester.encoder_seq_length
       if hasattr(self.model_tester,      """chunk_length"""		) and self.model_tester.chunk_length > 1:
         _snake_case							:		str								=  seq_length * self.model_tester.chunk_length
     else:
       _snake_case							:		Union[str, Any]								=  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							:		Union[str, Any]								=  outputs.decoder_hidden_states

       self.asseretIsInstance(__a,      (list, tuple)		)
       self.assertEqual(len(__a		),      __a		)
       _snake_case							:		List[str]								=  getattr(self.model_tester,      """seq_length""",      __a		)
       _snake_case							:		Tuple								=  getattr(self.model_tester,      """decoder_seq_length""",      __a		)

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

   _snake_case							:		Any								=  self.model_tester.prepare_config_and_inputs_for_common()

   for model_class in self.all_model_classes:
     _snake_case							:		int								=  True
     check_hidden_states_output(__a,      __a,      __a		)

     # check that output_hidden_states also work using config
     del inputs_dict["output_hidden_states"]
     _snake_case							:		Optional[Any]								=  True

     check_hidden_states_output(__a,      __a,      __a		)


 def  UpperCamelCase_   (				self:		Any,      a_:		Optional[int],      a_:		List[Any],      a_:		Optional[int]=False		):




   '''simple docstring'''



   _snake_case							:		Any								=  super()._prepare_for_class(__a,      __a,      return_labels=__a		)

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

   return inputs_dict


 def  UpperCamelCase_   (				self:		str		):




   '''simple docstring'''



   _snake_case							:		Optional[int]								=  self.model_tester.prepare_config_and_inputs()
   self.model_tester.create_and_check_model(*__a		)


 @unittest.skip(reason="""EfficientFormer does not implement masked image modeling yet"""		)
 def  UpperCamelCase_   (				self:		Tuple		):




   '''simple docstring'''



   _snake_case							:		Tuple								=  self.model_tester.prepare_config_and_inputs()
   self.model_tester.create_and_check_for_masked_image_modeling(*__a		)


 def  UpperCamelCase_   (				self:		int		):




   '''simple docstring'''



   _snake_case							:		List[str]								=  self.model_tester.prepare_config_and_inputs()
   self.model_tester.create_and_check_for_image_classification(*__a		)


 @slow
 def  UpperCamelCase_   (				self:		Any		):




   '''simple docstring'''



   for model_name in TF_EFFICIENTFORMER_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
     _snake_case							:		Any								=  TFEfficientFormerModel.from_pretrained(__a		)
     self.assertIsNotNone(__a		)


 def  UpperCamelCase_   (				self:		Dict		):




   '''simple docstring'''



   _snake_case							:		List[Any]								=  self.model_tester.prepare_config_and_inputs_for_common()
   _snake_case							:		int								=  True

   _snake_case							:		Optional[int]								=  getattr(self.model_tester,      """seq_length""",      __a		)
   _snake_case							:		List[Any]								=  getattr(self.model_tester,      """encoder_seq_length""",      __a		)
   _snake_case							:		str								=  getattr(self.model_tester,      """key_length""",      __a		)
   _snake_case							:		Any								=  getattr(self.model_tester,      """chunk_length""",      __a		)

   if chunk_length is not None and hasattr(self.model_tester,      """num_hashes"""		):
     _snake_case							:		Optional[int]								=  encoder_seq_length * self.model_tester.num_hashes

   for model_class in self.all_model_classes:
     _snake_case							:		Union[str, Any]								=  True
     _snake_case							:		Tuple								=  False
     _snake_case							:		List[str]								=  True
     _snake_case							:		int								=  model_class(__a		)

     _snake_case							:		str								=  model(**self._prepare_for_class(__a,      __a		),      training=__a		)
     _snake_case							:		Union[str, Any]								=  outputs.encoder_attentions if config.is_encoder_decoder else outputs.attentions
     self.assertEqual(len(__a		),      self.model_tester.num_attention_outputs		)

     # check that output_attentions also work using config
     del inputs_dict["output_attentions"]
     _snake_case							:		str								=  True
     _snake_case							:		Any								=  model_class(__a		)
     _snake_case							:		List[str]								=  model(**self._prepare_for_class(__a,      __a		),      training=__a		)

     _snake_case							:		Optional[Any]								=  outputs.encoder_attentions if config.is_encoder_decoder else outputs.attentions
     self.assertEqual(len(__a		),      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  UpperCamelCase_   (				self:		Optional[int]		):




   '''simple docstring'''



   _snake_case							:		Union[str, Any]								=  self.model_tester.prepare_config_and_inputs_for_common()

   for model_class in self.all_model_classes:
     # Prepare our model
     _snake_case							:		List[str]								=  model_class(__a		)
     # 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							:		List[str]								=  {
         key: tf.keras.Input(shape=val.shape[1:],      dtype=val.dtype,      name=__a		)
         for key, val in model.input_signature.items()
         if key in model.dummy_inputs
     }
     _snake_case							:		List[str]								=  model(__a		)
     self.assertTrue(outputs_dict is not None		)







def 					UpperCAmelCase__       ():
  """simple docstring"""

  _snake_case							:		Optional[int]								=  Image.open("""./tests/fixtures/tests_samples/COCO/000000039769.png"""    )
  return image






@require_tf
@require_vision
class 					lowercase(     unittest.TestCase ):







 '''simple docstring'''





 @cached_property
 def  UpperCamelCase_   (				self:		int		):




   '''simple docstring'''



   return (
       EfficientFormerImageProcessor.from_pretrained("""snap-research/efficientformer-l1-300"""		)
       if is_vision_available()
       else None
   )


 @slow
 def  UpperCamelCase_   (				self:		str		):




   '''simple docstring'''



   _snake_case							:		int								=  TFEfficientFormerForImageClassification.from_pretrained("""snap-research/efficientformer-l1-300"""		)
   _snake_case							:		Optional[Any]								=  self.default_image_processor
   _snake_case							:		Optional[int]								=  prepare_img()
   _snake_case							:		List[str]								=  image_processor(images=__a,      return_tensors="""tf"""		)
   # forward pass
   _snake_case							:		int								=  model(**__a,      training=__a		)
   # verify the logits
   _snake_case							:		Union[str, Any]								=  tf.TensorShape((1, 1_000)		)
   self.assertEqual(outputs.logits.shape,      __a		)
   _snake_case							:		Optional[Any]								=  tf.constant([-0.0_555, 0.4_825, -0.0_852]		)
   self.assertTrue(np.allclose(outputs.logits[0, :3],      __a,      atol=1E-4		)		)


 @slow
 def  UpperCamelCase_   (				self:		Any		):




   '''simple docstring'''



   _snake_case							:		Dict								=  TFEfficientFormerForImageClassificationWithTeacher.from_pretrained(
       """snap-research/efficientformer-l1-300"""		)
   _snake_case							:		Optional[int]								=  self.default_image_processor
   _snake_case							:		List[Any]								=  prepare_img()
   _snake_case							:		Any								=  image_processor(images=__a,      return_tensors="""tf"""		)
   # forward pass
   _snake_case							:		List[str]								=  model(**__a,      training=__a		)
   # verify the logits
   _snake_case							:		Any								=  tf.TensorShape((1, 1_000)		)
   self.assertEqual(outputs.logits.shape,      __a		)
   _snake_case							:		List[str]								=  tf.constant([-0.1_312, 0.4_353, -1.0_499]		)
   self.assertTrue(np.allclose(outputs.logits[0, :3],      __a,      atol=1E-4		)		)










from itertools import permutations
def 					snake_case_						(   lowerCAmelCase_				:  tuple					):
							if num[3] % 2 != 0:
														return False

							if (num[2] + num[3] + num[4]) % 3 != 0:
														return False

							if num[5] % 5 != 0:
														return False

							__lowercase					:							Dict			=   [7, 11, 13, 17]
							for i, test in enumerate(lowerCAmelCase_					):
														if (num[i + 4] * 100 + num[i + 5] * 10 + num[i + 6]) % test != 0:
																					return False
							return True
def 					snake_case_						(   lowerCAmelCase_				:  int = 10					):
							return sum(
							    int("""""".join(map(lowerCAmelCase_				,				lowerCAmelCase_					)					)					)
							    for num in permutations(range(lowerCAmelCase_					)					)
							    if is_substring_divisible(lowerCAmelCase_					)					)


if __name__ == "__main__":
	print(f'''{solution() = }''')