




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







     '''simple docstring'''




     def __init__(				self       :			List[Any] ,	UpperCamelCase_       :			Any ,	UpperCamelCase_       :			Dict=3 ,	UpperCamelCase_       :			int=32 ,	UpperCamelCase_       :			Optional[Any]=3 ,	UpperCamelCase_       :			Any=10 ,	UpperCamelCase_       :			Optional[Any]=[10, 20, 30, 40] ,	UpperCamelCase_       :			List[str]=[1, 1, 2, 1] ,	UpperCamelCase_       :			Optional[int]=True ,	UpperCamelCase_       :			Union[str, Any]=True ,	UpperCamelCase_       :			Optional[int]="relu" ,	UpperCamelCase_       :			str=3 ,	UpperCamelCase_       :			List[str]=None ,	):


         """simple docstring"""



         __A         =	parent
         __A         =	batch_size
         __A         =	image_size
         __A         =	num_channels
         __A         =	embeddings_size
         __A         =	hidden_sizes
         __A         =	depths
         __A         =	is_training
         __A         =	use_labels
         __A         =	hidden_act
         __A         =	num_labels
         __A         =	scope
         __A         =	len(UpperCamelCase_				)




     def 		lowerCAmelCase_     (				self       :			List[str]				):


         """simple docstring"""



         __A         =	floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]				)

         __A         =	None
         if self.use_labels:
             __A         =	ids_tensor([self.batch_size] ,	self.num_labels				)

         __A         =	self.get_config()

         return config, pixel_values, labels




     def 		lowerCAmelCase_     (				self       :			List[Any]				):


         """simple docstring"""



         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 		lowerCAmelCase_     (				self       :			List[Any] ,	UpperCamelCase_       :			Dict ,	UpperCamelCase_       :			List[str] ,	UpperCamelCase_       :			List[Any]				):


         """simple docstring"""



         __A         =	TFResNetModel(config=UpperCamelCase_				)
         __A         =	model(UpperCamelCase_				)
         # 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 		lowerCAmelCase_     (				self       :			List[Any] ,	UpperCamelCase_       :			Tuple ,	UpperCamelCase_       :			List[Any] ,	UpperCamelCase_       :			List[str]				):


         """simple docstring"""



         __A         =	self.num_labels
         __A         =	TFResNetForImageClassification(UpperCamelCase_				)
         __A         =	model(UpperCamelCase_ ,	labels=UpperCamelCase_				)
         self.parent.assertEqual(result.logits.shape ,	(self.batch_size, self.num_labels)				)





     def 		lowerCAmelCase_     (				self       :			List[str]				):


         """simple docstring"""



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


@require_tf
class       __lowercase      (	lowercase_			,      lowercase_			,      unittest.TestCase  ):







     '''simple docstring'''
     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 		lowerCAmelCase_     (				self       :			List[Any]				):


         """simple docstring"""



         __A         =	TFResNetModelTester(self				)
         __A         =	ConfigTester(self ,	config_class=UpperCamelCase_ ,	has_text_modality=UpperCamelCase_				)




     def 		lowerCAmelCase_     (				self       :			Any				):


         """simple docstring"""



         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 		lowerCAmelCase_     (				self       :			Dict				):


         """simple docstring"""



         return




     @unittest.skip(reason="""ResNet does not use inputs_embeds"""				)
     def 		lowerCAmelCase_     (				self       :			List[Any]				):


         """simple docstring"""



         pass




     @unittest.skip(reason="""ResNet does not support input and output embeddings"""				)
     def 		lowerCAmelCase_     (				self       :			str				):


         """simple docstring"""



         pass




     def 		lowerCAmelCase_     (				self       :			List[Any]				):


         """simple docstring"""



         __A    ,	__A         =	self.model_tester.prepare_config_and_inputs_for_common()

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

             __A         =	["""pixel_values"""]
             self.assertListEqual(arg_names[:1] ,	UpperCamelCase_				)




     def 		lowerCAmelCase_     (				self       :			Union[str, Any]				):


         """simple docstring"""



         __A         =	self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_model(*UpperCamelCase_				)




     def 		lowerCAmelCase_     (				self       :			Dict				):


         """simple docstring"""



         def check_hidden_states_output(UpperCamelCase_       :			Union[str, Any] ,	UpperCamelCase_       :			str ,	UpperCamelCase_       :			int				):
             __A         =	model_class(UpperCamelCase_				)
             __A         =	model(**self._prepare_for_class(UpperCamelCase_ ,	UpperCamelCase_				)				)

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

             __A         =	self.model_tester.num_stages
             self.assertEqual(len(UpperCamelCase_				) ,	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] ,	)

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

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

                 check_hidden_states_output(UpperCamelCase_ ,	UpperCamelCase_ ,	UpperCamelCase_				)




     def 		lowerCAmelCase_     (				self       :			str				):


         """simple docstring"""



         __A         =	self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_for_image_classification(*UpperCamelCase_				)





     @slow
     def 		lowerCAmelCase_     (				self       :			Dict				):


         """simple docstring"""



         for model_name in TF_RESNET_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
             __A         =	TFResNetModel.from_pretrained(UpperCamelCase_				)
             self.assertIsNotNone(UpperCamelCase_				)



def 			_SCREAMING_SNAKE_CASE						( )						->      Dict:





    """simple docstring"""

    __A         =	Image.open("""./tests/fixtures/tests_samples/COCO/000000039769.png"""    )
    return image






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







     '''simple docstring'''




     @cached_property
     def 		lowerCAmelCase_     (				self       :			str				):


         """simple docstring"""



         return (
             AutoImageProcessor.from_pretrained(TF_RESNET_PRETRAINED_MODEL_ARCHIVE_LIST[0]				)
             if is_vision_available()
             else None
         )





     @slow
     def 		lowerCAmelCase_     (				self       :			Union[str, Any]				):


         """simple docstring"""



         __A         =	TFResNetForImageClassification.from_pretrained(TF_RESNET_PRETRAINED_MODEL_ARCHIVE_LIST[0]				)

         __A         =	self.default_image_processor
         __A         =	prepare_img()
         __A         =	image_processor(images=UpperCamelCase_ ,	return_tensors="""tf"""				)

         # forward pass
         __A         =	model(**UpperCamelCase_				)

         # verify the logits
         __A         =	tf.TensorShape((1, 1_000)				)
         self.assertEqual(outputs.logits.shape ,	UpperCamelCase_				)

         __A         =	tf.constant([-11.1069, -9.7877, -8.3777]				)

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












from ...processing_utils import ProcessorMixin
from ...tokenization_utils_base import BatchEncoding


class       __lowercase      (	lowercase_  ):







     '''simple docstring'''
     SCREAMING_SNAKE_CASE   						=				["image_processor", "tokenizer"]
     SCREAMING_SNAKE_CASE   						=				"AutoImageProcessor"
     SCREAMING_SNAKE_CASE   						=				"AutoTokenizer"




     def __init__(				self       :			str ,	UpperCamelCase_       :			Any ,	UpperCamelCase_       :			str				):


         """simple docstring"""



         super().__init__(UpperCamelCase_ ,	UpperCamelCase_				)
         __A         =	self.image_processor




     def __call__(				self       :			Optional[Any] ,	UpperCamelCase_       :			Optional[Any]=None ,	UpperCamelCase_       :			Any=None ,	UpperCamelCase_       :			List[Any]=None ,	**UpperCamelCase_       :			int				):


         """simple docstring"""



         if text is None and images is None:
             raise ValueError("""You have to specify either text or images. Both cannot be none."""				)

         if text is not None:
             __A         =	self.tokenizer(UpperCamelCase_ ,	return_tensors=UpperCamelCase_ ,	**UpperCamelCase_				)

         if images is not None:
             __A         =	self.image_processor(UpperCamelCase_ ,	return_tensors=UpperCamelCase_ ,	**UpperCamelCase_				)

         if text is not None and images is not None:
             __A         =	image_features.pixel_values
             return encoding
         elif text is not None:
             return encoding
         else:
             return BatchEncoding(data=dict(**UpperCamelCase_				) ,	tensor_type=UpperCamelCase_				)




     def 		lowerCAmelCase_     (				self       :			List[str] ,	*UpperCamelCase_       :			Tuple ,	**UpperCamelCase_       :			List[str]				):


         """simple docstring"""



         return self.tokenizer.batch_decode(*UpperCamelCase_ ,	**UpperCamelCase_				)




     def 		lowerCAmelCase_     (				self       :			Any ,	*UpperCamelCase_       :			int ,	**UpperCamelCase_       :			Tuple				):


         """simple docstring"""



         return self.tokenizer.decode(*UpperCamelCase_ ,	**UpperCamelCase_				)





     @property
     def 		lowerCAmelCase_     (				self       :			Optional[Any]				):


         """simple docstring"""



         return ["input_ids", "attention_mask", "pixel_values"]




