




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__:
      def __init__(				self: List[Any]    ,       UpperCamelCase_: Dict    ,       UpperCamelCase_: Any=3    ,       UpperCamelCase_: Any=32    ,       UpperCamelCase_: Optional[Any]=3    ,       UpperCamelCase_: str=10    ,       UpperCamelCase_: Union[str, Any]=[10, 20, 30, 40]    ,       UpperCamelCase_: Optional[Any]=[1, 1, 2, 1]    ,       UpperCamelCase_: Optional[Any]=True    ,       UpperCamelCase_: Dict=True    ,       UpperCamelCase_: Tuple="relu"    ,       UpperCamelCase_: List[str]=3    ,       UpperCamelCase_: Tuple=None    ,       ):
             __lowerCamelCase   =						parent
             __lowerCamelCase   =						batch_size
             __lowerCamelCase   =						image_size
             __lowerCamelCase   =						num_channels
             __lowerCamelCase   =						embeddings_size
             __lowerCamelCase   =						hidden_sizes
             __lowerCamelCase   =						depths
             __lowerCamelCase   =						is_training
             __lowerCamelCase   =						use_labels
             __lowerCamelCase   =						hidden_act
             __lowerCamelCase   =						num_labels
             __lowerCamelCase   =						scope
             __lowerCamelCase   =						len(UpperCamelCase_   )
      def 			lowerCAmelCase__						(				self: Optional[int]   ):
             __lowerCamelCase   =						floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]   )

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

             __lowerCamelCase   =						self.get_config()

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




      def 			lowerCAmelCase__						(				self: Optional[int]   ):
             __lowerCamelCase   =						self.prepare_config_and_inputs()
             __lowerCamelCase   =						config_and_inputs
             __lowerCamelCase   =						{"pixel_values": pixel_values}
             return config, inputs_dict





@require_tf
class     lowerCamelCase__(					__lowercase ,     __lowercase ,     unittest.TestCase):
      UpperCAmelCase__      :	Dict    		=   (TFResNetModel, TFResNetForImageClassification) if is_tf_available() else ()
      UpperCAmelCase__      :	List[Any]    		=   (
          {'feature-extraction': TFResNetModel, 'image-classification': TFResNetForImageClassification}
          if is_tf_available()
          else {}
      )

      UpperCAmelCase__      :	Optional[int]    		=   False
      UpperCAmelCase__      :	Optional[int]    		=   False
      UpperCAmelCase__      :	int    		=   False
      UpperCAmelCase__      :	List[Any]    		=   False
      UpperCAmelCase__      :	Dict    		=   False
      def 			lowerCAmelCase__						(				self: int   ):
             __lowerCamelCase   =						TFResNetModelTester(self   )
             __lowerCamelCase   =						ConfigTester(self    ,       config_class=UpperCamelCase_    ,       has_text_modality=UpperCamelCase_   )
      def 			lowerCAmelCase__						(				self: int   ):
             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: str   ):
             return
      @unittest.skip(reason="""ResNet does not use inputs_embeds"""   )
      def 			lowerCAmelCase__						(				self: Tuple   ):
             pass
      @unittest.skip(reason="""ResNet does not support input and output embeddings"""   )
      def 			lowerCAmelCase__						(				self: List[Any]   ):
             pass
      def 			lowerCAmelCase__						(				self: Optional[int]   ):
             __lowerCamelCase   =						self.model_tester.prepare_config_and_inputs_for_common()

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

                    __lowerCamelCase   =						["pixel_values"]
                    self.assertListEqual(arg_names[:1]    ,       UpperCamelCase_   )
      def 			lowerCAmelCase__						(				self: List[str]   ):
             __lowerCamelCase   =						self.model_tester.prepare_config_and_inputs()
             self.model_tester.create_and_check_model(*UpperCamelCase_   )
      def 			lowerCAmelCase__						(				self: Optional[Any]   ):
             def check_hidden_states_output(UpperCamelCase_: Optional[Any]    ,       UpperCamelCase_: Optional[int]    ,       UpperCamelCase_: List[str]   ):
                    __lowerCamelCase   =						model_class(UpperCamelCase_   )
                    __lowerCamelCase   =						model(**self._prepare_for_class(UpperCamelCase_    ,       UpperCamelCase_   )   )

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

                    __lowerCamelCase   =						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   =						self.model_tester.prepare_config_and_inputs_for_common()
             __lowerCamelCase   =						["basic", "bottleneck"]
             for model_class in self.all_model_classes:
                    for layer_type in layers_type:
                           __lowerCamelCase   =						layer_type
                           __lowerCamelCase   =						True
                           check_hidden_states_output(UpperCamelCase_    ,       UpperCamelCase_    ,       UpperCamelCase_   )

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

                           check_hidden_states_output(UpperCamelCase_    ,       UpperCamelCase_    ,       UpperCamelCase_   )
      def 			lowerCAmelCase__						(				self: Union[str, Any]   ):
             __lowerCamelCase   =						self.model_tester.prepare_config_and_inputs()
             self.model_tester.create_and_check_for_image_classification(*UpperCamelCase_   )




      @slow
      def 			lowerCAmelCase__						(				self: Dict   ):
             for model_name in TF_RESNET_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
                    __lowerCamelCase   =						TFResNetModel.from_pretrained(UpperCamelCase_   )
                    self.assertIsNotNone(UpperCamelCase_   )




def 					lowerCamelCase__       (						):





       '''simple docstring'''



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





@require_tf
@require_vision
class     lowerCamelCase__(					unittest.TestCase):
      @cached_property
      def 			lowerCAmelCase__						(				self: Optional[Any]   ):
             return (
                 AutoImageProcessor.from_pretrained(TF_RESNET_PRETRAINED_MODEL_ARCHIVE_LIST[0]   )
                 if is_vision_available()
                 else None
             )




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

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

             # forward pass
             __lowerCamelCase   =						model(**UpperCamelCase_   )

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

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

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



def 	_SCREAMING_SNAKE_CASE					(		_lowerCamelCase :			int						,  _lowerCamelCase :			int)					->    float:






							'''simple docstring'''





							return base * power(_lowerCamelCase						,  (exponent - 1)) if exponent else 1


if __name__ == "__main__":
		print('Raise base to the power of exponent using recursion...')
		lowercase  :					Optional[int]													=       int(input('Enter the base: ').strip())
		lowercase  :					Tuple													=       int(input('Enter the exponent: ').strip())
		lowercase  :					str													=       power(base, abs(exponent))
		if exponent < 0:  # power() does not properly deal w/ negative exponents
				lowercase  :					Tuple													=       1 / result
		print(f"{base} to the power of {exponent} is {result}")