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


			"""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 ,  )	->   Any:

							'''simple docstring'''


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





			def 			_SCREAMING_SNAKE_CASE     (  self		)	->   Union[str, Any]:

							'''simple docstring'''


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

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

							__lowercase					     =				self.get_config()

							return config, pixel_values, labels





			def 			_SCREAMING_SNAKE_CASE     (  self		)	->   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 			_SCREAMING_SNAKE_CASE     (  self ,  lowerCAmelCase__ ,  lowerCAmelCase__ ,  lowerCAmelCase__		)	->   Union[str, Any]:

							'''simple docstring'''


							__lowercase					     =				TFResNetModel(config=lowerCAmelCase__		)
							__lowercase					     =				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 			_SCREAMING_SNAKE_CASE     (  self ,  lowerCAmelCase__ ,  lowerCAmelCase__ ,  lowerCAmelCase__		)	->   str:

							'''simple docstring'''


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





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

							'''simple docstring'''


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




@require_tf
class   _UpperCamelCase (		_UpperCAmelCase		,_UpperCAmelCase		,unittest.TestCase					):


			"""simple docstring"""






			__a    :					Optional[int]     					=		(TFResNetModel, TFResNetForImageClassification) if is_tf_available() else ()
			__a    :					Any     					=		(
			    {'''feature-extraction''': TFResNetModel, '''image-classification''': TFResNetForImageClassification}
			    if is_tf_available()
			    else {}
			)

			__a    :					List[Any]     					=		False
			__a    :					Tuple     					=		False
			__a    :					Any     					=		False
			__a    :					List[str]     					=		False
			__a    :					str     					=		False





			def 			_SCREAMING_SNAKE_CASE     (  self		)	->   Any:

							'''simple docstring'''


							__lowercase					     =				TFResNetModelTester(self		)
							__lowercase					     =				ConfigTester(self ,  config_class=lowerCAmelCase__ ,  has_text_modality=lowerCAmelCase__		)





			def 			_SCREAMING_SNAKE_CASE     (  self		)	->   List[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 			_SCREAMING_SNAKE_CASE     (  self		)	->   List[Any]:

							'''simple docstring'''


							return





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

							'''simple docstring'''


							pass





			@unittest.skip(reason='''ResNet does not support input and output embeddings'''		)
			def 			_SCREAMING_SNAKE_CASE     (  self		)	->   Optional[Any]:

							'''simple docstring'''


							pass





			def 			_SCREAMING_SNAKE_CASE     (  self		)	->   Tuple:

							'''simple docstring'''


							__lowercase     ,	__lowercase					     =				self.model_tester.prepare_config_and_inputs_for_common()

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

											__lowercase					     =				['''pixel_values''']
											self.assertListEqual(arg_names[:1] ,  lowerCAmelCase__		)





			def 			_SCREAMING_SNAKE_CASE     (  self		)	->   int:

							'''simple docstring'''


							__lowercase					     =				self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_model(*lowerCAmelCase__		)





			def 			_SCREAMING_SNAKE_CASE     (  self		)	->   Optional[int]:

							'''simple docstring'''


							def check_hidden_states_output(lowerCAmelCase__ ,  lowerCAmelCase__ ,  lowerCAmelCase__		):
											__lowercase					     =				model_class(lowerCAmelCase__		)
											__lowercase					     =				model(**self._prepare_for_class(lowerCAmelCase__ ,  lowerCAmelCase__		)		)

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

											__lowercase					     =				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] ,  )

							__lowercase     ,	__lowercase					     =				self.model_tester.prepare_config_and_inputs_for_common()
							__lowercase					     =				['''basic''', '''bottleneck''']
							for model_class in self.all_model_classes:
											for layer_type in layers_type:
															__lowercase					     =				layer_type
															__lowercase					     =				True
															check_hidden_states_output(lowerCAmelCase__ ,  lowerCAmelCase__ ,  lowerCAmelCase__		)

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

															check_hidden_states_output(lowerCAmelCase__ ,  lowerCAmelCase__ ,  lowerCAmelCase__		)





			def 			_SCREAMING_SNAKE_CASE     (  self		)	->   str:

							'''simple docstring'''


							__lowercase					     =				self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_for_image_classification(*lowerCAmelCase__		)





			@slow
			def 			_SCREAMING_SNAKE_CASE     (  self		)	->   List[Any]:

							'''simple docstring'''


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





def 							UpperCAmelCase		(       ):







				"""simple docstring"""



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




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


			"""simple docstring"""






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

							'''simple docstring'''


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





			@slow
			def 			_SCREAMING_SNAKE_CASE     (  self		)	->   Any:

							'''simple docstring'''


							__lowercase					     =				TFResNetForImageClassification.from_pretrained(TF_RESNET_PRETRAINED_MODEL_ARCHIVE_LIST[0]		)

							__lowercase					     =				self.default_image_processor
							__lowercase					     =				prepare_img()
							__lowercase					     =				image_processor(images=lowerCAmelCase__ ,  return_tensors='''tf'''		)

							# forward pass
							__lowercase					     =				model(**lowerCAmelCase__		)

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

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

							self.assertTrue(np.allclose(outputs.logits[0, :3].numpy() ,  lowerCAmelCase__ ,  atol=1E-4		)		)
from typing import Any




class   _UpperCamelCase :


			"""simple docstring"""






			def __init__(  self ,  lowerCAmelCase__		)	->   int:

							'''simple docstring'''


							__lowercase					     =				data
							__lowercase					     =				None





			def __repr__(  self		)	->   str:

							'''simple docstring'''


							return F"Node({self.data})"




class   _UpperCamelCase :


			"""simple docstring"""






			def __init__(  self		)	->   Optional[Any]:

							'''simple docstring'''


							__lowercase					     =				None





			def __iter__(  self		)	->   Any:

							'''simple docstring'''


							__lowercase					     =				self.head
							while node:
											yield node.data
											__lowercase					     =				node.next





			def __len__(  self		)	->   int:

							'''simple docstring'''


							return sum(1 for _ in self		)





			def __repr__(  self		)	->   str:

							'''simple docstring'''


							return "->".join([str(lowerCAmelCase__		) for item in self]		)





			def __getitem__(  self ,  lowerCAmelCase__		)	->   Any:

							'''simple docstring'''


							if not 0 <= index < len(self		):
											raise ValueError('''list index out of range.'''		)
							for i, node in enumerate(self		):
											if i == index:
															return node
							return None





			def __setitem__(  self ,  lowerCAmelCase__ ,  lowerCAmelCase__		)	->   None:

							'''simple docstring'''


							if not 0 <= index < len(self		):
											raise ValueError('''list index out of range.'''		)
							__lowercase					     =				self.head
							for _ in range(lowerCAmelCase__		):
											__lowercase					     =				current.next
							__lowercase					     =				data





			def 			_SCREAMING_SNAKE_CASE     (  self ,  lowerCAmelCase__		)	->   None:

							'''simple docstring'''


							self.insert_nth(len(self		) ,  lowerCAmelCase__		)





			def 			_SCREAMING_SNAKE_CASE     (  self ,  lowerCAmelCase__		)	->   None:

							'''simple docstring'''


							self.insert_nth(0 ,  lowerCAmelCase__		)





			def 			_SCREAMING_SNAKE_CASE     (  self ,  lowerCAmelCase__ ,  lowerCAmelCase__		)	->   None:

							'''simple docstring'''


							if not 0 <= index <= len(self		):
											raise IndexError('''list index out of range'''		)
							__lowercase					     =				Node(lowerCAmelCase__		)
							if self.head is None:
											__lowercase					     =				new_node
							elif index == 0:
											__lowercase					     =				self.head  # link new_node to head
											__lowercase					     =				new_node
							else:
											__lowercase					     =				self.head
											for _ in range(index - 1		):
															__lowercase					     =				temp.next
											__lowercase					     =				temp.next
											__lowercase					     =				new_node





			def 			_SCREAMING_SNAKE_CASE     (  self		)	->   None:  # print every node data

							'''simple docstring'''


							print(self		)





			def 			_SCREAMING_SNAKE_CASE     (  self		)	->   Any:

							'''simple docstring'''


							return self.delete_nth(0		)





			def 			_SCREAMING_SNAKE_CASE     (  self		)	->   Any:  # delete from tail

							'''simple docstring'''


							return self.delete_nth(len(self		) - 1		)





			def 			_SCREAMING_SNAKE_CASE     (  self ,  lowerCAmelCase__ = 0		)	->   Any:

							'''simple docstring'''


							if not 0 <= index <= len(self		) - 1:  # test if index is valid
											raise IndexError('''List index out of range.'''		)
							__lowercase					     =				self.head  # default first node
							if index == 0:
											__lowercase					     =				self.head.next
							else:
											__lowercase					     =				self.head
											for _ in range(index - 1		):
															__lowercase					     =				temp.next
											__lowercase					     =				temp.next
											__lowercase					     =				temp.next.next
							return delete_node.data





			def 			_SCREAMING_SNAKE_CASE     (  self		)	->   bool:

							'''simple docstring'''


							return self.head is None





			def 			_SCREAMING_SNAKE_CASE     (  self		)	->   None:

							'''simple docstring'''


							__lowercase					     =				None
							__lowercase					     =				self.head

							while current:
											# Store the current node's next node.
											__lowercase					     =				current.next
											# Make the current node's next point backwards
											__lowercase					     =				prev
											# Make the previous node be the current node
											__lowercase					     =				current
											# Make the current node the next node (to progress iteration)
											__lowercase					     =				next_node
							# Return prev in order to put the head at the end
							__lowercase					     =				prev





def 							UpperCAmelCase		(       ):







				"""simple docstring"""



				__lowercase					     =				LinkedList()
				assert linked_list.is_empty() is True
				assert str(lowercase				) == ""

				try:
								linked_list.delete_head()
								raise AssertionError  # This should not happen.
				except IndexError:
								assert True  # This should happen.

				try:
								linked_list.delete_tail()
								raise AssertionError  # This should not happen.
				except IndexError:
								assert True  # This should happen.

				for i in range(10				):
								assert len(lowercase				) == i
								linked_list.insert_nth(lowercase				,     i + 1				)
				assert str(lowercase				) == "->".join(str(lowercase				) for i in range(1				,     11				)				)

				linked_list.insert_head(0				)
				linked_list.insert_tail(11				)
				assert str(lowercase				) == "->".join(str(lowercase				) for i in range(0				,     12				)				)

				assert linked_list.delete_head() == 0
				assert linked_list.delete_nth(9				) == 10
				assert linked_list.delete_tail() == 11
				assert len(lowercase				) == 9
				assert str(lowercase				) == "->".join(str(lowercase				) for i in range(1				,     10				)				)

				assert all(linked_list[i] == i + 1 for i in range(0				,     9				)				) is True

				for i in range(0				,     9				):
								__lowercase					     =				-i
				assert all(linked_list[i] == -i for i in range(0				,     9				)				) is True

				linked_list.reverse()
				assert str(lowercase				) == "->".join(str(lowercase				) for i in range(-8				,     1				)				)





def 							UpperCAmelCase		(       ):







				"""simple docstring"""



				__lowercase					     =				[
				    -9,
				    100,
				    Node(77345112				),
				    '''dlrow olleH''',
				    7,
				    5555,
				    0,
				    -192.55555,
				    '''Hello, world!''',
				    77.9,
				    Node(10				),
				    None,
				    None,
				    12.20,
				]
				__lowercase					     =				LinkedList()

				for i in test_input:
								linked_list.insert_tail(lowercase				)

				# Check if it's empty or not
				assert linked_list.is_empty() is False
				assert (
				    str(lowercase				) == "-9->100->Node(77345112)->dlrow olleH->7->5555->0->"
				    "-192.55555->Hello, world!->77.9->Node(10)->None->None->12.2"
				)

				# Delete the head
				__lowercase					     =				linked_list.delete_head()
				assert result == -9
				assert (
				    str(lowercase				) == "100->Node(77345112)->dlrow olleH->7->5555->0->-192.55555->"
				    "Hello, world!->77.9->Node(10)->None->None->12.2"
				)

				# Delete the tail
				__lowercase					     =				linked_list.delete_tail()
				assert result == 12.2
				assert (
				    str(lowercase				) == "100->Node(77345112)->dlrow olleH->7->5555->0->-192.55555->"
				    "Hello, world!->77.9->Node(10)->None->None"
				)

				# Delete a node in specific location in linked list
				__lowercase					     =				linked_list.delete_nth(10				)
				assert result is None
				assert (
				    str(lowercase				) == "100->Node(77345112)->dlrow olleH->7->5555->0->-192.55555->"
				    "Hello, world!->77.9->Node(10)->None"
				)

				# Add a Node instance to its head
				linked_list.insert_head(Node('''Hello again, world!'''				)				)
				assert (
				    str(lowercase				)
				    == "Node(Hello again, world!)->100->Node(77345112)->dlrow olleH->"
				    "7->5555->0->-192.55555->Hello, world!->77.9->Node(10)->None"
				)

				# Add None to its tail
				linked_list.insert_tail(lowercase				)
				assert (
				    str(lowercase				)
				    == "Node(Hello again, world!)->100->Node(77345112)->dlrow olleH->"
				    "7->5555->0->-192.55555->Hello, world!->77.9->Node(10)->None->None"
				)

				# Reverse the linked list
				linked_list.reverse()
				assert (
				    str(lowercase				)
				    == "None->None->Node(10)->77.9->Hello, world!->-192.55555->0->5555->"
				    "7->dlrow olleH->Node(77345112)->100->Node(Hello again, world!)"
				)





def 							UpperCAmelCase		(       ):







				"""simple docstring"""



				from doctest import testmod

				testmod()

				__lowercase					     =				LinkedList()
				linked_list.insert_head(input('''Inserting 1st at head '''				).strip()				)
				linked_list.insert_head(input('''Inserting 2nd at head '''				).strip()				)
				print('''\nPrint list:'''				)
				linked_list.print_list()
				linked_list.insert_tail(input('''\nInserting 1st at tail '''				).strip()				)
				linked_list.insert_tail(input('''Inserting 2nd at tail '''				).strip()				)
				print('''\nPrint list:'''				)
				linked_list.print_list()
				print('''\nDelete head'''				)
				linked_list.delete_head()
				print('''Delete tail'''				)
				linked_list.delete_tail()
				print('''\nPrint list:'''				)
				linked_list.print_list()
				print('''\nReverse linked list'''				)
				linked_list.reverse()
				print('''\nPrint list:'''				)
				linked_list.print_list()
				print('''\nString representation of linked list:'''				)
				print(lowercase				)
				print('''\nReading/changing Node data using indexing:'''				)
				print(F"Element at Position 1: {linked_list[1]}"				)
				__lowercase					     =				input('''Enter New Value: '''				).strip()
				print('''New list:'''				)
				print(lowercase				)
				print(F"length of linked_list is : {len(lowercase				)}"				)


if __name__ == "__main__":
		main()