'''simple docstring'''

import unittest

from transformers import PegasusTokenizer, PegasusTokenizerFast
from transformers.testing_utils import get_tests_dir, require_sentencepiece, require_tokenizers, require_torch, slow
from transformers.utils import cached_property

from ...test_tokenization_common import TokenizerTesterMixin


lowerCAmelCase_ : str									=      get_tests_dir("fixtures/test_sentencepiece_no_bos.model")





@require_sentencepiece
@require_tokenizers
class 							lowercase						(						__lowerCamelCase ,				unittest.TestCase ):
   lowerCamelCase_    					=PegasusTokenizer
   lowerCamelCase_    					=PegasusTokenizerFast
   lowerCamelCase_    					=True
   lowerCamelCase_    					=True


   def __UpperCAmelCase       (   self				:	Optional[int])      ->					Union[str, Any]:
         super().setUp()

         # We have a SentencePiece fixture for testing
         lowercase_     =      PegasusTokenizer(__lowerCAmelCase)
         tokenizer.save_pretrained(self.tmpdirname)


   @cached_property
   def __UpperCAmelCase       (   self				:	Optional[Any])      ->					Optional[int]:
         return PegasusTokenizer.from_pretrained("google/pegasus-large")


   def __UpperCAmelCase       (   self				:	Dict   ,		**__lowerCAmelCase				:	Tuple)      ->					PegasusTokenizer:
         return PegasusTokenizer.from_pretrained(self.tmpdirname   ,		**__lowerCAmelCase)


   def __UpperCAmelCase       (   self				:	int   ,		__lowerCAmelCase				:	Optional[int])      ->					List[str]:
         return ("This is a test", "This is a test")


   def __UpperCAmelCase       (   self				:	Union[str, Any])      ->					Tuple:
         lowercase_     =      "</s>"
         lowercase_     =      1

         self.assertEqual(self.get_tokenizer()._convert_token_to_id(__lowerCAmelCase)   ,		__lowerCAmelCase)
         self.assertEqual(self.get_tokenizer()._convert_id_to_token(__lowerCAmelCase)   ,		__lowerCAmelCase)


   def __UpperCAmelCase       (   self				:	Dict)      ->					Any:
         lowercase_     =      list(self.get_tokenizer().get_vocab().keys())

         self.assertEqual(vocab_keys[0]   ,		"<pad>")
         self.assertEqual(vocab_keys[1]   ,		"</s>")
         self.assertEqual(vocab_keys[-1]   ,		"v")
         self.assertEqual(len(__lowerCAmelCase)   ,		1103)


   def __UpperCAmelCase       (   self				:	Optional[int])      ->					int:
         self.assertEqual(self.get_tokenizer().vocab_size   ,		1103)


   def __UpperCAmelCase       (   self				:	List[Any])      ->					Optional[int]:
         lowercase_     =      self.rust_tokenizer_class.from_pretrained(self.tmpdirname)
         lowercase_     =      self.tokenizer_class.from_pretrained(self.tmpdirname)
         lowercase_     =      (
             "Let's see which <unk> is the better <unk_token_11> one <mask_1> It seems like this <mask_2> was important"
             " </s> <pad> <pad> <pad>"
         )
         lowercase_     =      rust_tokenizer([raw_input_str]   ,		return_tensors=__lowerCAmelCase   ,		add_special_tokens=__lowerCAmelCase).input_ids[0]
         lowercase_     =      py_tokenizer([raw_input_str]   ,		return_tensors=__lowerCAmelCase   ,		add_special_tokens=__lowerCAmelCase).input_ids[0]
         self.assertListEqual(__lowerCAmelCase   ,		__lowerCAmelCase)


   def __UpperCAmelCase       (   self				:	Dict)      ->					Optional[Any]:
         lowercase_     =      self._large_tokenizer
         # <mask_1> masks whole sentence while <mask_2> masks single word
         lowercase_     =      "<mask_1> To ensure a <mask_2> flow of bank resolutions."
         lowercase_     =      [2, 413, 615, 114, 3, 1971, 113, 1679, 1_0710, 107, 1]
         lowercase_     =      tokenizer([raw_input_str]   ,		return_tensors=__lowerCAmelCase).input_ids[0]
         self.assertListEqual(__lowerCAmelCase   ,		__lowerCAmelCase)


   def __UpperCAmelCase       (   self				:	List[Any])      ->					Optional[Any]:
         lowercase_     =      self._large_tokenizer
         # The tracebacks for the following asserts are **better** without messages or self.assertEqual
         assert tokenizer.vocab_size == 9_6103
         assert tokenizer.pad_token_id == 0
         assert tokenizer.eos_token_id == 1
         assert tokenizer.offset == 103
         assert tokenizer.unk_token_id == tokenizer.offset + 2 == 105
         assert tokenizer.unk_token == "<unk>"
         assert tokenizer.model_max_length == 1024
         lowercase_     =      "To ensure a smooth flow of bank resolutions."
         lowercase_     =      [413, 615, 114, 2291, 1971, 113, 1679, 1_0710, 107, 1]
         lowercase_     =      tokenizer([raw_input_str]   ,		return_tensors=__lowerCAmelCase).input_ids[0]
         self.assertListEqual(__lowerCAmelCase   ,		__lowerCAmelCase)
         assert tokenizer.convert_ids_to_tokens([0, 1, 2, 3]) == ["<pad>", "</s>", "<mask_1>", "<mask_2>"]


   @require_torch
   def __UpperCAmelCase       (   self				:	Any)      ->					Any:
         lowercase_     =      ["This is going to be way too long." * 150, "short example"]
         lowercase_     =      ["not super long but more than 5 tokens", "tiny"]
         lowercase_     =      self._large_tokenizer(__lowerCAmelCase   ,		padding=__lowerCAmelCase   ,		truncation=__lowerCAmelCase   ,		return_tensors="pt")
         lowercase_     =      self._large_tokenizer(
             text_target=__lowerCAmelCase   ,		max_length=5   ,		padding=__lowerCAmelCase   ,		truncation=__lowerCAmelCase   ,		return_tensors="pt")

         assert batch.input_ids.shape == (2, 1024)
         assert batch.attention_mask.shape == (2, 1024)
         assert targets["input_ids"].shape == (2, 5)
         assert len(__lowerCAmelCase) == 2  # input_ids, attention_mask.


   @slow
   def __UpperCAmelCase       (   self				:	List[Any])      ->					Tuple:
         # fmt: off
         lowercase_     =      {"input_ids": [[3_8979, 143, 1_8485, 606, 130, 2_6669, 8_7686, 121, 5_4189, 1129, 111, 2_6669, 8_7686, 121, 9114, 1_4787, 121, 1_3249, 158, 592, 956, 121, 1_4621, 3_1576, 143, 6_2613, 108, 9688, 930, 4_3430, 1_1562, 6_2613, 304, 108, 1_1443, 897, 108, 9314, 1_7415, 6_3399, 108, 1_1443, 7614, 1_8316, 118, 4284, 7148, 1_2430, 143, 1400, 2_5703, 158, 111, 4284, 7148, 1_1772, 143, 2_1297, 1064, 158, 122, 204, 3506, 1754, 1133, 1_4787, 1581, 115, 3_3224, 4482, 111, 1355, 110, 2_9173, 317, 5_0833, 108, 2_0147, 9_4665, 111, 7_7198, 107, 1], [110, 6_2613, 117, 638, 112, 1133, 121, 2_0098, 1355, 7_9050, 1_3872, 135, 1596, 5_3541, 1352, 141, 1_3039, 5542, 124, 302, 518, 111, 268, 2956, 115, 149, 4427, 107, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [139, 1235, 2799, 1_8289, 1_7780, 204, 109, 9474, 1296, 107, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]], "attention_mask": [[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]]}  # noqa: E501
         # fmt: on

         self.tokenizer_integration_test_util(
             expected_encoding=__lowerCAmelCase   ,		model_name="google/bigbird-pegasus-large-arxiv"   ,		revision="ba85d0851d708441f91440d509690f1ab6353415"   ,		)





@require_sentencepiece
@require_tokenizers
class 							lowercase						(						__lowerCamelCase ,				unittest.TestCase ):
   lowerCamelCase_    					=PegasusTokenizer
   lowerCamelCase_    					=PegasusTokenizerFast
   lowerCamelCase_    					=True
   lowerCamelCase_    					=True


   def __UpperCAmelCase       (   self				:	Tuple)      ->					Dict:
         super().setUp()

         # We have a SentencePiece fixture for testing
         lowercase_     =      PegasusTokenizer(__lowerCAmelCase   ,		offset=0   ,		mask_token_sent=__lowerCAmelCase   ,		mask_token="[MASK]")
         tokenizer.save_pretrained(self.tmpdirname)


   @cached_property
   def __UpperCAmelCase       (   self				:	Union[str, Any])      ->					int:
         return PegasusTokenizer.from_pretrained("google/bigbird-pegasus-large-arxiv")


   def __UpperCAmelCase       (   self				:	int   ,		**__lowerCAmelCase				:	List[str])      ->					PegasusTokenizer:
         return PegasusTokenizer.from_pretrained(self.tmpdirname   ,		**__lowerCAmelCase)


   def __UpperCAmelCase       (   self				:	Any   ,		__lowerCAmelCase				:	Dict)      ->					str:
         return ("This is a test", "This is a test")


   def __UpperCAmelCase       (   self				:	Tuple)      ->					Union[str, Any]:
         lowercase_     =      self.rust_tokenizer_class.from_pretrained(self.tmpdirname)
         lowercase_     =      self.tokenizer_class.from_pretrained(self.tmpdirname)
         lowercase_     =      (
             "Let's see which <unk> is the better <unk_token> one [MASK] It seems like this [MASK] was important </s>"
             " <pad> <pad> <pad>"
         )
         lowercase_     =      rust_tokenizer([raw_input_str]   ,		return_tensors=__lowerCAmelCase   ,		add_special_tokens=__lowerCAmelCase).input_ids[0]
         lowercase_     =      py_tokenizer([raw_input_str]   ,		return_tensors=__lowerCAmelCase   ,		add_special_tokens=__lowerCAmelCase).input_ids[0]
         self.assertListEqual(__lowerCAmelCase   ,		__lowerCAmelCase)


   @require_torch
   def __UpperCAmelCase       (   self				:	List[Any])      ->					Dict:
         lowercase_     =      ["This is going to be way too long." * 1000, "short example"]
         lowercase_     =      ["not super long but more than 5 tokens", "tiny"]
         lowercase_     =      self._large_tokenizer(__lowerCAmelCase   ,		padding=__lowerCAmelCase   ,		truncation=__lowerCAmelCase   ,		return_tensors="pt")
         lowercase_     =      self._large_tokenizer(
             text_target=__lowerCAmelCase   ,		max_length=5   ,		padding=__lowerCAmelCase   ,		truncation=__lowerCAmelCase   ,		return_tensors="pt")

         assert batch.input_ids.shape == (2, 4096)
         assert batch.attention_mask.shape == (2, 4096)
         assert targets["input_ids"].shape == (2, 5)
         assert len(__lowerCAmelCase) == 2  # input_ids, attention_mask.


   def __UpperCAmelCase       (   self				:	Tuple)      ->					Optional[int]:
         lowercase_     =      (
             "This is an example string that is used to test the original TF implementation against the HF"
             " implementation"
         )

         lowercase_     =      self._large_tokenizer(__lowerCAmelCase).input_ids

         self.assertListEqual(
             __lowerCAmelCase   ,		[182, 117, 142, 587, 4211, 120, 117, 263, 112, 804, 109, 856, 2_5016, 3137, 464, 109, 2_6955, 3137, 1]   ,		)







'''simple docstring'''

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				:	List[Any]   ,		__lowerCAmelCase				:	Optional[Any]   ,		__lowerCAmelCase				:	Any=14   ,		__lowerCAmelCase				:	Optional[Any]=7   ,		__lowerCAmelCase				:	List[str]=True   ,		__lowerCAmelCase				:	Optional[int]=True   ,		__lowerCAmelCase				:	Optional[Any]=True   ,		__lowerCAmelCase				:	Optional[Any]=True   ,		__lowerCAmelCase				:	Optional[Any]=True   ,		__lowerCAmelCase				:	Any=99   ,		__lowerCAmelCase				:	Tuple=32   ,		__lowerCAmelCase				:	Union[str, Any]=5   ,		__lowerCAmelCase				:	str=4   ,		__lowerCAmelCase				:	Dict=37   ,		__lowerCAmelCase				:	Optional[int]="gelu"   ,		__lowerCAmelCase				:	int=0.1   ,		__lowerCAmelCase				:	Tuple=0.1   ,		__lowerCAmelCase				:	str=512   ,		__lowerCAmelCase				:	Optional[Any]=16   ,		__lowerCAmelCase				:	Optional[int]=2   ,		__lowerCAmelCase				:	str=0.02   ,		__lowerCAmelCase				:	str=3   ,		__lowerCAmelCase				:	Tuple=4   ,		__lowerCAmelCase				:	Union[str, Any]=None   ,		)      ->					List[Any]:
         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 __UpperCAmelCase       (   self				:	Tuple)      ->					int:
         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 __UpperCAmelCase       (   self				:	Union[str, Any])      ->					int:
         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 __UpperCAmelCase       (   self				:	Union[str, Any]   ,		__lowerCAmelCase				:	Optional[Any]   ,		__lowerCAmelCase				:	Union[str, Any]   ,		__lowerCAmelCase				:	Union[str, Any]   ,		__lowerCAmelCase				:	Tuple   ,		__lowerCAmelCase				:	Union[str, Any]   ,		*__lowerCAmelCase				:	Tuple)      ->					List[str]:
         lowercase_     =      CTRLModel(config=__lowerCAmelCase)
         model.to(__lowerCAmelCase)
         model.eval()

         model(__lowerCAmelCase   ,		token_type_ids=__lowerCAmelCase   ,		head_mask=__lowerCAmelCase)
         model(__lowerCAmelCase   ,		token_type_ids=__lowerCAmelCase)
         lowercase_     =      model(__lowerCAmelCase)
         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 __UpperCAmelCase       (   self				:	List[Any]   ,		__lowerCAmelCase				:	Optional[int]   ,		__lowerCAmelCase				:	Union[str, Any]   ,		__lowerCAmelCase				:	Dict   ,		__lowerCAmelCase				:	int   ,		__lowerCAmelCase				:	Dict   ,		*__lowerCAmelCase				:	int)      ->					int:
         lowercase_     =      CTRLLMHeadModel(__lowerCAmelCase)
         model.to(__lowerCAmelCase)
         model.eval()

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


   def __UpperCAmelCase       (   self				:	Dict)      ->					int:
         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 __UpperCAmelCase       (   self				:	Any   ,		__lowerCAmelCase				:	Optional[int]   ,		__lowerCAmelCase				:	Optional[Any]   ,		__lowerCAmelCase				:	int   ,		__lowerCAmelCase				:	List[str]   ,		*__lowerCAmelCase				:	List[Any])      ->					int:
         lowercase_     =      self.num_labels
         lowercase_     =      CTRLForSequenceClassification(__lowerCAmelCase)
         model.to(__lowerCAmelCase)
         model.eval()
         lowercase_     =      ids_tensor([self.batch_size]   ,		self.type_sequence_label_size)
         lowercase_     =      model(__lowerCAmelCase   ,		token_type_ids=__lowerCAmelCase   ,		labels=__lowerCAmelCase)
         self.parent.assertEqual(result.logits.shape   ,		(self.batch_size, self.num_labels))





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


   def __UpperCAmelCase       (   self				:	Tuple   ,		__lowerCAmelCase				:	Dict   ,		__lowerCAmelCase				:	Dict   ,		__lowerCAmelCase				:	str   ,		__lowerCAmelCase				:	List[Any]   ,		__lowerCAmelCase				:	int)      ->					Optional[int]:
         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 __UpperCAmelCase       (   self				:	str)      ->					Tuple:
         lowercase_     =      CTRLModelTester(self)
         lowercase_     =      ConfigTester(self   ,		config_class=__lowerCAmelCase   ,		n_embd=37)


   def __UpperCAmelCase       (   self				:	Dict)      ->					Optional[Any]:
         super().tearDown()
         # clean-up as much as possible GPU memory occupied by PyTorch
         gc.collect()
         torch.cuda.empty_cache()


   def __UpperCAmelCase       (   self				:	str)      ->					List[Any]:
         self.config_tester.run_common_tests()


   def __UpperCAmelCase       (   self				:	Any)      ->					List[Any]:
         lowercase_     =      self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_ctrl_model(*__lowerCAmelCase)


   def __UpperCAmelCase       (   self				:	Tuple)      ->					Dict:
         lowercase_     =      self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_lm_head_model(*__lowerCAmelCase)


   @unittest.skip("Will be fixed soon by reducing the size of the model used for common tests.")
   def __UpperCAmelCase       (   self				:	Union[str, Any])      ->					Optional[Any]:
         pass


   @slow
   def __UpperCAmelCase       (   self				:	Dict)      ->					List[str]:
         for model_name in CTRL_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
               lowercase_     =      CTRLModel.from_pretrained(__lowerCAmelCase)
               self.assertIsNotNone(__lowerCAmelCase)


   @unittest.skip("The model doesn't support left padding")  # and it's not used enough to be worth fixing :)
   def __UpperCAmelCase       (   self				:	Optional[Any])      ->					Dict:
         pass





@require_torch
class 							lowercase						(						unittest.TestCase ):


   def __UpperCAmelCase       (   self				:	Optional[int])      ->					Any:
         super().tearDown()
         # clean-up as much as possible GPU memory occupied by PyTorch
         gc.collect()
         torch.cuda.empty_cache()


   @slow
   def __UpperCAmelCase       (   self				:	int)      ->					Any:
         lowercase_     =      CTRLLMHeadModel.from_pretrained("ctrl")
         model.to(__lowerCAmelCase)
         lowercase_     =      torch.tensor(
             [[1_1859, 0, 1611, 8]]   ,		dtype=torch.long   ,		device=__lowerCAmelCase)  # Legal the president is
         lowercase_     =      [
             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

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






