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




 '''simple docstring'''





 def __init__(	self :			Any							,A :			Optional[int]							,A :			Optional[int]=3							,A :			str=32							,A :			Optional[int]=3							,A :			Tuple=10							,A :			Any=[10, 20, 30, 40]							,A :			List[str]=[1, 1, 2, 1]							,A :			Tuple=True							,A :			Dict=True							,A :			Union[str, Any]="relu"							,A :			List[Any]=3							,A :			List[str]=None							,):
     __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(A			)






 def     UpperCamelCase_  (	self :			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 :			Optional[int]			):
     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     UpperCamelCase_  (	self :			Tuple							,A :			Dict							,A :			int							,A :			Optional[int]			):
     __A             =			TFRegNetModel(config=A			)
     __A             =			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     UpperCamelCase_  (	self :			List[Any]							,A :			Tuple							,A :			List[Any]							,A :			Any			):
     __A             =			self.num_labels
     __A             =			TFRegNetForImageClassification(A			)
     __A             =			model(A							,labels=A							,training=A			)
     self.parent.assertEqual(result.logits.shape							,(self.batch_size, self.num_labels)			)







 def     UpperCamelCase_  (	self :			Optional[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 							UpperCAmelCase				(  __SCREAMING_SNAKE_CASE      ,      __SCREAMING_SNAKE_CASE      ,      unittest.TestCase  ):




 '''simple docstring'''





 snake_case_    =					(TFRegNetModel, TFRegNetForImageClassification) if is_tf_available() else ()
 snake_case_    =					(
     {"feature-extraction": TFRegNetModel, "image-classification": TFRegNetForImageClassification}
     if is_tf_available()
     else {}
 )

 snake_case_    =					False
 snake_case_    =					False
 snake_case_    =					False
 snake_case_    =					False
 snake_case_    =					False






 def     UpperCamelCase_  (	self :			Optional[int]			):
     __A             =			TFRegNetModelTester(self			)
     __A             =			ConfigTester(self							,config_class=A							,has_text_modality=A			)






 def     UpperCamelCase_  (	self :			Union[str, Any]			):
     return






 @unittest.skip(reason="RegNet does not use inputs_embeds"			)
 def     UpperCamelCase_  (	self :			List[str]			):
     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     UpperCamelCase_  (	self :			Optional[int]			):
     super().test_keras_fit()






 @unittest.skip(reason="RegNet does not support input and output embeddings"			)
 def     UpperCamelCase_  (	self :			str			):
     pass






 def     UpperCamelCase_  (	self :			Optional[int]			):
     __A      ,							__A             =			self.model_tester.prepare_config_and_inputs_for_common()

     for model_class in self.all_model_classes:
         __A             =			model_class(A			)
         __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]							,A			)






 def     UpperCamelCase_  (	self :			Dict			):
     __A             =			self.model_tester.prepare_config_and_inputs()
     self.model_tester.create_and_check_model(*A			)






 def     UpperCamelCase_  (	self :			Any			):
     def check_hidden_states_output(A :			int							,A :			List[Any]							,A :			int			):
         __A             =			model_class(A			)
         __A             =			model(**self._prepare_for_class(A							,A			)							,training=A			)

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

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

     __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(A							,A							,A			)

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

             check_hidden_states_output(A							,A							,A			)






 def     UpperCamelCase_  (	self :			str			):
     __A      ,							__A             =			self.model_tester.prepare_config_and_inputs_for_common()

     def check_equivalence(A :			Union[str, Any]							,A :			Union[str, Any]							,A :			List[Any]							,A :			int={}			):
         __A             =			model(A							,return_dict=A							,**A			)
         __A             =			model(A							,return_dict=A							,**A			).to_tuple()

         def recursive_check(A :			Union[str, Any]							,A :			str			):
             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:
         __A             =			model_class(A			)

         __A             =			self._prepare_for_class(A							,A			)
         __A             =			self._prepare_for_class(A							,A			)
         check_equivalence(A							,A							,A			)

         __A             =			self._prepare_for_class(A							,A							,return_labels=A			)
         __A             =			self._prepare_for_class(A							,A							,return_labels=A			)
         check_equivalence(A							,A							,A			)

         __A             =			self._prepare_for_class(A							,A			)
         __A             =			self._prepare_for_class(A							,A			)
         check_equivalence(A							,A							,A							,{"output_hidden_states": True}			)

         __A             =			self._prepare_for_class(A							,A							,return_labels=A			)
         __A             =			self._prepare_for_class(A							,A							,return_labels=A			)
         check_equivalence(A							,A							,A							,{"output_hidden_states": True}			)






 def     UpperCamelCase_  (	self :			Any			):
     __A             =			self.model_tester.prepare_config_and_inputs()
     self.model_tester.create_and_check_for_image_classification(*A			)







 @slow
 def     UpperCamelCase_  (	self :			Tuple			):
     for model_name in TF_REGNET_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
         __A             =			TFRegNetModel.from_pretrained(A			)
         self.assertIsNotNone(A			)





def 						UpperCAmelCase      (     )		->     Dict:







    """simple docstring"""



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





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




 '''simple docstring'''





 @cached_property
 def     UpperCamelCase_  (	self :			Any			):
     return (
         AutoImageProcessor.from_pretrained(TF_REGNET_PRETRAINED_MODEL_ARCHIVE_LIST[0]			)
         if is_vision_available()
         else None
     )







 @slow
 def     UpperCamelCase_  (	self :			Union[str, Any]			):
     __A             =			TFRegNetForImageClassification.from_pretrained(TF_REGNET_PRETRAINED_MODEL_ARCHIVE_LIST[0]			)

     __A             =			self.default_image_processor
     __A             =			prepare_img()
     __A             =			image_processor(images=A							,return_tensors="tf"			)

     # forward pass
     __A             =			model(**A							,training=A			)

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

     __A             =			tf.constant([-0.41_80, -1.50_51, -3.48_36]			)

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


import warnings

from ...utils import logging
from .image_processing_clip import CLIPImageProcessor


SCREAMING_SNAKE_CASE							:Any										=    logging.get_logger(__name__)





class 							UpperCAmelCase				(  __SCREAMING_SNAKE_CASE  ):




	'''simple docstring'''





	def __init__(	self :			int							,*A :			Dict							,**A :			Dict			):
					warnings.warn(
					    "The class CLIPFeatureExtractor is deprecated and will be removed in version 5 of Transformers. Please"
					    " use CLIPImageProcessor instead."							,A							,)
					super().__init__(*A							,**A			)
