



'''simple docstring'''

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				:	Optional[Any]     ,  UpperCamelCase_				:	Dict     ,  UpperCamelCase_				:	str=3     ,  UpperCamelCase_				:	Optional[Any]=32     ,  UpperCamelCase_				:	List[str]=3     ,  UpperCamelCase_				:	List[Any]=10     ,  UpperCamelCase_				:	Dict=[10, 20, 30, 40]     ,  UpperCamelCase_				:	Any=[1, 1, 2, 1]     ,  UpperCamelCase_				:	Any=True     ,  UpperCamelCase_				:	Union[str, Any]=True     ,  UpperCamelCase_				:	List[str]="relu"     ,  UpperCamelCase_				:	str=3     ,  UpperCamelCase_				:	Optional[Any]=None     ,  )  ->       int:



						'''simple docstring'''





						_lowercase					:       List[Any]       =		parent
						_lowercase					:       Union[str, Any]       =		batch_size
						_lowercase					:       Union[str, Any]       =		image_size
						_lowercase					:       Optional[int]       =		num_channels
						_lowercase					:       str       =		embeddings_size
						_lowercase					:       Optional[Any]       =		hidden_sizes
						_lowercase					:       List[str]       =		depths
						_lowercase					:       List[str]       =		is_training
						_lowercase					:       Union[str, Any]       =		use_labels
						_lowercase					:       str       =		hidden_act
						_lowercase					:       Dict       =		num_labels
						_lowercase					:       str       =		scope
						_lowercase					:       Any       =		len(UpperCamelCase_					)




					def 						__UpperCAmelCase     (  self				:	int					)  ->       List[str]:



						'''simple docstring'''





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

						_lowercase					:       Optional[Any]       =		None
						if self.use_labels:
							_lowercase					:       str       =		ids_tensor([self.batch_size]     ,  self.num_labels					)

						_lowercase					:       Any       =		self.get_config()

						return config, pixel_values, labels




					def 						__UpperCAmelCase     (  self				:	Any					)  ->       Optional[int]:



						'''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 						__UpperCAmelCase     (  self				:	Any     ,  UpperCamelCase_				:	Dict     ,  UpperCamelCase_				:	int     ,  UpperCamelCase_				:	Optional[int]					)  ->       Union[str, Any]:



						'''simple docstring'''





						_lowercase					:       Optional[int]       =		TFResNetModel(config=UpperCamelCase_					)
						_lowercase					:       Tuple       =		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 						__UpperCAmelCase     (  self				:	str     ,  UpperCamelCase_				:	Dict     ,  UpperCamelCase_				:	List[str]     ,  UpperCamelCase_				:	Tuple					)  ->       Any:



						'''simple docstring'''





						_lowercase					:       Any       =		self.num_labels
						_lowercase					:       Tuple       =		TFResNetForImageClassification(UpperCamelCase_					)
						_lowercase					:       Optional[Any]       =		model(UpperCamelCase_     ,  labels=UpperCamelCase_					)
						self.parent.assertEqual(result.logits.shape     ,  (self.batch_size, self.num_labels)					)




					def 						__UpperCAmelCase     (  self				:	Any					)  ->       List[Any]:



						'''simple docstring'''





						_lowercase					:       Optional[Any]       =		self.prepare_config_and_inputs()
						_lowercase  ,    _lowercase  ,    _lowercase					:       Any       =		config_and_inputs
						_lowercase					:       List[str]       =		{'pixel_values': pixel_values}
						return config, inputs_dict






@require_tf
class 		lowerCamelCase__      (						A	,   A	,   unittest.TestCase     ):




					'''simple docstring'''



					A_						    =						(TFResNetModel, TFResNetForImageClassification) if is_tf_available() else ()
					A_						    =						(
					    {"""feature-extraction""": TFResNetModel, """image-classification""": TFResNetForImageClassification}
					    if is_tf_available()
					    else {}
					)

					A_						    =						False
					A_						    =						False
					A_						    =						False
					A_						    =						False
					A_						    =						False




					def 						__UpperCAmelCase     (  self				:	str					)  ->       List[Any]:



						'''simple docstring'''





						_lowercase					:       Any       =		TFResNetModelTester(self					)
						_lowercase					:       Any       =		ConfigTester(self     ,  config_class=UpperCamelCase_     ,  has_text_modality=UpperCamelCase_					)




					def 						__UpperCAmelCase     (  self				:	Optional[int]					)  ->       Union[str, 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 						__UpperCAmelCase     (  self				:	Optional[Any]					)  ->       str:



						'''simple docstring'''





						return




					@unittest.skip(reason='ResNet does not use inputs_embeds'					)
					def 						__UpperCAmelCase     (  self				:	Any					)  ->       Optional[int]:



						'''simple docstring'''





						pass




					@unittest.skip(reason='ResNet does not support input and output embeddings'					)
					def 						__UpperCAmelCase     (  self				:	str					)  ->       int:



						'''simple docstring'''





						pass




					def 						__UpperCAmelCase     (  self				:	Dict					)  ->       Any:



						'''simple docstring'''





						_lowercase  ,    _lowercase					:       Any       =		self.model_tester.prepare_config_and_inputs_for_common()

						for model_class in self.all_model_classes:
							_lowercase					:       Union[str, Any]       =		model_class(UpperCamelCase_					)
							_lowercase					:       Tuple       =		inspect.signature(model.call					)
							# signature.parameters is an OrderedDict => so arg_names order is deterministic
							_lowercase					:       List[str]       =		[*signature.parameters.keys()]

							_lowercase					:       int       =		['pixel_values']
							self.assertListEqual(arg_names[:1]     ,  UpperCamelCase_					)




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



						'''simple docstring'''





						_lowercase					:       List[str]       =		self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_model(*UpperCamelCase_					)




					def 						__UpperCAmelCase     (  self				:	Optional[int]					)  ->       Union[str, Any]:



						'''simple docstring'''





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

							_lowercase					:       List[Any]       =		outputs.encoder_hidden_states if config.is_encoder_decoder else outputs.hidden_states

							_lowercase					:       Dict       =		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]     ,  )

						_lowercase  ,    _lowercase					:       Any       =		self.model_tester.prepare_config_and_inputs_for_common()
						_lowercase					:       Tuple       =		['basic', 'bottleneck']
						for model_class in self.all_model_classes:
							for layer_type in layers_type:
								_lowercase					:       Optional[Any]       =		layer_type
								_lowercase					:       Dict       =		True
								check_hidden_states_output(UpperCamelCase_     ,  UpperCamelCase_     ,  UpperCamelCase_					)

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

								check_hidden_states_output(UpperCamelCase_     ,  UpperCamelCase_     ,  UpperCamelCase_					)




					def 						__UpperCAmelCase     (  self				:	Dict					)  ->       str:



						'''simple docstring'''





						_lowercase					:       Tuple       =		self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_for_image_classification(*UpperCamelCase_					)




					@slow
					def 						__UpperCAmelCase     (  self				:	str					)  ->       Union[str, Any]:



						'''simple docstring'''





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







def 						__UpperCamelCase				(							) ->			int:
	_lowercase					:       List[str]       =		Image.open('./tests/fixtures/tests_samples/COCO/000000039769.png'					)
	return image






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




					'''simple docstring'''



					@cached_property
					def 						__UpperCAmelCase     (  self				:	Optional[int]					)  ->       int:



						'''simple docstring'''





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




					@slow
					def 						__UpperCAmelCase     (  self				:	int					)  ->       List[str]:



						'''simple docstring'''





						_lowercase					:       Dict       =		TFResNetForImageClassification.from_pretrained(TF_RESNET_PRETRAINED_MODEL_ARCHIVE_LIST[0]					)

						_lowercase					:       Any       =		self.default_image_processor
						_lowercase					:       Tuple       =		prepare_img()
						_lowercase					:       str       =		image_processor(images=UpperCamelCase_     ,  return_tensors='tf'					)

						# forward pass
						_lowercase					:       Optional[Any]       =		model(**UpperCamelCase_					)

						# verify the logits
						_lowercase					:       Tuple       =		tf.TensorShape((1, 1000)					)
						self.assertEqual(outputs.logits.shape     ,  UpperCamelCase_					)

						_lowercase					:       List[str]       =		tf.constant([-11.10_69, -9.78_77, -8.37_77]					)

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





'''simple docstring'''

def 						__UpperCamelCase				(							_lowercase					) ->			bool:
	return str(_lowercase					) == str(_lowercase					)[::-1]







def 						__UpperCamelCase				(							_lowercase					) ->			int:
	return int(_lowercase					) + int(str(_lowercase					)[::-1]					)







def 						__UpperCamelCase				(							_lowercase = 1_0000					) ->			int:
	_lowercase					:       List[str]       =		[]
	for num in range(1,				_lowercase					):
		_lowercase					:       Tuple       =		0
		_lowercase					:       Tuple       =		num
		while iterations < 50:
			_lowercase					:       Union[str, Any]       =		sum_reverse(_lowercase					)
			iterations += 1
			if is_palindrome(_lowercase					):
				break
		else:
			lychrel_nums.append(_lowercase					)
	return len(_lowercase					)


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