


'''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_  :






       def __init__( self			,     _UpperCamelCase			,     _UpperCamelCase=3			,     _UpperCamelCase=32			,     _UpperCamelCase=3			,     _UpperCamelCase=10			,     _UpperCamelCase=[10, 20, 30, 40]			,     _UpperCamelCase=[1, 1, 2, 1]			,     _UpperCamelCase=True			,     _UpperCamelCase=True			,     _UpperCamelCase="relu"			,     _UpperCamelCase=3			,     _UpperCamelCase=None			,     )->      Optional[Any]:
            _A				=							parent
            _A				=							batch_size
            _A				=							image_size
            _A				=							num_channels
            _A				=							embeddings_size
            _A				=							hidden_sizes
            _A				=							depths
            _A				=							is_training
            _A				=							use_labels
            _A				=							hidden_act
            _A				=							num_labels
            _A				=							scope
            _A				=							len(_UpperCamelCase   )






       def   UpperCamelCase						( self   )->      List[Any]:
            _A				=							floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]   )

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

            _A				=							self.get_config()

            return config, pixel_values, labels






       def   UpperCamelCase						( 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   UpperCamelCase						( self			,     _UpperCamelCase			,     _UpperCamelCase			,     _UpperCamelCase   )->      Optional[int]:
            _A				=							TFResNetModel(config=_UpperCamelCase   )
            _A				=							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			,     _UpperCamelCase			,     _UpperCamelCase			,     _UpperCamelCase   )->      List[str]:
            _A				=							self.num_labels
            _A				=							TFResNetForImageClassification(_UpperCamelCase   )
            _A				=							model(_UpperCamelCase			,     labels=_UpperCamelCase   )
            self.parent.assertEqual(result.logits.shape			,     (self.batch_size, self.num_labels)   )






       def   UpperCamelCase						( self   )->      int:
            _A				=							self.prepare_config_and_inputs()
            _A		,				_A		,				_A				=							config_and_inputs
            _A				=							{'pixel_values': pixel_values}
            return config, inputs_dict






@require_tf
class        lowerCAmelCase_  (     UpperCAmelCase      ,							UpperCAmelCase      ,							unittest.TestCase	):
       __UpperCAmelCase					=(TFResNetModel, TFResNetForImageClassification) if is_tf_available() else ()
       __UpperCAmelCase					=(
           {'feature-extraction': TFResNetModel, 'image-classification': TFResNetForImageClassification}
           if is_tf_available()
           else {}
       )

       __UpperCAmelCase					=False
       __UpperCAmelCase					=False
       __UpperCAmelCase					=False
       __UpperCAmelCase					=False
       __UpperCAmelCase					=False






       def   UpperCamelCase						( self   )->      Tuple:
            _A				=							TFResNetModelTester(self   )
            _A				=							ConfigTester(self			,     config_class=_UpperCamelCase			,     has_text_modality=_UpperCamelCase   )






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






       @unittest.skip(reason='ResNet does not use inputs_embeds'   )
       def   UpperCamelCase						( self   )->      Dict:
            pass






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






       def   UpperCamelCase						( self   )->      Optional[Any]:
            _A		,				_A				=							self.model_tester.prepare_config_and_inputs_for_common()

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

                 _A				=							['pixel_values']
                 self.assertListEqual(arg_names[:1]			,     _UpperCamelCase   )






       def   UpperCamelCase						( self   )->      List[Any]:
            _A				=							self.model_tester.prepare_config_and_inputs()
            self.model_tester.create_and_check_model(*_UpperCamelCase   )






       def   UpperCamelCase						( self   )->      Optional[Any]:
            def check_hidden_states_output(_UpperCamelCase			,     _UpperCamelCase			,     _UpperCamelCase   ):
                 _A				=							model_class(_UpperCamelCase   )
                 _A				=							model(**self._prepare_for_class(_UpperCamelCase			,     _UpperCamelCase   )   )

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

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

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

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

                      check_hidden_states_output(_UpperCamelCase			,     _UpperCamelCase			,     _UpperCamelCase   )






       def   UpperCamelCase						( self   )->      Union[str, Any]:
            _A				=							self.model_tester.prepare_config_and_inputs()
            self.model_tester.create_and_check_for_image_classification(*_UpperCamelCase   )






       @slow
       def   UpperCamelCase						( self   )->      str:
            for model_name in TF_RESNET_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
                 _A				=							TFResNetModel.from_pretrained(_UpperCamelCase   )
                 self.assertIsNotNone(_UpperCamelCase   )






def 					lowerCamelCase_ ( )					->	List[Any]:







     """simple docstring"""
     _A				=							Image.open('./tests/fixtures/tests_samples/COCO/000000039769.png'		)
     return image






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






       @cached_property
       def   UpperCamelCase						( self   )->      int:
            return (
                AutoImageProcessor.from_pretrained(TF_RESNET_PRETRAINED_MODEL_ARCHIVE_LIST[0]   )
                if is_vision_available()
                else None
            )






       @slow
       def   UpperCamelCase						( self   )->      List[str]:
            _A				=							TFResNetForImageClassification.from_pretrained(TF_RESNET_PRETRAINED_MODEL_ARCHIVE_LIST[0]   )

            _A				=							self.default_image_processor
            _A				=							prepare_img()
            _A				=							image_processor(images=_UpperCamelCase			,     return_tensors='tf'   )

            # forward pass
            _A				=							model(**_UpperCamelCase   )

            # verify the logits
            _A				=							tf.TensorShape((1, 1000)   )
            self.assertEqual(outputs.logits.shape			,     _UpperCamelCase   )

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

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









'''simple docstring'''
from __future__ import annotations

def 					lowerCamelCase_ ( __UpperCamelCase					:       list							,    __UpperCamelCase					:       int | None = None							,    __UpperCamelCase					:       int | None = None		)					->	None:







     """simple docstring"""
     if start is None:
          _A				=							0

     if end is None:
          _A				=							len(__UpperCamelCase		) - 1

     if start >= end:
          return

     _A				=							(start + end) // 2

     slowsort(__UpperCamelCase							,    __UpperCamelCase							,    __UpperCamelCase		)
     slowsort(__UpperCamelCase							,    mid + 1							,    __UpperCamelCase		)

     if sequence[end] < sequence[mid]:
          _A		,				_A				=							sequence[mid], sequence[end]

     slowsort(__UpperCamelCase							,    __UpperCamelCase							,    end - 1		)


if __name__ == "__main__":
    from doctest import testmod

    testmod()





