




from __future__ import annotations

import inspect
import unittest

import numpy as np

from transformers import ResNetConfig
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 TFResNetForImageClassification, TFResNetModel
				from transformers.models.resnet.modeling_tf_resnet import TF_RESNET_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
				from PIL import Image

				from transformers import AutoImageProcessor






class 						__a :



	def __init__(						self							:    List[Any]				,	snake_case_							:    int				,	snake_case_							:    Dict=3				,	snake_case_							:    List[str]=32				,	snake_case_							:    Any=3				,	snake_case_							:    List[str]=10				,	snake_case_							:    Union[str, Any]=[10, 20, 30, 40]				,	snake_case_							:    Optional[int]=[1, 1, 2, 1]				,	snake_case_							:    Union[str, Any]=True				,	snake_case_							:    Any=True				,	snake_case_							:    Optional[Any]="relu"				,	snake_case_							:    Dict=3				,	snake_case_							:    List[str]=None				,	)->							Union[str, Any]:
						__lowerCAmelCase	   =parent
						__lowerCAmelCase	   =batch_size
						__lowerCAmelCase	   =image_size
						__lowerCAmelCase	   =num_channels
						__lowerCAmelCase	   =embeddings_size
						__lowerCAmelCase	   =hidden_sizes
						__lowerCAmelCase	   =depths
						__lowerCAmelCase	   =is_training
						__lowerCAmelCase	   =use_labels
						__lowerCAmelCase	   =hidden_act
						__lowerCAmelCase	   =num_labels
						__lowerCAmelCase	   =scope
						__lowerCAmelCase	   =len(snake_case_)



	def 		UpperCamelCase							(						self							:    str)->							Optional[Any]:
						__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.num_labels)

						__lowerCAmelCase	   =self.get_config()

						return config, pixel_values, labels



	def 		UpperCamelCase							(						self							:    List[Any])->							Dict:
						return ResNetConfig(
						    num_channels=self.num_channels				,	embeddings_size=self.embeddings_size				,	hidden_sizes=self.hidden_sizes				,	depths=self.depths				,	hidden_act=self.hidden_act				,	num_labels=self.num_labels				,	image_size=self.image_size				,	)



	def 		UpperCamelCase							(						self							:    Dict				,	snake_case_							:    Any				,	snake_case_							:    Optional[Any]				,	snake_case_							:    Optional[Any])->							Any:
						__lowerCAmelCase	   =TFResNetModel(config=snake_case_)
						__lowerCAmelCase	   =model(snake_case_)
						# expected last hidden states: B, C, H // 32, W // 32
						self.parent.assertEqual(
						    result.last_hidden_state.shape				,	(self.batch_size, self.hidden_sizes[-1], self.image_size // 32, self.image_size // 32)				,	)



	def 		UpperCamelCase							(						self							:    List[str]				,	snake_case_							:    Optional[Any]				,	snake_case_							:    Dict				,	snake_case_							:    Union[str, Any])->							List[Any]:
						__lowerCAmelCase	   =self.num_labels
						__lowerCAmelCase	   =TFResNetForImageClassification(snake_case_)
						__lowerCAmelCase	   =model(snake_case_				,	labels=snake_case_)
						self.parent.assertEqual(result.logits.shape				,	(self.batch_size, self.num_labels))



	def 		UpperCamelCase							(						self							:    Tuple)->							Union[str, Any]:
						__lowerCAmelCase	   =self.prepare_config_and_inputs()
						__lowerCAmelCase	   =config_and_inputs
						__lowerCAmelCase	   ={"pixel_values": pixel_values}
						return config, inputs_dict






@require_tf
class 						__a (     __lowercase	,    __lowercase	,    unittest.TestCase				):
	SCREAMING_SNAKE_CASE       =       (TFResNetModel, TFResNetForImageClassification) if is_tf_available() else ()
	SCREAMING_SNAKE_CASE       =       (
	    {"feature-extraction": TFResNetModel, "image-classification": TFResNetForImageClassification}
	    if is_tf_available()
	    else {}
	)

	SCREAMING_SNAKE_CASE       =       False
	SCREAMING_SNAKE_CASE       =       False
	SCREAMING_SNAKE_CASE       =       False
	SCREAMING_SNAKE_CASE       =       False
	SCREAMING_SNAKE_CASE       =       False



	def 		UpperCamelCase							(						self							:    Tuple)->							Union[str, Any]:
						__lowerCAmelCase	   =TFResNetModelTester(self)
						__lowerCAmelCase	   =ConfigTester(self				,	config_class=snake_case_				,	has_text_modality=snake_case_)



	def 		UpperCamelCase							(						self							:    Tuple)->							Any:
						self.create_and_test_config_common_properties()
						self.config_tester.create_and_test_config_to_json_string()
						self.config_tester.create_and_test_config_to_json_file()
						self.config_tester.create_and_test_config_from_and_save_pretrained()
						self.config_tester.create_and_test_config_with_num_labels()
						self.config_tester.check_config_can_be_init_without_params()
						self.config_tester.check_config_arguments_init()



	def 		UpperCamelCase							(						self							:    Tuple)->							List[str]:
						return



	@unittest.skip(reason="""ResNet does not use inputs_embeds""")
	def 		UpperCamelCase							(						self							:    Union[str, Any])->							Optional[Any]:
						pass



	@unittest.skip(reason="""ResNet does not support input and output embeddings""")
	def 		UpperCamelCase							(						self							:    str)->							Tuple:
						pass



	def 		UpperCamelCase							(						self							:    List[Any])->							Optional[int]:
						__lowerCAmelCase	   =self.model_tester.prepare_config_and_inputs_for_common()

						for model_class in self.all_model_classes:
											__lowerCAmelCase	   =model_class(snake_case_)
											__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]				,	snake_case_)



	def 		UpperCamelCase							(						self							:    Optional[Any])->							Tuple:
						__lowerCAmelCase	   =self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_model(*snake_case_)



	def 		UpperCamelCase							(						self							:    Optional[Any])->							Any:
						def check_hidden_states_output(snake_case_							:    Union[str, Any]				,	snake_case_							:    Optional[Any]				,	snake_case_							:    Optional[Any]):
											__lowerCAmelCase	   =model_class(snake_case_)
											__lowerCAmelCase	   =model(**self._prepare_for_class(snake_case_				,	snake_case_))

											__lowerCAmelCase	   =outputs.encoder_hidden_states if config.is_encoder_decoder else outputs.hidden_states

											__lowerCAmelCase	   =self.model_tester.num_stages
											self.assertEqual(len(snake_case_)				,	expected_num_stages + 1)

											# ResNet's feature maps are of shape (batch_size, num_channels, height, width)
											self.assertListEqual(
											    list(hidden_states[0].shape[-2:])				,	[self.model_tester.image_size // 4, self.model_tester.image_size // 4]				,	)

						__lowerCAmelCase	   =self.model_tester.prepare_config_and_inputs_for_common()
						__lowerCAmelCase	   =["basic", "bottleneck"]
						for model_class in self.all_model_classes:
											for layer_type in layers_type:
																__lowerCAmelCase	   =layer_type
																__lowerCAmelCase	   =True
																check_hidden_states_output(snake_case_				,	snake_case_				,	snake_case_)

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

																check_hidden_states_output(snake_case_				,	snake_case_				,	snake_case_)



	def 		UpperCamelCase							(						self							:    Union[str, Any])->							Any:
						__lowerCAmelCase	   =self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_for_image_classification(*snake_case_)



	@slow
	def 		UpperCamelCase							(						self							:    Union[str, Any])->							Tuple:
						for model_name in TF_RESNET_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
											__lowerCAmelCase	   =TFResNetModel.from_pretrained(snake_case_)
											self.assertIsNotNone(snake_case_)






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






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



	@cached_property
	def 		UpperCamelCase							(						self							:    Any)->							str:
						return (
						    AutoImageProcessor.from_pretrained(TF_RESNET_PRETRAINED_MODEL_ARCHIVE_LIST[0])
						    if is_vision_available()
						    else None
						)



	@slow
	def 		UpperCamelCase							(						self							:    Optional[int])->							List[str]:
						__lowerCAmelCase	   =TFResNetForImageClassification.from_pretrained(TF_RESNET_PRETRAINED_MODEL_ARCHIVE_LIST[0])

						__lowerCAmelCase	   =self.default_image_processor
						__lowerCAmelCase	   =prepare_img()
						__lowerCAmelCase	   =image_processor(images=snake_case_				,	return_tensors="""tf""")

						# forward pass
						__lowerCAmelCase	   =model(**snake_case_)

						# verify the logits
						__lowerCAmelCase	   =tf.TensorShape((1, 10_00))
						self.assertEqual(outputs.logits.shape				,	snake_case_)

						__lowerCAmelCase	   =tf.constant([-1_1.1_0_6_9, -9.7_8_7_7, -8.3_7_7_7])

						self.assertTrue(np.allclose(outputs.logits[0, :3].numpy()				,	snake_case_				,	atol=1e-4))









def 					__lowerCAmelCase		(  __lowerCamelCase	:    list				,   __lowerCamelCase	:    int				,   __lowerCamelCase	:    int = 0				,   __lowerCamelCase	:    int = 0	)  ->						int:
					__lowerCAmelCase	   =right or len(__lowerCamelCase	) - 1
					if left > right:
										return -1
					elif list_data[left] == key:
										return left
					elif list_data[right] == key:
										return right
					else:
										return search(__lowerCamelCase				,   __lowerCamelCase				,   left + 1				,   right - 1	)


if __name__ == "__main__":
				import doctest

				doctest.testmod()




