





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





					"""simple docstring"""


					def __init__( self	,  _lowerCAmelCase	,  _lowerCAmelCase = 13	,  _lowerCAmelCase = 64	,  _lowerCAmelCase = 2	,  _lowerCAmelCase = 3	,  _lowerCAmelCase = 3	,  _lowerCAmelCase = True	,  _lowerCAmelCase = True	,  _lowerCAmelCase = 128	,  _lowerCAmelCase=[16, 32, 64, 128]	,  _lowerCAmelCase = 7	,  _lowerCAmelCase = 4	,  _lowerCAmelCase = 37	,  _lowerCAmelCase = "gelu"	,  _lowerCAmelCase = 0.1	,  _lowerCAmelCase = 0.1	,  _lowerCAmelCase = 10	,  _lowerCAmelCase = 0.02	,  _lowerCAmelCase = 2	,  _lowerCAmelCase = 1	,  _lowerCAmelCase = 128	,  _lowerCAmelCase = [2, 2, 2, 2]	,  _lowerCAmelCase = 2	,  _lowerCAmelCase = 2	,  ):
										lowerCamelCase__       =       parent
										lowerCamelCase__       =       batch_size
										lowerCamelCase__       =       image_size
										lowerCamelCase__       =       patch_size
										lowerCamelCase__       =       num_channels
										lowerCamelCase__       =       is_training
										lowerCamelCase__       =       use_labels
										lowerCamelCase__       =       hidden_size
										lowerCamelCase__       =       num_hidden_layers
										lowerCamelCase__       =       num_attention_heads
										lowerCamelCase__       =       intermediate_size
										lowerCamelCase__       =       hidden_act
										lowerCamelCase__       =       hidden_dropout_prob
										lowerCamelCase__       =       attention_probs_dropout_prob
										lowerCamelCase__       =       type_sequence_label_size
										lowerCamelCase__       =       initializer_range
										lowerCamelCase__       =       encoder_stride
										lowerCamelCase__       =       num_attention_outputs
										lowerCamelCase__       =       embed_dim
										lowerCamelCase__       =       embed_dim + 1
										lowerCamelCase__       =       resolution
										lowerCamelCase__       =       depths
										lowerCamelCase__       =       hidden_sizes
										lowerCamelCase__       =       dim
										lowerCamelCase__       =       mlp_expansion_ratio





					def 					__magic_name__ ( self	):
										lowerCamelCase__       =       floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]	)

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

										lowerCamelCase__       =       self.get_config()

										return config, pixel_values, labels





					def 					__magic_name__ ( 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=__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 					__magic_name__ ( self	,  _lowerCAmelCase	,  _lowerCAmelCase	,  _lowerCAmelCase	):
										lowerCamelCase__       =       TFEfficientFormerModel(config=__a	)
										lowerCamelCase__       =       model(__a	,  training=__a	)
										self.parent.assertEqual(result.last_hidden_state.shape	,  (self.batch_size, self.seq_length, self.hidden_size)	)





					def 					__magic_name__ ( self	,  _lowerCAmelCase	,  _lowerCAmelCase	,  _lowerCAmelCase	):
										lowerCamelCase__       =       self.type_sequence_label_size
										lowerCamelCase__       =       TFEfficientFormerForImageClassification(__a	)
										lowerCamelCase__       =       model(__a	,  labels=__a	,  training=__a	)
										self.parent.assertEqual(result.logits.shape	,  (self.batch_size, self.type_sequence_label_size)	)

										# test greyscale images
										lowerCamelCase__       =       1
										lowerCamelCase__       =       TFEfficientFormerForImageClassification(__a	)

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






					def 					__magic_name__ ( self	):
										lowerCamelCase__       =       self.prepare_config_and_inputs()
										lowerCamelCase__       =       config_and_inputs
										lowerCamelCase__       =       {'pixel_values': pixel_values}
										return config, inputs_dict

@require_tf
class SCREAMING_SNAKE_CASE_ (					UpperCamelCase_							,       UpperCamelCase_							,       unittest.TestCase   ):





					"""simple docstring"""


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

					A__				 =    False

					A__				 =    False
					A__				 =    False
					A__				 =    False
					A__				 =    False





					def 					__magic_name__ ( self	):
										lowerCamelCase__       =       TFEfficientFormerModelTester(self	)
										lowerCamelCase__       =       ConfigTester(
										    self	,  config_class=__a	,  has_text_modality=__a	,  hidden_size=37	)





					def 					__magic_name__ ( self	):
										self.config_tester.run_common_tests()





					@unittest.skip(reason="EfficientFormer does not use inputs_embeds"	)
					def 					__magic_name__ ( self	):
										pass





					@unittest.skip(reason="EfficientFormer does not support input and output embeddings"	)
					def 					__magic_name__ ( self	):
										pass





					def 					__magic_name__ ( self	):
										lowerCamelCase__       =       self.model_tester.prepare_config_and_inputs_for_common()

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

															lowerCamelCase__       =       ['pixel_values']
															self.assertListEqual(arg_names[:1]	,  __a	)





					def 					__magic_name__ ( self	):






										def check_hidden_states_output(_lowerCAmelCase	,  _lowerCAmelCase	,  _lowerCAmelCase	):
															lowerCamelCase__       =       model_class(__a	)

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

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

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

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

										lowerCamelCase__       =       self.model_tester.prepare_config_and_inputs_for_common()

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

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

															check_hidden_states_output(__a	,  __a	,  __a	)





					def 					__magic_name__ ( self	,  _lowerCAmelCase	,  _lowerCAmelCase	,  _lowerCAmelCase=False	):
										lowerCamelCase__       =       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 					__magic_name__ ( self	):
										lowerCamelCase__       =       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 					__magic_name__ ( self	):
										lowerCamelCase__       =       self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_for_masked_image_modeling(*__a	)





					def 					__magic_name__ ( self	):
										lowerCamelCase__       =       self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_for_image_classification(*__a	)





					@slow
					def 					__magic_name__ ( self	):






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





					def 					__magic_name__ ( self	):
										lowerCamelCase__       =       self.model_tester.prepare_config_and_inputs_for_common()
										lowerCamelCase__       =       True

										lowerCamelCase__       =       getattr(self.model_tester	,  "seq_length"	,  __a	)
										lowerCamelCase__       =       getattr(self.model_tester	,  "encoder_seq_length"	,  __a	)
										lowerCamelCase__       =       getattr(self.model_tester	,  "key_length"	,  __a	)
										lowerCamelCase__       =       getattr(self.model_tester	,  "chunk_length"	,  __a	)

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

										for model_class in self.all_model_classes:
															lowerCamelCase__       =       True
															lowerCamelCase__       =       False
															lowerCamelCase__       =       True
															lowerCamelCase__       =       model_class(__a	)

															lowerCamelCase__       =       model(**self._prepare_for_class(__a	,  __a	)	,  training=__a	)
															lowerCamelCase__       =       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"]
															lowerCamelCase__       =       True
															lowerCamelCase__       =       model_class(__a	)
															lowerCamelCase__       =       model(**self._prepare_for_class(__a	,  __a	)	,  training=__a	)

															lowerCamelCase__       =       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 					__magic_name__ ( self	):
										lowerCamelCase__       =       self.model_tester.prepare_config_and_inputs_for_common()

										for model_class in self.all_model_classes:
															# Prepare our model
															lowerCamelCase__       =       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
															lowerCamelCase__       =       {
															    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
															}
															lowerCamelCase__       =       model(__a	)
															self.assertTrue(outputs_dict is not None	)





def    __UpperCamelCase      (    ) ->int:
					lowerCamelCase__       =       Image.open("./tests/fixtures/tests_samples/COCO/000000039769.png")
					return image







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





					"""simple docstring"""


					@cached_property
					def 					__magic_name__ ( self	):
										return (
										    EfficientFormerImageProcessor.from_pretrained("snap-research/efficientformer-l1-300"	)
										    if is_vision_available()
										    else None
										)





					@slow
					def 					__magic_name__ ( self	):
										lowerCamelCase__       =       TFEfficientFormerForImageClassification.from_pretrained("snap-research/efficientformer-l1-300"	)
										lowerCamelCase__       =       self.default_image_processor
										lowerCamelCase__       =       prepare_img()
										lowerCamelCase__       =       image_processor(images=__a	,  return_tensors="tf"	)
										# forward pass
										lowerCamelCase__       =       model(**__a	,  training=__a	)
										# verify the logits
										lowerCamelCase__       =       tf.TensorShape((1, 1000)	)
										self.assertEqual(outputs.logits.shape	,  __a	)
										lowerCamelCase__       =       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 					__magic_name__ ( self	):
										lowerCamelCase__       =       TFEfficientFormerForImageClassificationWithTeacher.from_pretrained(
										    "snap-research/efficientformer-l1-300"	)
										lowerCamelCase__       =       self.default_image_processor
										lowerCamelCase__       =       prepare_img()
										lowerCamelCase__       =       image_processor(images=__a	,  return_tensors="tf"	)
										# forward pass
										lowerCamelCase__       =       model(**__a	,  training=__a	)
										# verify the logits
										lowerCamelCase__       =       tf.TensorShape((1, 1000)	)
										self.assertEqual(outputs.logits.shape	,  __a	)
										lowerCamelCase__       =       tf.constant([-0.1_312, 0.4_353, -1.0_499]	)
										self.assertTrue(np.allclose(outputs.logits[0, :3]	,  __a	,  atol=1E-4	)	)












import unittest

from transformers import load_tool

from .test_tools_common import ToolTesterMixin

class SCREAMING_SNAKE_CASE_ (					unittest.TestCase							,       lowercase_   ):





					"""simple docstring"""


					def 					__magic_name__ ( self	):
										lowerCamelCase__       =       load_tool("text-classification"	)
										self.tool.setup()
										lowerCamelCase__       =       load_tool("text-classification"	,  remote=_lowerCAmelCase	)





					def 					__magic_name__ ( self	):
										lowerCamelCase__       =       self.tool("That's quite cool"	,  ["positive", "negative"]	)
										self.assertEqual(_lowerCAmelCase	,  "positive"	)





					def 					__magic_name__ ( self	):
										lowerCamelCase__       =       self.remote_tool("That's quite cool"	,  ["positive", "negative"]	)
										self.assertEqual(_lowerCAmelCase	,  "positive"	)





					def 					__magic_name__ ( self	):
										lowerCamelCase__       =       self.tool(text="That's quite cool"	,  labels=["positive", "negative"]	)
										self.assertEqual(_lowerCAmelCase	,  "positive"	)






					def 					__magic_name__ ( self	):
										lowerCamelCase__       =       self.remote_tool(text="That's quite cool"	,  labels=["positive", "negative"]	)
										self.assertEqual(_lowerCAmelCase	,  "positive"	)

