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



				"""simple docstring"""

				def __init__(			self						,      lowerCAmelCase						,      lowerCAmelCase=3						,      lowerCAmelCase=32						,      lowerCAmelCase=3						,      lowerCAmelCase=10						,      lowerCAmelCase=[10, 20, 30, 40]						,      lowerCAmelCase=[1, 1, 2, 1]						,      lowerCAmelCase=True						,      lowerCAmelCase=True						,      lowerCAmelCase="relu"						,      lowerCAmelCase=3						,      lowerCAmelCase=None						,      ):






										"""simple docstring"""

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

				def 						snake_case	(			self      ):






										"""simple docstring"""

										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.num_labels      )

										snake_case        =     self.get_config()

										return config, pixel_values, labels

				def 						snake_case	(			self      ):






										"""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 						snake_case	(			self						,      lowerCAmelCase						,      lowerCAmelCase						,      lowerCAmelCase      ):






										"""simple docstring"""

										snake_case        =     TFResNetModel(config=lowerCAmelCase      )
										snake_case        =     model(lowerCAmelCase      )
										# 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 						snake_case	(			self						,      lowerCAmelCase						,      lowerCAmelCase						,      lowerCAmelCase      ):






										"""simple docstring"""

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

				def 						snake_case	(			self      ):






										"""simple docstring"""

										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 					lowerCAmelCase_      (     lowerCAmelCase       ,      lowerCAmelCase       ,      unittest.TestCase   ):



				"""simple docstring"""
				_lowerCAmelCase       :      Optional[int]     					=  (TFResNetModel, TFResNetForImageClassification) if is_tf_available() else ()
				_lowerCAmelCase       :      Dict     					=  (
				    {"""feature-extraction""": TFResNetModel, """image-classification""": TFResNetForImageClassification}
				    if is_tf_available()
				    else {}
				)

				_lowerCAmelCase       :      Union[str, Any]     					=  False
				_lowerCAmelCase       :      Any     					=  False
				_lowerCAmelCase       :      Union[str, Any]     					=  False
				_lowerCAmelCase       :      List[str]     					=  False
				_lowerCAmelCase       :      int     					=  False

				def 						snake_case	(			self      ):






										"""simple docstring"""

										snake_case        =     TFResNetModelTester(self      )
										snake_case        =     ConfigTester(self						,      config_class=lowerCAmelCase						,      has_text_modality=lowerCAmelCase      )

				def 						snake_case	(			self      ):






										"""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 						snake_case	(			self      ):






										"""simple docstring"""

										return

				@unittest.skip(reason='ResNet does not use inputs_embeds'      )
				def 						snake_case	(			self      ):






										"""simple docstring"""

										pass

				@unittest.skip(reason='ResNet does not support input and output embeddings'      )
				def 						snake_case	(			self      ):






										"""simple docstring"""

										pass

				def 						snake_case	(			self      ):






										"""simple docstring"""

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






										"""simple docstring"""

										snake_case        =     self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_model(*lowerCAmelCase      )

				def 						snake_case	(			self      ):






										"""simple docstring"""

										def check_hidden_states_output(lowerCAmelCase						,      lowerCAmelCase						,      lowerCAmelCase      ):
																snake_case        =     model_class(lowerCAmelCase      )
																snake_case        =     model(**self._prepare_for_class(lowerCAmelCase						,      lowerCAmelCase      )      )

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

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

										snake_case   ,snake_case        =     self.model_tester.prepare_config_and_inputs_for_common()
										snake_case        =     ['basic', 'bottleneck']
										for model_class in self.all_model_classes:
																for layer_type in layers_type:
																						snake_case        =     layer_type
																						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 						snake_case	(			self      ):






										"""simple docstring"""

										snake_case        =     self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_for_image_classification(*lowerCAmelCase      )

				@slow
				def 						snake_case	(			self      ):






										"""simple docstring"""

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





def 				lowerCAmelCase__      (     )   ->			Optional[Any]:





						"""simple docstring"""






						snake_case        =     Image.open('./tests/fixtures/tests_samples/COCO/000000039769.png'   )
						return image



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



				"""simple docstring"""

				@cached_property
				def 						snake_case	(			self      ):






										"""simple docstring"""

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

				@slow
				def 						snake_case	(			self      ):






										"""simple docstring"""

										snake_case        =     TFResNetForImageClassification.from_pretrained(TF_RESNET_PRETRAINED_MODEL_ARCHIVE_LIST[0]      )

										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      )

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

										snake_case        =     tf.constant([-11.10_69, -9.78_77, -8.37_77]      )

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



"""simple docstring"""
SCREAMING_SNAKE_CASE__   =					{str(digit): digit**5 for digit in range(10)}





def 				lowerCAmelCase__      (     _UpperCamelCase    :			int   )   ->			int:





						"""simple docstring"""






						return sum(DIGITS_FIFTH_POWER[digit] for digit in str(_UpperCamelCase   )   )





def 				lowerCAmelCase__      (     )   ->			int:





						"""simple docstring"""






						return sum(
						    number
						    for number in range(1_0_0_0	,     1_0_0_0_0_0_0   )
						    if number == digits_fifth_powers_sum(_UpperCamelCase   )   )


if __name__ == "__main__":
					print(solution())


