

from __future__ import annotations

import unittest

from transformers import CTRLConfig, is_tf_available
from transformers.testing_utils import require_tf, slow

from ...test_configuration_common import ConfigTester
from ...test_modeling_tf_common import TFModelTesterMixin, ids_tensor, random_attention_mask
from ...test_pipeline_mixin import PipelineTesterMixin


if is_tf_available():
	import tensorflow as tf

	from transformers.models.ctrl.modeling_tf_ctrl import (
	    TF_CTRL_PRETRAINED_MODEL_ARCHIVE_LIST,
	    TFCTRLForSequenceClassification,
	    TFCTRLLMHeadModel,
	    TFCTRLModel,
	)


class 			_SCREAMING_SNAKE_CASE      (  __lowerCAmelCase):







						def __init__(			self     ,						_SCREAMING_SNAKE_CASE     ,						)->							Any:
													lowerCamelCase_								=parent
													lowerCamelCase_								=13
													lowerCamelCase_								=7
													lowerCamelCase_								=True
													lowerCamelCase_								=True
													lowerCamelCase_								=True
													lowerCamelCase_								=True
													lowerCamelCase_								=True
													lowerCamelCase_								=99
													lowerCamelCase_								=32
													lowerCamelCase_								=2
													lowerCamelCase_								=4
													lowerCamelCase_								=37
													lowerCamelCase_								="""gelu"""
													lowerCamelCase_								=0.1
													lowerCamelCase_								=0.1
													lowerCamelCase_								=512
													lowerCamelCase_								=16
													lowerCamelCase_								=2
													lowerCamelCase_								=0.0_2
													lowerCamelCase_								=3
													lowerCamelCase_								=4
													lowerCamelCase_								=None
													lowerCamelCase_								=self.vocab_size - 1







						def        _snake_case				(			self							)->							str:
													lowerCamelCase_								=ids_tensor([self.batch_size, self.seq_length]     ,						self.vocab_size							)

													lowerCamelCase_								=None
													if self.use_input_mask:
																				lowerCamelCase_								=random_attention_mask([self.batch_size, self.seq_length]							)

													lowerCamelCase_								=None
													if self.use_token_type_ids:
																				lowerCamelCase_								=ids_tensor([self.batch_size, self.seq_length]     ,						self.type_vocab_size							)

													lowerCamelCase_								=None
													if self.use_mc_token_ids:
																				lowerCamelCase_								=ids_tensor([self.batch_size, self.num_choices]     ,						self.seq_length							)

													lowerCamelCase_								=None
													lowerCamelCase_								=None
													lowerCamelCase_								=None
													if self.use_labels:
																				lowerCamelCase_								=ids_tensor([self.batch_size]     ,						self.type_sequence_label_size							)
																				lowerCamelCase_								=ids_tensor([self.batch_size, self.seq_length]     ,						self.num_labels							)
																				lowerCamelCase_								=ids_tensor([self.batch_size]     ,						self.num_choices							)

													lowerCamelCase_								=CTRLConfig(
													    vocab_size=self.vocab_size     ,						n_embd=self.hidden_size     ,						n_layer=self.num_hidden_layers     ,						n_head=self.num_attention_heads     ,						n_positions=self.max_position_embeddings     ,						pad_token_id=self.pad_token_id     ,						)

													lowerCamelCase_								=ids_tensor([self.num_hidden_layers, self.num_attention_heads]     ,						2							)

													return (
													    config,
													    input_ids,
													    input_mask,
													    head_mask,
													    token_type_ids,
													    mc_token_ids,
													    sequence_labels,
													    token_labels,
													    choice_labels,
													)







						def        _snake_case				(			self     ,						_SCREAMING_SNAKE_CASE     ,						_SCREAMING_SNAKE_CASE     ,						_SCREAMING_SNAKE_CASE     ,						_SCREAMING_SNAKE_CASE     ,						_SCREAMING_SNAKE_CASE     ,						*_SCREAMING_SNAKE_CASE							)->							Dict:
													lowerCamelCase_								=TFCTRLModel(config=lowercase_							)
													lowerCamelCase_								={"""input_ids""": input_ids, """attention_mask""": input_mask, """token_type_ids""": token_type_ids}
													lowerCamelCase_								=model(lowercase_							)

													lowerCamelCase_								=[input_ids, None, input_mask]  # None is the input for 'past'
													lowerCamelCase_								=model(lowercase_							)

													lowerCamelCase_								=model(lowercase_							)

													self.parent.assertEqual(result.last_hidden_state.shape     ,						(self.batch_size, self.seq_length, self.hidden_size)							)







						def        _snake_case				(			self     ,						_SCREAMING_SNAKE_CASE     ,						_SCREAMING_SNAKE_CASE     ,						_SCREAMING_SNAKE_CASE     ,						_SCREAMING_SNAKE_CASE     ,						_SCREAMING_SNAKE_CASE     ,						*_SCREAMING_SNAKE_CASE							)->							Tuple:
													lowerCamelCase_								=TFCTRLLMHeadModel(config=lowercase_							)
													lowerCamelCase_								={"""input_ids""": input_ids, """attention_mask""": input_mask, """token_type_ids""": token_type_ids}
													lowerCamelCase_								=model(lowercase_							)
													self.parent.assertEqual(result.logits.shape     ,						(self.batch_size, self.seq_length, self.vocab_size)							)







						def        _snake_case				(			self     ,						_SCREAMING_SNAKE_CASE     ,						_SCREAMING_SNAKE_CASE     ,						_SCREAMING_SNAKE_CASE     ,						_SCREAMING_SNAKE_CASE     ,						_SCREAMING_SNAKE_CASE     ,						*_SCREAMING_SNAKE_CASE							)->							Optional[Any]:
													lowerCamelCase_								=self.num_labels
													lowerCamelCase_								=ids_tensor([self.batch_size]     ,						self.type_sequence_label_size							)
													lowerCamelCase_								={
													    """input_ids""": input_ids,
													    """token_type_ids""": token_type_ids,
													    """labels""": sequence_labels,
													}
													lowerCamelCase_								=TFCTRLForSequenceClassification(lowercase_							)
													lowerCamelCase_								=model(lowercase_							)
													self.parent.assertEqual(result.logits.shape     ,						(self.batch_size, self.num_labels)							)







						def        _snake_case				(			self							)->							Dict:
													lowerCamelCase_								=self.prepare_config_and_inputs()

													(
													    (
													    lowerCamelCase_			
													)	,   (
													    lowerCamelCase_			
													)	,   (
													    lowerCamelCase_			
													)	,   (
													    lowerCamelCase_			
													)	,   (
													    lowerCamelCase_			
													)	,   (
													    lowerCamelCase_			
													)	,   (
													    lowerCamelCase_			
													)	,   (
													    lowerCamelCase_			
													)	,   (
													    lowerCamelCase_			
													)	,   			
													)								=config_and_inputs

													lowerCamelCase_								={"""input_ids""": input_ids, """token_type_ids""": token_type_ids, """attention_mask""": input_mask}
													return config, inputs_dict


@require_tf
class 			_SCREAMING_SNAKE_CASE      (  __lowerCAmelCase ,    __lowerCAmelCase ,    unittest.TestCase):
						_UpperCamelCase:str	=		(TFCTRLModel, TFCTRLLMHeadModel, TFCTRLForSequenceClassification) if is_tf_available() else ()
						_UpperCamelCase:int	=		(TFCTRLLMHeadModel,) if is_tf_available() else ()
						_UpperCamelCase:int	=		(
						    {
						        "feature-extraction": TFCTRLModel,
						        "text-classification": TFCTRLForSequenceClassification,
						        "text-generation": TFCTRLLMHeadModel,
						        "zero-shot": TFCTRLForSequenceClassification,
						    }
						    if is_tf_available()
						    else {}
						)
						_UpperCamelCase:List[Any]	=		False
						_UpperCamelCase:List[Any]	=		False







						def        _snake_case				(			self     ,						_SCREAMING_SNAKE_CASE     ,						_SCREAMING_SNAKE_CASE     ,						_SCREAMING_SNAKE_CASE     ,						_SCREAMING_SNAKE_CASE     ,						_SCREAMING_SNAKE_CASE							)->							Tuple:
													if pipeline_test_casse_name == "ZeroShotClassificationPipelineTests":
																				# Get `tokenizer does not have a padding token` error for both fast/slow tokenizers.
																				# `CTRLConfig` was never used in pipeline tests, either because of a missing checkpoint or because a tiny
																				# config could not be created.
																				return True

													return False







						def        _snake_case				(			self							)->							Optional[int]:
													lowerCamelCase_								=TFCTRLModelTester(self							)
													lowerCamelCase_								=ConfigTester(self     ,						config_class=lowercase_     ,						n_embd=37							)







						def        _snake_case				(			self							)->							Tuple:
													self.config_tester.run_common_tests()







						def        _snake_case				(			self							)->							Optional[Any]:
													lowerCamelCase_								=self.model_tester.prepare_config_and_inputs()
													self.model_tester.create_and_check_ctrl_model(*lowercase_							)







						def        _snake_case				(			self							)->							Any:
													lowerCamelCase_								=self.model_tester.prepare_config_and_inputs()
													self.model_tester.create_and_check_ctrl_lm_head(*lowercase_							)







						def        _snake_case				(			self							)->							List[str]:
													lowerCamelCase_								=self.model_tester.prepare_config_and_inputs()
													self.model_tester.create_and_check_ctrl_for_sequence_classification(*lowercase_							)







						def        _snake_case				(			self							)->							str:
													lowerCamelCase_	,   lowerCamelCase_								=self.model_tester.prepare_config_and_inputs_for_common()
													lowerCamelCase_								=[TFCTRLLMHeadModel]
													lowerCamelCase_								=[TFCTRLForSequenceClassification]

													for model_class in self.all_model_classes:
																				lowerCamelCase_								=model_class(lowercase_							)
																				model.build()  # may be needed for the get_bias() call below
																				assert isinstance(model.get_input_embeddings()     ,						tf.keras.layers.Layer							)

																				if model_class in list_lm_models:
																											lowerCamelCase_								=model.get_output_embeddings()
																											assert isinstance(lowercase_     ,						tf.keras.layers.Layer							)
																											lowerCamelCase_								=model.get_bias()
																											assert isinstance(lowercase_     ,						lowercase_							)
																											for k, v in name.items():
																																		assert isinstance(lowercase_     ,						tf.Variable							)
																				elif model_class in list_other_models_with_output_ebd:
																											lowerCamelCase_								=model.get_output_embeddings()
																											assert isinstance(lowercase_     ,						tf.keras.layers.Layer							)
																											lowerCamelCase_								=model.get_bias()
																											assert name is None
																				else:
																											lowerCamelCase_								=model.get_output_embeddings()
																											assert x is None
																											lowerCamelCase_								=model.get_bias()
																											assert name is None







						@slow
						def        _snake_case				(			self							)->							Tuple:
													for model_name in TF_CTRL_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
																				lowerCamelCase_								=TFCTRLModel.from_pretrained(lowercase_							)
																				self.assertIsNotNone(lowercase_							)


@require_tf
class 			_SCREAMING_SNAKE_CASE      (  unittest.TestCase):







						@slow
						def        _snake_case				(			self							)->							Optional[int]:
													lowerCamelCase_								=TFCTRLLMHeadModel.from_pretrained("""ctrl"""							)
													lowerCamelCase_								=tf.convert_to_tensor([[1_1859, 0, 1611, 8]]     ,						dtype=tf.intaa							)  # Legal the president is
													lowerCamelCase_								=[
													    1_1859,
													    0,
													    1611,
													    8,
													    5,
													    150,
													    2_6449,
													    2,
													    19,
													    348,
													    469,
													    3,
													    2595,
													    48,
													    2_0740,
													    24_6533,
													    24_6533,
													    19,
													    30,
													    5,
													]  # Legal the president is a good guy and I don't want to lose my job. \n \n I have a

													lowerCamelCase_								=model.generate(lowercase_     ,						do_sample=lowercase_							)
													self.assertListEqual(output_ids[0].numpy().tolist()     ,						lowercase_							)



'''simple docstring'''

from __future__ import annotations

import inspect
import unittest
from typing import List, Tuple

from transformers import ConvNextConfig
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 TFConvNextForImageClassification, TFConvNextModel


if is_vision_available():
						from PIL import Image

						from transformers import ConvNextImageProcessor







class lowerCamelCase   :

				def __init__(       self,						lowercase_,						lowercase_=13,						lowercase_=32,						lowercase_=3,						lowercase_=4,						lowercase_=[10, 20, 30, 40],						lowercase_=[2, 2, 3, 2],						lowercase_=True,						lowercase_=True,						lowercase_=37,						lowercase_="gelu",						lowercase_=10,						lowercase_=0.02,						lowercase_=3,						lowercase_=None,						)    ->							Dict:
					snake_case							=					parent
					snake_case							=					batch_size
					snake_case							=					image_size
					snake_case							=					num_channels
					snake_case							=					num_stages
					snake_case							=					hidden_sizes
					snake_case							=					depths
					snake_case							=					is_training
					snake_case							=					use_labels
					snake_case							=					intermediate_size
					snake_case							=					hidden_act
					snake_case							=					type_sequence_label_size
					snake_case							=					initializer_range
					snake_case							=					scope

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

					snake_case							=					None
					if self.use_labels:
						snake_case							=					ids_tensor([self.batch_size],						self.type_sequence_label_size )

					snake_case							=					self.get_config()

					return config, pixel_values, labels

				def 					_lowerCamelCase    (       self )    ->							Any:
					return ConvNextConfig(
					    num_channels=self.num_channels,						hidden_sizes=self.hidden_sizes,						depths=self.depths,						num_stages=self.num_stages,						hidden_act=self.hidden_act,						is_decoder=lowercase_,						initializer_range=self.initializer_range,						)

				def 					_lowerCamelCase    (       self,						lowercase_,						lowercase_,						lowercase_ )    ->							List[Any]:
					snake_case							=					TFConvNextModel(config=lowercase_ )
					snake_case							=					model(lowercase_,						training=lowercase_ )
					# 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,						lowercase_,						lowercase_,						lowercase_ )    ->							Union[str, Any]:
					snake_case							=					self.type_sequence_label_size
					snake_case							=					TFConvNextForImageClassification(lowercase_ )
					snake_case							=					model(lowercase_,						labels=lowercase_,						training=lowercase_ )
					self.parent.assertEqual(result.logits.shape,						(self.batch_size, self.type_sequence_label_size) )






				def 					_lowerCamelCase    (       self )    ->							Optional[int]:
					snake_case							=					self.prepare_config_and_inputs()
					snake_case			,			snake_case			,			snake_case							=					config_and_inputs
					snake_case							=					{'pixel_values': pixel_values}
					return config, inputs_dict







@require_tf
class lowerCamelCase   (    __lowerCAmelCase				,				__lowerCAmelCase				,				unittest.TestCase				):
				snake_case_							     = (TFConvNextModel, TFConvNextForImageClassification) if is_tf_available() else ()
				snake_case_							     = (
				    {'''feature-extraction''': TFConvNextModel, '''image-classification''': TFConvNextForImageClassification}
				    if is_tf_available()
				    else {}
				)

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

				def 					_lowerCamelCase    (       self )    ->							str:
					snake_case							=					TFConvNextModelTester(self )
					snake_case							=					ConfigTester(
					    self,						config_class=lowercase_,						has_text_modality=lowercase_,						hidden_size=37,						)

				@unittest.skip(reason='ConvNext does not use inputs_embeds' )
				def 					_lowerCamelCase    (       self )    ->							Tuple:
					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 					_lowerCamelCase    (       self )    ->							Optional[Any]:
					super().test_keras_fit()

				@unittest.skip(reason='ConvNext does not support input and output embeddings' )
				def 					_lowerCamelCase    (       self )    ->							Dict:
					pass

				def 					_lowerCamelCase    (       self )    ->							List[Any]:
					snake_case			,			snake_case							=					self.model_tester.prepare_config_and_inputs_for_common()

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

						snake_case							=					['pixel_values']
						self.assertListEqual(arg_names[:1],						lowercase_ )

				def 					_lowerCamelCase    (       self )    ->							str:
					snake_case							=					self.model_tester.prepare_config_and_inputs()
					self.model_tester.create_and_check_model(*lowercase_ )

				@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.',						)
				def 					_lowerCamelCase    (       self )    ->							Optional[int]:
					super().test_dataset_conversion()

				def 					_lowerCamelCase    (       self )    ->							Union[str, Any]:
					def check_hidden_states_output(lowercase_,						lowercase_,						lowercase_ ):
						snake_case							=					model_class(lowercase_ )

						snake_case							=					model(**self._prepare_for_class(lowercase_,						lowercase_ ) )
						snake_case							=					outputs.encoder_hidden_states if config.is_encoder_decoder else outputs.hidden_states

						snake_case							=					self.model_tester.num_stages
						self.assertEqual(len(lowercase_ ),						expected_num_stages + 1 )

						# ConvNext'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],						)

					snake_case			,			snake_case							=					self.model_tester.prepare_config_and_inputs_for_common()

					for model_class in self.all_model_classes:
						snake_case							=					True
						check_hidden_states_output(lowercase_,						lowercase_,						lowercase_ )

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

						check_hidden_states_output(lowercase_,						lowercase_,						lowercase_ )

				def 					_lowerCamelCase    (       self )    ->							Dict:
					snake_case			,			snake_case							=					self.model_tester.prepare_config_and_inputs_for_common()

					def check_equivalence(lowercase_,						lowercase_,						lowercase_,						lowercase_={} ):
						snake_case							=					model(lowercase_,						return_dict=lowercase_,						**lowercase_ )
						snake_case							=					model(lowercase_,						return_dict=lowercase_,						**lowercase_ ).to_tuple()

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

							recursive_check(lowercase_,						lowercase_ )

					for model_class in self.all_model_classes:
						snake_case							=					model_class(lowercase_ )

						snake_case							=					self._prepare_for_class(lowercase_,						lowercase_ )
						snake_case							=					self._prepare_for_class(lowercase_,						lowercase_ )
						check_equivalence(lowercase_,						lowercase_,						lowercase_ )

						snake_case							=					self._prepare_for_class(lowercase_,						lowercase_,						return_labels=lowercase_ )
						snake_case							=					self._prepare_for_class(lowercase_,						lowercase_,						return_labels=lowercase_ )
						check_equivalence(lowercase_,						lowercase_,						lowercase_ )

						snake_case							=					self._prepare_for_class(lowercase_,						lowercase_ )
						snake_case							=					self._prepare_for_class(lowercase_,						lowercase_ )
						check_equivalence(lowercase_,						lowercase_,						lowercase_,						{'output_hidden_states': True} )

						snake_case							=					self._prepare_for_class(lowercase_,						lowercase_,						return_labels=lowercase_ )
						snake_case							=					self._prepare_for_class(lowercase_,						lowercase_,						return_labels=lowercase_ )
						check_equivalence(lowercase_,						lowercase_,						lowercase_,						{'output_hidden_states': True} )

				def 					_lowerCamelCase    (       self )    ->							List[str]:
					snake_case							=					self.model_tester.prepare_config_and_inputs()
					self.model_tester.create_and_check_for_image_classification(*lowercase_ )






				@slow
				def 					_lowerCamelCase    (       self )    ->							str:
					snake_case							=					TFConvNextModel.from_pretrained('facebook/convnext-tiny-224' )
					self.assertIsNotNone(lowercase_ )

def      __magic_name__							(			)      ->		Optional[int]:
	snake_case							=					Image.open('./tests/fixtures/tests_samples/COCO/000000039769.png'				)
	return image







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

				@cached_property
				def 					_lowerCamelCase    (       self )    ->							List[str]:
					return ConvNextImageProcessor.from_pretrained('facebook/convnext-tiny-224' ) if is_vision_available() else None






				@slow
				def 					_lowerCamelCase    (       self )    ->							Dict:
					snake_case							=					TFConvNextForImageClassification.from_pretrained('facebook/convnext-tiny-224' )

					snake_case							=					self.default_image_processor
					snake_case							=					prepare_img()
					snake_case							=					image_processor(images=lowercase_,						return_tensors='tf' )

					# forward pass
					snake_case							=					model(**lowercase_ )

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

					snake_case							=					tf.constant([-0.0_260, -0.4_739, 0.1_911] )

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





