"""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 			_snake_case  :






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






						def    lowerCamelCase__  (							self   :      int     ):
													__lowerCamelCase       :		Tuple		 =  floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]     )

													__lowerCamelCase       :		str		 =  None
													if self.use_labels:
																				__lowerCamelCase       :		List[str]		 =  ids_tensor([self.batch_size]				,       self.num_labels     )

													__lowerCamelCase       :		Optional[int]		 =  self.get_config()

													return config, pixel_values, labels






						def    lowerCamelCase__  (							self   :      List[Any]     ):
													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   :      Tuple				,       UpperCAmelCase   :      str				,       UpperCAmelCase   :      Union[str, Any]				,       UpperCAmelCase   :      Any     ):
													__lowerCamelCase       :		Union[str, Any]		 =  TFResNetModel(config=UpperCAmelCase     )
													__lowerCamelCase       :		Dict		 =  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   :      Optional[Any]				,       UpperCAmelCase   :      Dict				,       UpperCAmelCase   :      Optional[int]				,       UpperCAmelCase   :      List[Any]     ):
													__lowerCamelCase       :		Optional[Any]		 =  self.num_labels
													__lowerCamelCase       :		Any		 =  TFResNetForImageClassification(UpperCAmelCase     )
													__lowerCamelCase       :		Tuple		 =  model(UpperCAmelCase				,       labels=UpperCAmelCase     )
													self.parent.assertEqual(result.logits.shape				,       (self.batch_size, self.num_labels)     )







						def    lowerCamelCase__  (							self   :      List[str]     ):
													__lowerCamelCase       :		int		 =  self.prepare_config_and_inputs()
													__lowerCamelCase       :		Any		 =  config_and_inputs
													__lowerCamelCase       :		str		 =  {'''pixel_values''': pixel_values}
													return config, inputs_dict

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

						snake_case__      	=      False
						snake_case__      	=      False
						snake_case__      	=      False
						snake_case__      	=      False
						snake_case__      	=      False






						def    lowerCamelCase__  (							self   :      Optional[Any]     ):
													__lowerCamelCase       :		List[Any]		 =  TFResNetModelTester(self     )
													__lowerCamelCase       :		Any		 =  ConfigTester(self				,       config_class=UpperCAmelCase				,       has_text_modality=UpperCAmelCase     )






						def    lowerCamelCase__  (							self   :      Dict     ):
													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   :      Any     ):
													return






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






						@unittest.skip(reason="ResNet does not support input and output embeddings"     )
						def    lowerCamelCase__  (							self   :      List[str]     ):
													pass






						def    lowerCamelCase__  (							self   :      Optional[int]     ):
													__lowerCamelCase       :		List[str]		 =  self.model_tester.prepare_config_and_inputs_for_common()

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

																				__lowerCamelCase       :		int		 =  ['''pixel_values''']
																				self.assertListEqual(arg_names[:1]				,       UpperCAmelCase     )






						def    lowerCamelCase__  (							self   :      int     ):
													__lowerCamelCase       :		List[Any]		 =  self.model_tester.prepare_config_and_inputs()
													self.model_tester.create_and_check_model(*UpperCAmelCase     )






						def    lowerCamelCase__  (							self   :      List[str]     ):

													def check_hidden_states_output(UpperCAmelCase   :      Any				,       UpperCAmelCase   :      Optional[int]				,       UpperCAmelCase   :      List[Any]     ):
																				__lowerCamelCase       :		Union[str, Any]		 =  model_class(UpperCAmelCase     )
																				__lowerCamelCase       :		int		 =  model(**self._prepare_for_class(UpperCAmelCase				,       UpperCAmelCase     )     )

																				__lowerCamelCase       :		Tuple		 =  outputs.encoder_hidden_states if config.is_encoder_decoder else outputs.hidden_states

																				__lowerCamelCase       :		List[Any]		 =  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]				,       )

													__lowerCamelCase       :		Dict		 =  self.model_tester.prepare_config_and_inputs_for_common()
													__lowerCamelCase       :		str		 =  ['''basic''', '''bottleneck''']
													for model_class in self.all_model_classes:
																				for layer_type in layers_type:
																											__lowerCamelCase       :		Optional[int]		 =  layer_type
																											__lowerCamelCase       :		List[str]		 =  True
																											check_hidden_states_output(UpperCAmelCase				,       UpperCAmelCase				,       UpperCAmelCase     )

																											# check that output_hidden_states also work using config
																											del inputs_dict["output_hidden_states"]
																											__lowerCamelCase       :		Union[str, Any]		 =  True

																											check_hidden_states_output(UpperCAmelCase				,       UpperCAmelCase				,       UpperCAmelCase     )






						def    lowerCamelCase__  (							self   :      Any     ):
													__lowerCamelCase       :		List[str]		 =  self.model_tester.prepare_config_and_inputs()
													self.model_tester.create_and_check_for_image_classification(*UpperCAmelCase     )







						@slow
						def    lowerCamelCase__  (							self   :      int     ):

													for model_name in TF_RESNET_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
																				__lowerCamelCase       :		Dict		 =  TFResNetModel.from_pretrained(UpperCAmelCase     )
																				self.assertIsNotNone(UpperCAmelCase     )


def  lowercase_ ( )			->   int:



							'''simple docstring'''

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







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






						@cached_property
						def    lowerCamelCase__  (							self   :      Union[str, Any]     ):
													return (
													    AutoImageProcessor.from_pretrained(TF_RESNET_PRETRAINED_MODEL_ARCHIVE_LIST[0]     )
													    if is_vision_available()
													    else None
													)







						@slow
						def    lowerCamelCase__  (							self   :      int     ):
													__lowerCamelCase       :		int		 =  TFResNetForImageClassification.from_pretrained(TF_RESNET_PRETRAINED_MODEL_ARCHIVE_LIST[0]     )

													__lowerCamelCase       :		Optional[Any]		 =  self.default_image_processor
													__lowerCamelCase       :		Any		 =  prepare_img()
													__lowerCamelCase       :		Tuple		 =  image_processor(images=UpperCAmelCase				,       return_tensors="tf"     )

													# forward pass
													__lowerCamelCase       :		List[str]		 =  model(**UpperCAmelCase     )

													# verify the logits
													__lowerCamelCase       :		Optional[int]		 =  tf.TensorShape((1, 1000)     )
													self.assertEqual(outputs.logits.shape				,       UpperCAmelCase     )

													__lowerCamelCase       :		List[str]		 =  tf.constant([-11.1069, -9.7_8_7_7, -8.3_7_7_7]     )

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







'''simple docstring'''



def 				lowercase_					(     __A			:							int       ,   __A			:							int      )							->   int:



 """simple docstring"""




 return 1 if input_a == input_a else 0


def 				lowercase_					(     )							->   None:



 """simple docstring"""




 assert xnor_gate(0       ,   0      ) == 1
 assert xnor_gate(0       ,   1      ) == 0
 assert xnor_gate(1       ,   0      ) == 0
 assert xnor_gate(1       ,   1      ) == 1


if __name__ == "__main__":
      print(xnor_gate(0, 0))
      print(xnor_gate(0, 1))
      print(xnor_gate(1, 0))
      print(xnor_gate(1, 1))



