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




							def __init__(				self   ,A__   ,A__=1_4   ,A__=7   ,A__=True   ,A__=True   ,A__=True   ,A__=True   ,A__=True   ,A__=9_9   ,A__=3_2   ,A__=5   ,A__=4   ,A__=3_7   ,A__="gelu"   ,A__=0.1   ,A__=0.1   ,A__=5_1_2   ,A__=1_6   ,A__=2   ,A__=0.02   ,A__=3   ,A__=4   ,A__=None   ,):
												lowercase							=						parent
												lowercase							=						batch_size
												lowercase							=						seq_length
												lowercase							=						is_training
												lowercase							=						use_token_type_ids
												lowercase							=						use_input_mask
												lowercase							=						use_labels
												lowercase							=						use_mc_token_ids
												lowercase							=						vocab_size
												lowercase							=						hidden_size
												lowercase							=						num_hidden_layers
												lowercase							=						num_attention_heads
												lowercase							=						intermediate_size
												lowercase							=						hidden_act
												lowercase							=						hidden_dropout_prob
												lowercase							=						attention_probs_dropout_prob
												lowercase							=						max_position_embeddings
												lowercase							=						type_vocab_size
												lowercase							=						type_sequence_label_size
												lowercase							=						initializer_range
												lowercase							=						num_labels
												lowercase							=						num_choices
												lowercase							=						scope
												lowercase							=						self.vocab_size - 1




							def  A__      (				self):
												lowercase							=						ids_tensor([self.batch_size, self.seq_length]   ,self.vocab_size)

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

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

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

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

												lowercase							=						self.get_config()

												lowercase							=						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  A__      (				self):
												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  A__      (				self   ,A__   ,A__   ,A__   ,A__   ,A__   ,*A__):
												lowercase							=						CTRLModel(config=A__)
												model.to(A__)
												model.eval()

												model(A__   ,token_type_ids=A__   ,head_mask=A__)
												model(A__   ,token_type_ids=A__)
												lowercase							=						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  A__      (				self   ,A__   ,A__   ,A__   ,A__   ,A__   ,*A__):
												lowercase							=						CTRLLMHeadModel(A__)
												model.to(A__)
												model.eval()

												lowercase							=						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  A__      (				self):
												lowercase							=						self.prepare_config_and_inputs()

												(
												    (
												    lowercase
												)	,						(
												    lowercase
												)	,						(
												    lowercase
												)	,						(
												    lowercase
												)	,						(
												    lowercase
												)	,						(
												    lowercase
												)	,						(
												    lowercase
												)	,						(
												    lowercase
												)	,						(
												    lowercase
												)	,						
												)							=						config_and_inputs

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

												return config, inputs_dict





							def  A__      (				self   ,A__   ,A__   ,A__   ,A__   ,*A__):
												lowercase							=						self.num_labels
												lowercase							=						CTRLForSequenceClassification(A__)
												model.to(A__)
												model.eval()
												lowercase							=						ids_tensor([self.batch_size]   ,self.type_sequence_label_size)
												lowercase							=						model(A__   ,token_type_ids=A__   ,labels=A__)
												self.parent.assertEqual(result.logits.shape   ,(self.batch_size, self.num_labels))







@require_torch
class 				lowercase		(					SCREAMING_SNAKE_CASE__       ,  SCREAMING_SNAKE_CASE__       ,  SCREAMING_SNAKE_CASE__       ,  unittest.TestCase		):
							lowercase_       :       List[Any]       					=(CTRLModel, CTRLLMHeadModel, CTRLForSequenceClassification) if is_torch_available() else ()
							lowercase_       :       Optional[Any]       					=(CTRLLMHeadModel,) if is_torch_available() else ()
							lowercase_       :       Dict       					=(
							    {
							        '''feature-extraction''': CTRLModel,
							        '''text-classification''': CTRLForSequenceClassification,
							        '''text-generation''': CTRLLMHeadModel,
							        '''zero-shot''': CTRLForSequenceClassification,
							    }
							    if is_torch_available()
							    else {}
							)
							lowercase_       :       Any       					=True
							lowercase_       :       Tuple       					=False
							lowercase_       :       List[Any]       					=False




							def  A__      (				self   ,A__   ,A__   ,A__   ,A__   ,A__):
												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  A__      (				self):
												lowercase							=						CTRLModelTester(self)
												lowercase							=						ConfigTester(self   ,config_class=A__   ,n_embd=3_7)




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




							def  A__      (				self):
												self.config_tester.run_common_tests()




							def  A__      (				self):
												lowercase							=						self.model_tester.prepare_config_and_inputs()
												self.model_tester.create_and_check_ctrl_model(*A__)




							def  A__      (				self):
												lowercase							=						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  A__      (				self):
												pass




							@slow
							def  A__      (				self):
												for model_name in CTRL_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
																	lowercase							=						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  A__      (				self):
												pass







@require_torch
class 				lowercase		(					unittest.TestCase		):




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





							@slow
							def  A__      (				self):
												lowercase							=						CTRLLMHeadModel.from_pretrained('''ctrl''')
												model.to(A__)
												lowercase							=						torch.tensor(
												    [[1_1_8_5_9, 0, 1_6_1_1, 8]]   ,dtype=torch.long   ,device=A__)  # Legal the president is
												lowercase							=						[
												    1_1_8_5_9,
												    0,
												    1_6_1_1,
												    8,
												    5,
												    1_5_0,
												    2_6_4_4_9,
												    2,
												    1_9,
												    3_4_8,
												    4_6_9,
												    3,
												    2_5_9_5,
												    4_8,
												    2_0_7_4_0,
												    2_4_6_5_3_3,
												    2_4_6_5_3_3,
												    1_9,
												    3_0,
												    5,
												]  # Legal the president is a good guy and I don't want to lose my job. \n \n I have a

												lowercase							=						model.generate(A__   ,do_sample=A__)
												self.assertListEqual(output_ids[0].tolist()   ,A__)






import os
import sys

lowercase__		:Tuple   =    os.path.join(os.path.dirname(__file__), "src")
sys.path.append(SRC_DIR)


from transformers import (
    AutoConfig,
    AutoModel,
    AutoModelForCausalLM,
    AutoModelForMaskedLM,
    AutoModelForQuestionAnswering,
    AutoModelForSequenceClassification,
    AutoTokenizer,
    add_start_docstrings,
)


lowercase__		:List[Any]   =    [
    "torch",
    "numpy",
    "tokenizers",
    "filelock",
    "requests",
    "tqdm",
    "regex",
    "sentencepiece",
    "sacremoses",
    "importlib_metadata",
    "huggingface_hub",
]



@add_start_docstrings(AutoConfig.__doc__		)
def        UpperCamelCase    (							*lowerCAmelCase__ ,			**lowerCAmelCase__		):
					'''simple docstring'''
					return AutoConfig.from_pretrained(*lowerCAmelCase__ ,			**lowerCAmelCase__		)



@add_start_docstrings(AutoTokenizer.__doc__		)
def        UpperCamelCase    (							*lowerCAmelCase__ ,			**lowerCAmelCase__		):
					'''simple docstring'''
					return AutoTokenizer.from_pretrained(*lowerCAmelCase__ ,			**lowerCAmelCase__		)



@add_start_docstrings(AutoModel.__doc__		)
def        UpperCamelCase    (							*lowerCAmelCase__ ,			**lowerCAmelCase__		):
					'''simple docstring'''
					return AutoModel.from_pretrained(*lowerCAmelCase__ ,			**lowerCAmelCase__		)



@add_start_docstrings(AutoModelForCausalLM.__doc__		)
def        UpperCamelCase    (							*lowerCAmelCase__ ,			**lowerCAmelCase__		):
					'''simple docstring'''
					return AutoModelForCausalLM.from_pretrained(*lowerCAmelCase__ ,			**lowerCAmelCase__		)



@add_start_docstrings(AutoModelForMaskedLM.__doc__		)
def        UpperCamelCase    (							*lowerCAmelCase__ ,			**lowerCAmelCase__		):
					'''simple docstring'''
					return AutoModelForMaskedLM.from_pretrained(*lowerCAmelCase__ ,			**lowerCAmelCase__		)



@add_start_docstrings(AutoModelForSequenceClassification.__doc__		)
def        UpperCamelCase    (							*lowerCAmelCase__ ,			**lowerCAmelCase__		):
					'''simple docstring'''
					return AutoModelForSequenceClassification.from_pretrained(*lowerCAmelCase__ ,			**lowerCAmelCase__		)



@add_start_docstrings(AutoModelForQuestionAnswering.__doc__		)
def        UpperCamelCase    (							*lowerCAmelCase__ ,			**lowerCAmelCase__		):
					'''simple docstring'''
					return AutoModelForQuestionAnswering.from_pretrained(*lowerCAmelCase__ ,			**lowerCAmelCase__		)




