from __future__ import annotations

import inspect
import unittest
from typing import List, Tuple

from transformers import RegNetConfig
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 TF_REGNET_PRETRAINED_MODEL_ARCHIVE_LIST, TFRegNetForImageClassification, TFRegNetModel


if is_vision_available():
      from PIL import Image

      from transformers import AutoImageProcessor

class    snake_case       :




  def __init__(   self  :						Tuple  ,			a_  :						int  ,			a_  :						Optional[int]=3  ,			a_  :						Tuple=32  ,			a_  :						Any=3  ,			a_  :						Tuple=10  ,			a_  :						Optional[int]=[10, 20, 30, 40]  ,			a_  :						List[Any]=[1, 1, 2, 1]  ,			a_  :						int=True  ,			a_  :						Optional[Any]=True  ,			a_  :						Any="relu"  ,			a_  :						int=3  ,			a_  :						List[Any]=None  ,			)->							List[str]:




       """simple docstring"""
       SCREAMING_SNAKE_CASE__					:					str      =		parent
       SCREAMING_SNAKE_CASE__					:					Optional[int]      =		batch_size
       SCREAMING_SNAKE_CASE__					:					int      =		image_size
       SCREAMING_SNAKE_CASE__					:					Tuple      =		num_channels
       SCREAMING_SNAKE_CASE__					:					Tuple      =		embeddings_size
       SCREAMING_SNAKE_CASE__					:					str      =		hidden_sizes
       SCREAMING_SNAKE_CASE__					:					Optional[int]      =		depths
       SCREAMING_SNAKE_CASE__					:					Optional[Any]      =		is_training
       SCREAMING_SNAKE_CASE__					:					Union[str, Any]      =		use_labels
       SCREAMING_SNAKE_CASE__					:					Dict      =		hidden_act
       SCREAMING_SNAKE_CASE__					:					Tuple      =		num_labels
       SCREAMING_SNAKE_CASE__					:					List[Any]      =		scope
       SCREAMING_SNAKE_CASE__					:					str      =		len(a_					)




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




       """simple docstring"""
       SCREAMING_SNAKE_CASE__					:					Optional[Any]      =		floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]					)

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

       SCREAMING_SNAKE_CASE__					:					Tuple      =		self.get_config()
       return config, pixel_values, labels




  def 						__lowercase(   self  :						str					)->							str:




       """simple docstring"""
       return RegNetConfig(
           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  ,			)




  def 						__lowercase(   self  :						List[str]  ,			a_  :						int  ,			a_  :						Any  ,			a_  :						Optional[Any]					)->							int:




       """simple docstring"""
       SCREAMING_SNAKE_CASE__					:					Optional[Any]      =		TFRegNetModel(config=a_					)
       SCREAMING_SNAKE_CASE__					:					Optional[Any]      =		model(a_  ,			training=a_					)
       # 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 						__lowercase(   self  :						Union[str, Any]  ,			a_  :						Dict  ,			a_  :						int  ,			a_  :						Optional[Any]					)->							str:




       """simple docstring"""
       SCREAMING_SNAKE_CASE__					:					Dict      =		self.num_labels
       SCREAMING_SNAKE_CASE__					:					Tuple      =		TFRegNetForImageClassification(a_					)
       SCREAMING_SNAKE_CASE__					:					List[Any]      =		model(a_  ,			labels=a_  ,			training=a_					)
       self.parent.assertEqual(result.logits.shape  ,			(self.batch_size, self.num_labels)					)




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




       """simple docstring"""
       SCREAMING_SNAKE_CASE__					:					Union[str, Any]      =		self.prepare_config_and_inputs()
       SCREAMING_SNAKE_CASE__      ,				SCREAMING_SNAKE_CASE__      ,				SCREAMING_SNAKE_CASE__					:					Optional[Any]      =		config_and_inputs
       SCREAMING_SNAKE_CASE__					:					Optional[Any]      =		{'pixel_values': pixel_values}
       return config, inputs_dict




@require_tf
class    snake_case       (   UpperCamelCase_ ,    UpperCamelCase_ ,    unittest.TestCase    ):
  lowercase_								=  (TFRegNetModel, TFRegNetForImageClassification) if is_tf_available() else ()
  lowercase_								=  (
      {'feature-extraction': TFRegNetModel, 'image-classification': TFRegNetForImageClassification}
      if is_tf_available()
      else {}
  )

  lowercase_								=  False
  lowercase_								=  False
  lowercase_								=  False
  lowercase_								=  False
  lowercase_								=  False




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




       """simple docstring"""
       SCREAMING_SNAKE_CASE__					:					Tuple      =		TFRegNetModelTester(self					)
       SCREAMING_SNAKE_CASE__					:					int      =		ConfigTester(self  ,			config_class=a_  ,			has_text_modality=a_					)




  def 						__lowercase(   self  :						List[Any]					)->							Tuple:




       """simple docstring"""
       return




  @unittest.skip(reason='RegNet does not use inputs_embeds'					)
  def 						__lowercase(   self  :						str					)->							Optional[int]:




       """simple docstring"""
       pass




  @unittest.skipIf(
      not is_tf_available() or len(tf.config.list_physical_devices('GPU'					)					) == 0  ,			reason='TF does not support backprop for grouped convolutions on CPU.'  ,			)
  @slow
  def 						__lowercase(   self  :						Any					)->							List[Any]:




       """simple docstring"""
       super().test_keras_fit()




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




       """simple docstring"""
       pass




  def 						__lowercase(   self  :						Tuple					)->							List[Any]:




       """simple docstring"""
       SCREAMING_SNAKE_CASE__      ,				SCREAMING_SNAKE_CASE__					:					List[str]      =		self.model_tester.prepare_config_and_inputs_for_common()

       for model_class in self.all_model_classes:
            SCREAMING_SNAKE_CASE__					:					Optional[int]      =		model_class(a_					)
            SCREAMING_SNAKE_CASE__					:					Optional[Any]      =		inspect.signature(model.call					)
            # signature.parameters is an OrderedDict => so arg_names order is deterministic
            SCREAMING_SNAKE_CASE__					:					List[Any]      =		[*signature.parameters.keys()]

            SCREAMING_SNAKE_CASE__					:					Optional[int]      =		['pixel_values']
            self.assertListEqual(arg_names[:1]  ,			a_					)




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




       """simple docstring"""
       SCREAMING_SNAKE_CASE__					:					Union[str, Any]      =		self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_model(*a_					)




  def 						__lowercase(   self  :						List[Any]					)->							Optional[Any]:




       """simple docstring"""
       def check_hidden_states_output(a_  :						int  ,			a_  :						Union[str, Any]  ,			a_  :						Tuple					):
            SCREAMING_SNAKE_CASE__					:					Any      =		model_class(a_					)
            SCREAMING_SNAKE_CASE__					:					Optional[Any]      =		model(**self._prepare_for_class(a_  ,			a_					)  ,			training=a_					)

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

            SCREAMING_SNAKE_CASE__					:					Optional[Any]      =		self.model_tester.num_stages
            self.assertEqual(len(a_					)  ,			expected_num_stages + 1					)

            # RegNet'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 // 2, self.model_tester.image_size // 2]  ,			)

       SCREAMING_SNAKE_CASE__      ,				SCREAMING_SNAKE_CASE__					:					int      =		self.model_tester.prepare_config_and_inputs_for_common()
       SCREAMING_SNAKE_CASE__					:					Dict      =		['basic', 'bottleneck']
       for model_class in self.all_model_classes:
            for layer_type in layers_type:
                 SCREAMING_SNAKE_CASE__					:					List[Any]      =		layer_type
                 SCREAMING_SNAKE_CASE__					:					Union[str, Any]      =		True
                 check_hidden_states_output(a_  ,			a_  ,			a_					)

                 # check that output_hidden_states also work using config
                 del inputs_dict["output_hidden_states"]
                 SCREAMING_SNAKE_CASE__					:					int      =		True

                 check_hidden_states_output(a_  ,			a_  ,			a_					)




  def 						__lowercase(   self  :						Optional[int]					)->							Tuple:




       """simple docstring"""
       SCREAMING_SNAKE_CASE__      ,				SCREAMING_SNAKE_CASE__					:					str      =		self.model_tester.prepare_config_and_inputs_for_common()

       def check_equivalence(a_  :						str  ,			a_  :						Tuple  ,			a_  :						Optional[int]  ,			a_  :						Union[str, Any]={}					):
            SCREAMING_SNAKE_CASE__					:					int      =		model(a_  ,			return_dict=a_  ,			**a_					)
            SCREAMING_SNAKE_CASE__					:					str      =		model(a_  ,			return_dict=a_  ,			**a_					).to_tuple()

            def recursive_check(a_  :						List[Any]  ,			a_  :						int					):
                 if isinstance(a_  ,			(List, Tuple)					):
                      for tuple_iterable_value, dict_iterable_value in zip(a_  ,			a_					):
                           recursive_check(a_  ,			a_					)
                 elif tuple_object is None:
                      return
                 else:
                      self.assertTrue(
                          all(tf.equal(a_  ,			a_					)					)  ,			msg=(
                              'Tuple and dict output are not equal. Difference:'
                              F''' {tf.math.reduce_max(tf.abs(tuple_object - dict_object					)					)}'''
                          )  ,			)

                 recursive_check(a_  ,			a_					)

       for model_class in self.all_model_classes:
            SCREAMING_SNAKE_CASE__					:					Optional[int]      =		model_class(a_					)

            SCREAMING_SNAKE_CASE__					:					int      =		self._prepare_for_class(a_  ,			a_					)
            SCREAMING_SNAKE_CASE__					:					Dict      =		self._prepare_for_class(a_  ,			a_					)
            check_equivalence(a_  ,			a_  ,			a_					)

            SCREAMING_SNAKE_CASE__					:					List[str]      =		self._prepare_for_class(a_  ,			a_  ,			return_labels=a_					)
            SCREAMING_SNAKE_CASE__					:					Optional[int]      =		self._prepare_for_class(a_  ,			a_  ,			return_labels=a_					)
            check_equivalence(a_  ,			a_  ,			a_					)

            SCREAMING_SNAKE_CASE__					:					str      =		self._prepare_for_class(a_  ,			a_					)
            SCREAMING_SNAKE_CASE__					:					List[str]      =		self._prepare_for_class(a_  ,			a_					)
            check_equivalence(a_  ,			a_  ,			a_  ,			{'output_hidden_states': True}					)

            SCREAMING_SNAKE_CASE__					:					int      =		self._prepare_for_class(a_  ,			a_  ,			return_labels=a_					)
            SCREAMING_SNAKE_CASE__					:					Union[str, Any]      =		self._prepare_for_class(a_  ,			a_  ,			return_labels=a_					)
            check_equivalence(a_  ,			a_  ,			a_  ,			{'output_hidden_states': True}					)




  def 						__lowercase(   self  :						str					)->							Dict:




       """simple docstring"""
       SCREAMING_SNAKE_CASE__					:					List[str]      =		self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_for_image_classification(*a_					)




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




       """simple docstring"""
       for model_name in TF_REGNET_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
            SCREAMING_SNAKE_CASE__					:					Optional[int]      =		TFRegNetModel.from_pretrained(a_					)
            self.assertIsNotNone(a_					)







def      _a					(   ):







     '''simple docstring'''


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







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




  @cached_property
  def 						__lowercase(   self  :						List[Any]					)->							int:




       """simple docstring"""
       return (
           AutoImageProcessor.from_pretrained(TF_REGNET_PRETRAINED_MODEL_ARCHIVE_LIST[0]					)
           if is_vision_available()
           else None
       )




  @slow
  def 						__lowercase(   self  :						Any					)->							Tuple:




       """simple docstring"""
       SCREAMING_SNAKE_CASE__					:					str      =		TFRegNetForImageClassification.from_pretrained(TF_REGNET_PRETRAINED_MODEL_ARCHIVE_LIST[0]					)

       SCREAMING_SNAKE_CASE__					:					List[Any]      =		self.default_image_processor
       SCREAMING_SNAKE_CASE__					:					Any      =		prepare_img()
       SCREAMING_SNAKE_CASE__					:					str      =		image_processor(images=a_  ,			return_tensors='tf'					)

       # forward pass
       SCREAMING_SNAKE_CASE__					:					Tuple      =		model(**a_  ,			training=a_					)

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

       SCREAMING_SNAKE_CASE__					:					Any      =		tf.constant([-0.4180, -1.5051, -3.4836]					)

       tf.debugging.assert_near(outputs.logits[0, :3]  ,			a_  ,			atol=1e-4					)





from math import loga






def   lowerCamelCase__							(							__lowerCAmelCase    :    int							):




			"""simple docstring"""


			if a < 0:
						raise ValueError("Input value must be a positive integer"							)
			elif isinstance(__lowerCAmelCase       ,				__lowerCAmelCase							):
						raise TypeError("Input value must be a 'int' type"							)
			return 0 if (a == 0) else int(loga(a & -a							)							)


if __name__ == "__main__":
			import doctest

			doctest.testmod()



