



'''simple docstring'''






import json
import os
from functools import lru_cache
from typing import List, Optional, Tuple

import regex as re

from ...tokenization_utils import AddedToken, PreTrainedTokenizer
from ...utils import logging


A_				:					Dict							=      logging.get_logger(__name__)


A_				:					List[str]							=      {"""vocab_file""": """vocab.json""", """merges_file""": """merges.txt"""}

# See all MVP models at https://huggingface.co/models?filter=mvp
A_				:					Tuple							=      {
    """vocab_file""": {
        """RUCAIBox/mvp""": """https://huggingface.co/RUCAIBox/mvp/resolve/main/vocab.json""",
    },
    """added_tokens.json""": {
        """RUCAIBox/mvp""": """https://huggingface.co/RUCAIBox/mvp/resolve/main/added_tokens.json""",
    },
    """merges_file""": {
        """RUCAIBox/mvp""": """https://huggingface.co/RUCAIBox/mvp/resolve/main/merges.txt""",
    },
}

A_				:					Dict							=      {
    """RUCAIBox/mvp""": 1_0_2_4,
}




@lru_cache()
def        snake_case_   (	)->						int:





       '''simple docstring'''


       _UpperCAmelCase    :		Union[str, Any]     	=					(
           list(range(ord("""!"""						)			,  ord("""~"""						) + 1						)						) + list(range(ord("""¡"""						)			,  ord("""¬"""						) + 1						)						) + list(range(ord("""®"""						)			,  ord("""ÿ"""						) + 1						)						)
       )
       _UpperCAmelCase    :		List[str]     	=					bs[:]
       _UpperCAmelCase    :		Optional[Any]     	=					0
       for b in range(2**8						):
              if b not in bs:
                     bs.append(lowerCAmelCase_						)
                     cs.append(2**8 + n						)
                     n += 1
       _UpperCAmelCase    :		Any     	=					[chr(lowerCAmelCase_						) for n in cs]
       return dict(zip(lowerCAmelCase_			,  lowerCAmelCase_						)						)




def        snake_case_   (	lowerCAmelCase_						)->						str:





       '''simple docstring'''


       _UpperCAmelCase    :		Dict     	=					set()
       _UpperCAmelCase    :		int     	=					word[0]
       for char in word[1:]:
              pairs.add((prev_char, char)						)
              _UpperCAmelCase    :		Union[str, Any]     	=					char
       return pairs



class 				lowercase			(    _lowerCamelCase							):


 """simple docstring"""


 UpperCAmelCase		      =    VOCAB_FILES_NAMES
 UpperCAmelCase		      =    PRETRAINED_VOCAB_FILES_MAP
 UpperCAmelCase		      =    PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
 UpperCAmelCase		      =    ["""input_ids""", """attention_mask"""]







 def __init__(				self    ,a_    ,a_    ,a_="replace"    ,a_="<s>"    ,a_="</s>"    ,a_="</s>"    ,a_="<s>"    ,a_="<unk>"    ,a_="<pad>"    ,a_="<mask>"    ,a_=False    ,**a_    ,)						->  Any:
        _UpperCAmelCase    :		Optional[Any]     	=					AddedToken(a_    ,lstrip=a_    ,rstrip=a_				) if isinstance(a_    ,a_				) else bos_token
        _UpperCAmelCase    :		List[Any]     	=					AddedToken(a_    ,lstrip=a_    ,rstrip=a_				) if isinstance(a_    ,a_				) else eos_token
        _UpperCAmelCase    :		Union[str, Any]     	=					AddedToken(a_    ,lstrip=a_    ,rstrip=a_				) if isinstance(a_    ,a_				) else sep_token
        _UpperCAmelCase    :		List[str]     	=					AddedToken(a_    ,lstrip=a_    ,rstrip=a_				) if isinstance(a_    ,a_				) else cls_token
        _UpperCAmelCase    :		Any     	=					AddedToken(a_    ,lstrip=a_    ,rstrip=a_				) if isinstance(a_    ,a_				) else unk_token
        _UpperCAmelCase    :		Optional[int]     	=					AddedToken(a_    ,lstrip=a_    ,rstrip=a_				) if isinstance(a_    ,a_				) else pad_token

        # Mask token behave like a normal word, i.e. include the space before it
        _UpperCAmelCase    :		str     	=					AddedToken(a_    ,lstrip=a_    ,rstrip=a_				) if isinstance(a_    ,a_				) else mask_token

        super().__init__(
            errors=a_    ,bos_token=a_    ,eos_token=a_    ,unk_token=a_    ,sep_token=a_    ,cls_token=a_    ,pad_token=a_    ,mask_token=a_    ,add_prefix_space=a_    ,**a_    ,)
        with open(a_    ,encoding="""utf-8"""				) as vocab_handle:
               _UpperCAmelCase    :		Any     	=					json.load(a_				)
        _UpperCAmelCase    :		Optional[Any]     	=					{v: k for k, v in self.encoder.items()}
        _UpperCAmelCase    :		Any     	=					errors  # how to handle errors in decoding
        _UpperCAmelCase    :		Optional[Any]     	=					bytes_to_unicode()
        _UpperCAmelCase    :		Optional[Any]     	=					{v: k for k, v in self.byte_encoder.items()}
        with open(a_    ,encoding="""utf-8"""				) as merges_handle:
               _UpperCAmelCase    :		Optional[int]     	=					merges_handle.read().split("""\n"""				)[1:-1]
        _UpperCAmelCase    :		List[str]     	=					[tuple(merge.split()				) for merge in bpe_merges]
        _UpperCAmelCase    :		Optional[Any]     	=					dict(zip(a_    ,range(len(a_				)				)				)				)
        _UpperCAmelCase    :		List[Any]     	=					{}
        _UpperCAmelCase    :		Union[str, Any]     	=					add_prefix_space

        # Should have added re.IGNORECASE so BPE merges can happen for capitalized versions of contractions
        _UpperCAmelCase    :		Optional[Any]     	=					re.compile(r"""'s|'t|'re|'ve|'m|'ll|'d| ?\p{L}+| ?\p{N}+| ?[^\s\p{L}\p{N}]+|\s+(?!\S)|\s+"""				)







 @property
 def _snake_case					(				self				)						->  str:
        return len(self.encoder				)







 def _snake_case					(				self				)						->  Dict:
        return dict(self.encoder    ,**self.added_tokens_encoder				)







 def _snake_case					(				self    ,a_				)						->  Optional[Any]:
        if token in self.cache:
               return self.cache[token]
        _UpperCAmelCase    :		Any     	=					tuple(a_				)
        _UpperCAmelCase    :		int     	=					get_pairs(a_				)

        if not pairs:
               return token

        while True:
               _UpperCAmelCase    :		Optional[Any]     	=					min(a_    ,key=lambda a_				: self.bpe_ranks.get(a_    ,float("""inf"""				)				)				)
               if bigram not in self.bpe_ranks:
                      break
               _UpperCAmelCase	,_UpperCAmelCase    :		Optional[Any]     	=					bigram
               _UpperCAmelCase    :		Optional[Any]     	=					[]
               _UpperCAmelCase    :		Optional[int]     	=					0
               while i < len(a_				):
                      try:
                             _UpperCAmelCase    :		int     	=					word.index(a_    ,a_				)
                      except ValueError:
                             new_word.extend(word[i:]				)
                             break
                      else:
                             new_word.extend(word[i:j]				)
                             _UpperCAmelCase    :		List[Any]     	=					j

                      if word[i] == first and i < len(a_				) - 1 and word[i + 1] == second:
                             new_word.append(first + second				)
                             i += 2
                      else:
                             new_word.append(word[i]				)
                             i += 1
               _UpperCAmelCase    :		str     	=					tuple(a_				)
               _UpperCAmelCase    :		List[str]     	=					new_word
               if len(a_				) == 1:
                      break
               else:
                      _UpperCAmelCase    :		Any     	=					get_pairs(a_				)
        _UpperCAmelCase    :		List[str]     	=					""" """.join(a_				)
        _UpperCAmelCase    :		List[Any]     	=					word
        return word







 def _snake_case					(				self    ,a_				)						->  Optional[int]:
        _UpperCAmelCase    :		str     	=					[]
        for token in re.findall(self.pat    ,a_				):
               _UpperCAmelCase    :		List[str]     	=					"""""".join(
                   self.byte_encoder[b] for b in token.encode("""utf-8"""				)				)  # Maps all our bytes to unicode strings, avoiding control tokens of the BPE (spaces in our case)
               bpe_tokens.extend(bpe_token for bpe_token in self.bpe(a_				).split(""" """				)				)
        return bpe_tokens







 def _snake_case					(				self    ,a_				)						->  Union[str, Any]:
        return self.encoder.get(a_    ,self.encoder.get(self.unk_token				)				)







 def _snake_case					(				self    ,a_				)						->  Optional[int]:
        return self.decoder.get(a_				)







 def _snake_case					(				self    ,a_				)						->  str:
        _UpperCAmelCase    :		Dict     	=					"""""".join(a_				)
        _UpperCAmelCase    :		str     	=					bytearray([self.byte_decoder[c] for c in text]				).decode("""utf-8"""    ,errors=self.errors				)
        return text







 def _snake_case					(				self    ,a_    ,a_ = None				)						->  Tuple[str]:
        if not os.path.isdir(a_				):
               logger.error(f'''Vocabulary path ({save_directory}) should be a directory'''				)
               return
        _UpperCAmelCase    :		Union[str, Any]     	=					os.path.join(
            a_    ,(filename_prefix + """-""" if filename_prefix else """""") + VOCAB_FILES_NAMES["""vocab_file"""]				)
        _UpperCAmelCase    :		Any     	=					os.path.join(
            a_    ,(filename_prefix + """-""" if filename_prefix else """""") + VOCAB_FILES_NAMES["""merges_file"""]				)

        with open(a_    ,"""w"""    ,encoding="""utf-8"""				) as f:
               f.write(json.dumps(self.encoder    ,indent=2    ,sort_keys=a_    ,ensure_ascii=a_				) + """\n"""				)

        _UpperCAmelCase    :		Optional[Any]     	=					0
        with open(a_    ,"""w"""    ,encoding="""utf-8"""				) as writer:
               writer.write("""#version: 0.2\n"""				)
               for bpe_tokens, token_index in sorted(self.bpe_ranks.items()    ,key=lambda a_				: kv[1]				):
                      if index != token_index:
                             logger.warning(
                                 f'''Saving vocabulary to {merge_file}: BPE merge indices are not consecutive.'''
                                 """ Please check that the tokenizer is not corrupted!"""				)
                             _UpperCAmelCase    :		Optional[Any]     	=					token_index
                      writer.write(""" """.join(a_				) + """\n"""				)
                      index += 1

        return vocab_file, merge_file







 def _snake_case					(				self    ,a_    ,a_ = None				)						->  List[int]:
        if token_ids_a is None:
               return [self.cls_token_id] + token_ids_a + [self.sep_token_id]
        _UpperCAmelCase    :		Union[str, Any]     	=					[self.cls_token_id]
        _UpperCAmelCase    :		Optional[int]     	=					[self.sep_token_id]
        return cls + token_ids_a + sep + sep + token_ids_a + sep







 def _snake_case					(				self    ,a_    ,a_ = None    ,a_ = False				)						->  List[int]:
        if already_has_special_tokens:
               return super().get_special_tokens_mask(
                   token_ids_a=a_    ,token_ids_a=a_    ,already_has_special_tokens=a_				)

        if token_ids_a is None:
               return [1] + ([0] * len(a_				)) + [1]
        return [1] + ([0] * len(a_				)) + [1, 1] + ([0] * len(a_				)) + [1]







 def _snake_case					(				self    ,a_    ,a_ = None				)						->  List[int]:
        _UpperCAmelCase    :		str     	=					[self.sep_token_id]
        _UpperCAmelCase    :		Union[str, Any]     	=					[self.cls_token_id]

        if token_ids_a is None:
               return len(cls + token_ids_a + sep				) * [0]
        return len(cls + token_ids_a + sep + sep + token_ids_a + sep				) * [0]







 def _snake_case					(				self    ,a_    ,a_=False    ,**a_				)						->  int:
        _UpperCAmelCase    :		Any     	=					kwargs.pop("""add_prefix_space"""    ,self.add_prefix_space				)
        if (is_split_into_words or add_prefix_space) and (len(a_				) > 0 and not text[0].isspace()):
               _UpperCAmelCase    :		Dict     	=					""" """ + text
        return (text, kwargs)




"""simple docstring"""







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



   '''simple docstring'''



   def __init__(	self ,				_SCREAMING_SNAKE_CASE ,				):


      '''simple docstring'''

      __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.02
      __lowerCamelCase    		=					3
      __lowerCamelCase    		=					4
      __lowerCamelCase    		=					None
      __lowerCamelCase    		=					self.vocab_size - 1







   def    _A				(	self	):


      '''simple docstring'''

      __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    _A				(	self ,				_SCREAMING_SNAKE_CASE ,				_SCREAMING_SNAKE_CASE ,				_SCREAMING_SNAKE_CASE ,				_SCREAMING_SNAKE_CASE ,				_SCREAMING_SNAKE_CASE ,				*_SCREAMING_SNAKE_CASE	):


      '''simple docstring'''

      __lowerCamelCase    		=					TFCTRLModel(config=_SCREAMING_SNAKE_CASE	)
      __lowerCamelCase    		=					{'input_ids': input_ids, 'attention_mask': input_mask, 'token_type_ids': token_type_ids}
      __lowerCamelCase    		=					model(_SCREAMING_SNAKE_CASE	)

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

      __lowerCamelCase    		=					model(_SCREAMING_SNAKE_CASE	)

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







   def    _A				(	self ,				_SCREAMING_SNAKE_CASE ,				_SCREAMING_SNAKE_CASE ,				_SCREAMING_SNAKE_CASE ,				_SCREAMING_SNAKE_CASE ,				_SCREAMING_SNAKE_CASE ,				*_SCREAMING_SNAKE_CASE	):


      '''simple docstring'''

      __lowerCamelCase    		=					TFCTRLLMHeadModel(config=_SCREAMING_SNAKE_CASE	)
      __lowerCamelCase    		=					{'input_ids': input_ids, 'attention_mask': input_mask, 'token_type_ids': token_type_ids}
      __lowerCamelCase    		=					model(_SCREAMING_SNAKE_CASE	)
      self.parent.assertEqual(result.logits.shape ,				(self.batch_size, self.seq_length, self.vocab_size)	)







   def    _A				(	self ,				_SCREAMING_SNAKE_CASE ,				_SCREAMING_SNAKE_CASE ,				_SCREAMING_SNAKE_CASE ,				_SCREAMING_SNAKE_CASE ,				_SCREAMING_SNAKE_CASE ,				*_SCREAMING_SNAKE_CASE	):


      '''simple docstring'''

      __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(_SCREAMING_SNAKE_CASE	)
      __lowerCamelCase    		=					model(_SCREAMING_SNAKE_CASE	)
      self.parent.assertEqual(result.logits.shape ,				(self.batch_size, self.num_labels)	)







   def    _A				(	self	):


      '''simple docstring'''

      __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							(			UpperCAmelCase    ,				UpperCAmelCase    ,				unittest.TestCase				):



   '''simple docstring'''



   __UpperCAmelCase	:							Union[str, Any]    =    (TFCTRLModel, TFCTRLLMHeadModel, TFCTRLForSequenceClassification) if is_tf_available() else ()
   __UpperCAmelCase	:							List[str]    =    (TFCTRLLMHeadModel,) if is_tf_available() else ()
   __UpperCAmelCase	:							Dict    =    (
       {
           "feature-extraction": TFCTRLModel,
           "text-classification": TFCTRLForSequenceClassification,
           "text-generation": TFCTRLLMHeadModel,
           "zero-shot": TFCTRLForSequenceClassification,
       }
       if is_tf_available()
       else {}
   )
   __UpperCAmelCase	:							str    =    False
   __UpperCAmelCase	:							Tuple    =    False







   def    _A				(	self ,				_SCREAMING_SNAKE_CASE ,				_SCREAMING_SNAKE_CASE ,				_SCREAMING_SNAKE_CASE ,				_SCREAMING_SNAKE_CASE ,				_SCREAMING_SNAKE_CASE	):


      '''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    _A				(	self	):


      '''simple docstring'''

      __lowerCamelCase    		=					TFCTRLModelTester(self	)
      __lowerCamelCase    		=					ConfigTester(self ,				config_class=_SCREAMING_SNAKE_CASE ,				n_embd=37	)







   def    _A				(	self	):


      '''simple docstring'''

      self.config_tester.run_common_tests()







   def    _A				(	self	):


      '''simple docstring'''

      __lowerCamelCase    		=					self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_ctrl_model(*_SCREAMING_SNAKE_CASE	)







   def    _A				(	self	):


      '''simple docstring'''

      __lowerCamelCase    		=					self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_ctrl_lm_head(*_SCREAMING_SNAKE_CASE	)







   def    _A				(	self	):


      '''simple docstring'''

      __lowerCamelCase    		=					self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_ctrl_for_sequence_classification(*_SCREAMING_SNAKE_CASE	)







   def    _A				(	self	):


      '''simple docstring'''

      __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(_SCREAMING_SNAKE_CASE	)
         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(_SCREAMING_SNAKE_CASE ,				tf.keras.layers.Layer	)
            __lowerCamelCase    		=					model.get_bias()
            assert isinstance(_SCREAMING_SNAKE_CASE ,				_SCREAMING_SNAKE_CASE	)
            for k, v in name.items():
               assert isinstance(_SCREAMING_SNAKE_CASE ,				tf.Variable	)
         elif model_class in list_other_models_with_output_ebd:
            __lowerCamelCase    		=					model.get_output_embeddings()
            assert isinstance(_SCREAMING_SNAKE_CASE ,				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    _A				(	self	):


      '''simple docstring'''

      for model_name in TF_CTRL_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
         __lowerCamelCase    		=					TFCTRLModel.from_pretrained(_SCREAMING_SNAKE_CASE	)
         self.assertIsNotNone(_SCREAMING_SNAKE_CASE	)






@require_tf
class      _SCREAMING_SNAKE_CASE							(			unittest.TestCase				):



   '''simple docstring'''



   @slow
   def    _A				(	self	):


      '''simple docstring'''

      __lowerCamelCase    		=					TFCTRLLMHeadModel.from_pretrained('ctrl'	)
      __lowerCamelCase    		=					tf.convert_to_tensor([[11859, 0, 1611, 8]] ,				dtype=tf.intaa	)  # Legal the president is
      __lowerCamelCase    		=					[
          11859,
          0,
          1611,
          8,
          5,
          150,
          26449,
          2,
          19,
          348,
          469,
          3,
          2595,
          48,
          20740,
          246533,
          246533,
          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(_SCREAMING_SNAKE_CASE ,				do_sample=_SCREAMING_SNAKE_CASE	)
      self.assertListEqual(output_ids[0].numpy().tolist() ,				_SCREAMING_SNAKE_CASE	)






