



import gc
import unittest

from transformers import CTRLConfig, is_torch_available
from transformers.testing_utils import require_torch, slow, torch_device

from ...generation.test_utils import GenerationTesterMixin
from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, ids_tensor, random_attention_mask
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
							import torch

							from transformers import (
							    CTRL_PRETRAINED_MODEL_ARCHIVE_LIST,
							    CTRLForSequenceClassification,
							    CTRLLMHeadModel,
							    CTRLModel,
							)







class       __lowerCAmelCase   :



			def __init__(						self       :  int			,		A       :  str			,		A       :  Any=14			,		A       :  Any=7			,		A       :  int=True			,		A       :  Tuple=True			,		A       :  Optional[int]=True			,		A       :  Optional[Any]=True			,		A       :  Optional[int]=True			,		A       :  str=99			,		A       :  List[Any]=32			,		A       :  Dict=5			,		A       :  List[str]=4			,		A       :  Optional[Any]=37			,		A       :  Optional[int]="gelu"			,		A       :  Union[str, Any]=0.1			,		A       :  str=0.1			,		A       :  Optional[int]=5_12			,		A       :  Any=16			,		A       :  List[Any]=2			,		A       :  Union[str, Any]=0.0_2			,		A       :  List[str]=3			,		A       :  Any=4			,		A       :  Optional[int]=None			,		)       ->   Union[str, Any]:



						"""simple docstring"""






						_UpperCAmelCase			=       parent
						_UpperCAmelCase			=       batch_size
						_UpperCAmelCase			=       seq_length
						_UpperCAmelCase			=       is_training
						_UpperCAmelCase			=       use_token_type_ids
						_UpperCAmelCase			=       use_input_mask
						_UpperCAmelCase			=       use_labels
						_UpperCAmelCase			=       use_mc_token_ids
						_UpperCAmelCase			=       vocab_size
						_UpperCAmelCase			=       hidden_size
						_UpperCAmelCase			=       num_hidden_layers
						_UpperCAmelCase			=       num_attention_heads
						_UpperCAmelCase			=       intermediate_size
						_UpperCAmelCase			=       hidden_act
						_UpperCAmelCase			=       hidden_dropout_prob
						_UpperCAmelCase			=       attention_probs_dropout_prob
						_UpperCAmelCase			=       max_position_embeddings
						_UpperCAmelCase			=       type_vocab_size
						_UpperCAmelCase			=       type_sequence_label_size
						_UpperCAmelCase			=       initializer_range
						_UpperCAmelCase			=       num_labels
						_UpperCAmelCase			=       num_choices
						_UpperCAmelCase			=       scope
						_UpperCAmelCase			=       self.vocab_size - 1



			def    _lowerCamelCase	(						self       :  int)       ->   str:



						"""simple docstring"""






						_UpperCAmelCase			=       ids_tensor([self.batch_size, self.seq_length]			,		self.vocab_size)

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

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

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

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

						_UpperCAmelCase			=       self.get_config()

						_UpperCAmelCase			=       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    _lowerCamelCase	(						self       :  str)       ->   str:



						"""simple docstring"""






						return 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			,		)



			def    _lowerCamelCase	(						self       :  Optional[int]			,		A       :  Optional[int]			,		A       :  Dict			,		A       :  Tuple			,		A       :  Optional[Any]			,		A       :  Optional[int]			,		*A       :  Optional[Any])       ->   List[str]:



						"""simple docstring"""






						_UpperCAmelCase			=       CTRLModel(config=A)
						model.to(A)
						model.eval()

						model(A			,		token_type_ids=A			,		head_mask=A)
						model(A			,		token_type_ids=A)
						_UpperCAmelCase			=       model(A)
						self.parent.assertEqual(result.last_hidden_state.shape			,		(self.batch_size, self.seq_length, self.hidden_size))
						self.parent.assertEqual(len(result.past_key_values)			,		config.n_layer)



			def    _lowerCamelCase	(						self       :  List[Any]			,		A       :  str			,		A       :  Optional[Any]			,		A       :  int			,		A       :  Optional[int]			,		A       :  List[str]			,		*A       :  Tuple)       ->   List[str]:



						"""simple docstring"""






						_UpperCAmelCase			=       CTRLLMHeadModel(A)
						model.to(A)
						model.eval()

						_UpperCAmelCase			=       model(A			,		token_type_ids=A			,		labels=A)
						self.parent.assertEqual(result.loss.shape			,		())
						self.parent.assertEqual(result.logits.shape			,		(self.batch_size, self.seq_length, self.vocab_size))



			def    _lowerCamelCase	(						self       :  List[str])       ->   str:



						"""simple docstring"""






						_UpperCAmelCase			=       self.prepare_config_and_inputs()

						(
						    (
						    _UpperCAmelCase					
						)	,					(
						    _UpperCAmelCase					
						)	,					(
						    _UpperCAmelCase					
						)	,					(
						    _UpperCAmelCase					
						)	,					(
						    _UpperCAmelCase					
						)	,					(
						    _UpperCAmelCase					
						)	,					(
						    _UpperCAmelCase					
						)	,					(
						    _UpperCAmelCase					
						)	,					(
						    _UpperCAmelCase					
						)	,										
						)			=       config_and_inputs

						_UpperCAmelCase			=       {'input_ids': input_ids, 'token_type_ids': token_type_ids, 'head_mask': head_mask}

						return config, inputs_dict



			def    _lowerCamelCase	(						self       :  Dict			,		A       :  Optional[int]			,		A       :  int			,		A       :  Optional[int]			,		A       :  Union[str, Any]			,		*A       :  Optional[Any])       ->   List[str]:



						"""simple docstring"""






						_UpperCAmelCase			=       self.num_labels
						_UpperCAmelCase			=       CTRLForSequenceClassification(A)
						model.to(A)
						model.eval()
						_UpperCAmelCase			=       ids_tensor([self.batch_size]			,		self.type_sequence_label_size)
						_UpperCAmelCase			=       model(A			,		token_type_ids=A			,		labels=A)
						self.parent.assertEqual(result.logits.shape			,		(self.batch_size, self.num_labels))







@require_torch
class       __lowerCAmelCase   (      A    ,						A    ,						A    ,						unittest.TestCase						):
			UpperCamelCase        =					(CTRLModel, CTRLLMHeadModel, CTRLForSequenceClassification) if is_torch_available() else ()
			UpperCamelCase        =					(CTRLLMHeadModel,) if is_torch_available() else ()
			UpperCamelCase        =					(
			    {
			        '''feature-extraction''': CTRLModel,
			        '''text-classification''': CTRLForSequenceClassification,
			        '''text-generation''': CTRLLMHeadModel,
			        '''zero-shot''': CTRLForSequenceClassification,
			    }
			    if is_torch_available()
			    else {}
			)
			UpperCamelCase        =					True
			UpperCamelCase        =					False
			UpperCamelCase        =					False



			def    _lowerCamelCase	(						self       :  str			,		A       :  Dict			,		A       :  Tuple			,		A       :  List[str]			,		A       :  str			,		A       :  Optional[Any])       ->   Dict:



						"""simple docstring"""






						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    _lowerCamelCase	(						self       :  Dict)       ->   Any:



						"""simple docstring"""






						_UpperCAmelCase			=       CTRLModelTester(self)
						_UpperCAmelCase			=       ConfigTester(self			,		config_class=A			,		n_embd=37)



			def    _lowerCamelCase	(						self       :  Optional[Any])       ->   str:



						"""simple docstring"""






						super().tearDown()
						# clean-up as much as possible GPU memory occupied by PyTorch
						gc.collect()
						torch.cuda.empty_cache()



			def    _lowerCamelCase	(						self       :  Optional[Any])       ->   str:



						"""simple docstring"""






						self.config_tester.run_common_tests()



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



						"""simple docstring"""






						_UpperCAmelCase			=       self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_ctrl_model(*A)



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



						"""simple docstring"""






						_UpperCAmelCase			=       self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_lm_head_model(*A)



			@unittest.skip('Will be fixed soon by reducing the size of the model used for common tests.')
			def    _lowerCamelCase	(						self       :  List[Any])       ->   Optional[int]:



						"""simple docstring"""






						pass



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



						"""simple docstring"""






						for model_name in CTRL_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
									_UpperCAmelCase			=       CTRLModel.from_pretrained(A)
									self.assertIsNotNone(A)



			@unittest.skip('The model doesn\'t support left padding')  # and it's not used enough to be worth fixing :)
			def    _lowerCamelCase	(						self       :  List[str])       ->   str:



						"""simple docstring"""






						pass







@require_torch
class       __lowerCAmelCase   (      unittest.TestCase						):



			def    _lowerCamelCase	(						self       :  List[Any])       ->   str:



						"""simple docstring"""






						super().tearDown()
						# clean-up as much as possible GPU memory occupied by PyTorch
						gc.collect()
						torch.cuda.empty_cache()



			@slow
			def    _lowerCamelCase	(						self       :  Optional[Any])       ->   Union[str, Any]:



						"""simple docstring"""






						_UpperCAmelCase			=       CTRLLMHeadModel.from_pretrained('ctrl')
						model.to(A)
						_UpperCAmelCase			=       torch.tensor(
						    [[1_18_59, 0, 16_11, 8]]			,		dtype=torch.long			,		device=A)  # Legal the president is
						_UpperCAmelCase			=       [
						    1_18_59,
						    0,
						    16_11,
						    8,
						    5,
						    1_50,
						    2_64_49,
						    2,
						    19,
						    3_48,
						    4_69,
						    3,
						    25_95,
						    48,
						    2_07_40,
						    24_65_33,
						    24_65_33,
						    19,
						    30,
						    5,
						]  # Legal the president is a good guy and I don't want to lose my job. \n \n I have a

						_UpperCAmelCase			=       model.generate(A			,		do_sample=A)
						self.assertListEqual(output_ids[0].tolist()			,		A)











from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_flax_available,
    is_tf_available,
    is_tokenizers_available,
    is_torch_available,
    is_vision_available,
)


UpperCAmelCase__       =	{
    "configuration_clip": [
        "CLIP_PRETRAINED_CONFIG_ARCHIVE_MAP",
        "CLIPConfig",
        "CLIPOnnxConfig",
        "CLIPTextConfig",
        "CLIPVisionConfig",
    ],
    "processing_clip": ["CLIPProcessor"],
    "tokenization_clip": ["CLIPTokenizer"],
}

try:
							if not is_tokenizers_available():
														raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
							pass
else:
							UpperCAmelCase__       =	["CLIPTokenizerFast"]

try:
							if not is_vision_available():
														raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
							pass
else:
							UpperCAmelCase__       =	["CLIPFeatureExtractor"]
							UpperCAmelCase__       =	["CLIPImageProcessor"]

try:
							if not is_torch_available():
														raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
							pass
else:
							UpperCAmelCase__       =	[
							    "CLIP_PRETRAINED_MODEL_ARCHIVE_LIST",
							    "CLIPModel",
							    "CLIPPreTrainedModel",
							    "CLIPTextModel",
							    "CLIPTextModelWithProjection",
							    "CLIPVisionModel",
							    "CLIPVisionModelWithProjection",
							]

try:
							if not is_tf_available():
														raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
							pass
else:
							UpperCAmelCase__       =	[
							    "TF_CLIP_PRETRAINED_MODEL_ARCHIVE_LIST",
							    "TFCLIPModel",
							    "TFCLIPPreTrainedModel",
							    "TFCLIPTextModel",
							    "TFCLIPVisionModel",
							]

try:
							if not is_flax_available():
														raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
							pass
else:
							UpperCAmelCase__       =	[
							    "FlaxCLIPModel",
							    "FlaxCLIPPreTrainedModel",
							    "FlaxCLIPTextModel",
							    "FlaxCLIPTextPreTrainedModel",
							    "FlaxCLIPVisionModel",
							    "FlaxCLIPVisionPreTrainedModel",
							]


if TYPE_CHECKING:
							from .configuration_clip import (
							    CLIP_PRETRAINED_CONFIG_ARCHIVE_MAP,
							    CLIPConfig,
							    CLIPOnnxConfig,
							    CLIPTextConfig,
							    CLIPVisionConfig,
							)
							from .processing_clip import CLIPProcessor
							from .tokenization_clip import CLIPTokenizer

							try:
														if not is_tokenizers_available():
																					raise OptionalDependencyNotAvailable()
							except OptionalDependencyNotAvailable:
														pass
							else:
														from .tokenization_clip_fast import CLIPTokenizerFast

							try:
														if not is_vision_available():
																					raise OptionalDependencyNotAvailable()
							except OptionalDependencyNotAvailable:
														pass
							else:
														from .feature_extraction_clip import CLIPFeatureExtractor
														from .image_processing_clip import CLIPImageProcessor

							try:
														if not is_torch_available():
																					raise OptionalDependencyNotAvailable()
							except OptionalDependencyNotAvailable:
														pass
							else:
														from .modeling_clip import (
														    CLIP_PRETRAINED_MODEL_ARCHIVE_LIST,
														    CLIPModel,
														    CLIPPreTrainedModel,
														    CLIPTextModel,
														    CLIPTextModelWithProjection,
														    CLIPVisionModel,
														    CLIPVisionModelWithProjection,
														)

							try:
														if not is_tf_available():
																					raise OptionalDependencyNotAvailable()
							except OptionalDependencyNotAvailable:
														pass
							else:
														from .modeling_tf_clip import (
														    TF_CLIP_PRETRAINED_MODEL_ARCHIVE_LIST,
														    TFCLIPModel,
														    TFCLIPPreTrainedModel,
														    TFCLIPTextModel,
														    TFCLIPVisionModel,
														)

							try:
														if not is_flax_available():
																					raise OptionalDependencyNotAvailable()
							except OptionalDependencyNotAvailable:
														pass
							else:
														from .modeling_flax_clip import (
														    FlaxCLIPModel,
														    FlaxCLIPPreTrainedModel,
														    FlaxCLIPTextModel,
														    FlaxCLIPTextPreTrainedModel,
														    FlaxCLIPVisionModel,
														    FlaxCLIPVisionPreTrainedModel,
														)


else:
							import sys

							UpperCAmelCase__       =	_LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)
