


import os
import unicodedata
from shutil import copyfile
from typing import Any, Dict, List, Optional, Tuple

import sentencepiece as spm

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


snake_case    :   Dict	    =					logging.get_logger(__name__)

snake_case    :   List[str]	    =					{'''vocab_file''': '''spiece.model'''}

snake_case    :   Any	    =					{
    '''vocab_file''': {
        '''xlnet-base-cased''': '''https://huggingface.co/xlnet-base-cased/resolve/main/spiece.model''',
        '''xlnet-large-cased''': '''https://huggingface.co/xlnet-large-cased/resolve/main/spiece.model''',
    }
}

snake_case    :   List[Any]	    =					{
    '''xlnet-base-cased''': None,
    '''xlnet-large-cased''': None,
}

# Segments (not really needed)
snake_case    :   Dict	    =					0
snake_case    :   Union[str, Any]	    =					1
snake_case    :   Any	    =					2
snake_case    :   Optional[Any]	    =					3
snake_case    :   Tuple	    =					4







class 		_snake_case  (				_snake_case							):
 SCREAMING_SNAKE_CASE__				=	VOCAB_FILES_NAMES
 SCREAMING_SNAKE_CASE__				=	PRETRAINED_VOCAB_FILES_MAP
 SCREAMING_SNAKE_CASE__				=	PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
 SCREAMING_SNAKE_CASE__				=	'left'




 def __init__(		self ,  _lowerCamelCase ,  _lowerCamelCase=False ,  _lowerCamelCase=True ,  _lowerCamelCase=False ,  _lowerCamelCase="<s>" ,  _lowerCamelCase="</s>" ,  _lowerCamelCase="<unk>" ,  _lowerCamelCase="<sep>" ,  _lowerCamelCase="<pad>" ,  _lowerCamelCase="<cls>" ,  _lowerCamelCase="<mask>" ,  _lowerCamelCase=["<eop>", "<eod>"] ,  _lowerCamelCase = None ,  **_lowerCamelCase ,  ):
       # Mask token behave like a normal word, i.e. include the space before it
       a						:List[Any]										=	AddedToken(_lowerCamelCase ,  lstrip=_lowerCamelCase ,  rstrip=_lowerCamelCase   ) if isinstance(_lowerCamelCase ,  _lowerCamelCase   ) else mask_token

       a						:Union[str, Any]										=	{} if sp_model_kwargs is None else sp_model_kwargs

       super().__init__(
           do_lower_case=_lowerCamelCase ,  remove_space=_lowerCamelCase ,  keep_accents=_lowerCamelCase ,  bos_token=_lowerCamelCase ,  eos_token=_lowerCamelCase ,  unk_token=_lowerCamelCase ,  sep_token=_lowerCamelCase ,  pad_token=_lowerCamelCase ,  cls_token=_lowerCamelCase ,  mask_token=_lowerCamelCase ,  additional_special_tokens=_lowerCamelCase ,  sp_model_kwargs=self.sp_model_kwargs ,  **_lowerCamelCase ,  )

       a						:Dict										=	3

       a						:Optional[Any]										=	do_lower_case
       a						:List[Any]										=	remove_space
       a						:Tuple										=	keep_accents
       a						:Dict										=	vocab_file

       a						:Optional[int]										=	spm.SentencePieceProcessor(**self.sp_model_kwargs   )
       self.sp_model.Load(_lowerCamelCase   )




 @property
 def 	SCREAMING_SNAKE_CASE__    (		self   ):
       return len(self.sp_model   )




 def 	SCREAMING_SNAKE_CASE__    (		self   ):
       a						:Optional[int]										=	{self.convert_ids_to_tokens(_lowerCamelCase   ): i for i in range(self.vocab_size   )}
       vocab.update(self.added_tokens_encoder   )
       return vocab




 def __getstate__(		self   ):
       a						:List[str]										=	self.__dict__.copy()
       a						:str										=	None
       return state




 def __setstate__(		self ,  _lowerCamelCase   ):
       a						:List[str]										=	d

       # for backward compatibility
       if not hasattr(self ,  '''sp_model_kwargs'''   ):
             a						:Union[str, Any]										=	{}

       a						:Union[str, Any]										=	spm.SentencePieceProcessor(**self.sp_model_kwargs   )
       self.sp_model.Load(self.vocab_file   )




 def 	SCREAMING_SNAKE_CASE__    (		self ,  _lowerCamelCase   ):
       if self.remove_space:
             a						:Union[str, Any]										=	''' '''.join(inputs.strip().split()   )
       else:
             a						:Union[str, Any]										=	inputs
       a						:List[Any]										=	outputs.replace('''``''' ,  '''"'''   ).replace('''\'\'''' ,  '''"'''   )

       if not self.keep_accents:
             a						:Tuple										=	unicodedata.normalize('''NFKD''' ,  _lowerCamelCase   )
             a						:Dict										=	''''''.join([c for c in outputs if not unicodedata.combining(_lowerCamelCase   )]   )
       if self.do_lower_case:
             a						:Dict										=	outputs.lower()

       return outputs




 def 	SCREAMING_SNAKE_CASE__    (		self ,  _lowerCamelCase   ):
       a						:List[str]										=	self.preprocess_text(_lowerCamelCase   )
       a						:Optional[Any]										=	self.sp_model.encode(_lowerCamelCase ,  out_type=_lowerCamelCase   )
       a						:Union[str, Any]										=	[]
       for piece in pieces:
             if len(_lowerCamelCase   ) > 1 and piece[-1] == str(''','''   ) and piece[-2].isdigit():
                   a						:List[Any]										=	self.sp_model.EncodeAsPieces(piece[:-1].replace(_lowerCamelCase ,  ''''''   )   )
                   if piece[0] != SPIECE_UNDERLINE and cur_pieces[0][0] == SPIECE_UNDERLINE:
                         if len(cur_pieces[0]   ) == 1:
                               a						:int										=	cur_pieces[1:]
                         else:
                               a						:int										=	cur_pieces[0][1:]
                   cur_pieces.append(piece[-1]   )
                   new_pieces.extend(_lowerCamelCase   )
             else:
                   new_pieces.append(_lowerCamelCase   )

       return new_pieces




 def 	SCREAMING_SNAKE_CASE__    (		self ,  _lowerCamelCase   ):
       return self.sp_model.PieceToId(_lowerCamelCase   )




 def 	SCREAMING_SNAKE_CASE__    (		self ,  _lowerCamelCase   ):
       return self.sp_model.IdToPiece(_lowerCamelCase   )




 def 	SCREAMING_SNAKE_CASE__    (		self ,  _lowerCamelCase   ):
       a						:Tuple										=	''''''.join(_lowerCamelCase   ).replace(_lowerCamelCase ,  ''' '''   ).strip()
       return out_string




 def 	SCREAMING_SNAKE_CASE__    (		self ,  _lowerCamelCase ,  _lowerCamelCase = False ,  _lowerCamelCase = None ,  _lowerCamelCase = True ,  **_lowerCamelCase ,  ):
       a						:Union[str, Any]										=	kwargs.pop('''use_source_tokenizer''' ,  _lowerCamelCase   )

       a						:Union[str, Any]										=	self.convert_ids_to_tokens(_lowerCamelCase ,  skip_special_tokens=_lowerCamelCase   )

       # To avoid mixing byte-level and unicode for byte-level BPT
       # we need to build string separately for added tokens and byte-level tokens
       # cf. https://github.com/huggingface/transformers/issues/1133
       a						:Dict										=	[]
       a						:Dict										=	[]
       for token in filtered_tokens:
             if skip_special_tokens and token in self.all_special_ids:
                   continue
             if token in self.added_tokens_encoder:
                   if current_sub_text:
                         sub_texts.append(self.convert_tokens_to_string(_lowerCamelCase   )   )
                         a						:Optional[int]										=	[]
                   sub_texts.append(_lowerCamelCase   )
             else:
                   current_sub_text.append(_lowerCamelCase   )
       if current_sub_text:
             sub_texts.append(self.convert_tokens_to_string(_lowerCamelCase   )   )

       # Mimic the behavior of the Rust tokenizer:
       # By default, there are no spaces between special tokens
       a						:Any										=	''''''.join(_lowerCamelCase   )

       a						:Union[str, Any]										=	(
           clean_up_tokenization_spaces
           if clean_up_tokenization_spaces is not None
           else self.clean_up_tokenization_spaces
       )
       if clean_up_tokenization_spaces:
             a						:Optional[Any]										=	self.clean_up_tokenization(_lowerCamelCase   )
             return clean_text
       else:
             return text




 def 	SCREAMING_SNAKE_CASE__    (		self ,  _lowerCamelCase ,  _lowerCamelCase = None   ):
       a						:Any										=	[self.sep_token_id]
       a						:Optional[Any]										=	[self.cls_token_id]
       if token_ids_a is None:
             return token_ids_a + sep + cls
       return token_ids_a + sep + token_ids_a + sep + cls




 def 	SCREAMING_SNAKE_CASE__    (		self ,  _lowerCamelCase ,  _lowerCamelCase = None ,  _lowerCamelCase = False   ):

       if already_has_special_tokens:
             return super().get_special_tokens_mask(
                 token_ids_a=_lowerCamelCase ,  token_ids_a=_lowerCamelCase ,  already_has_special_tokens=_lowerCamelCase   )

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




 def 	SCREAMING_SNAKE_CASE__    (		self ,  _lowerCamelCase ,  _lowerCamelCase = None   ):
       a						:str										=	[self.sep_token_id]
       a						:List[str]										=	[2]

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




 def 	SCREAMING_SNAKE_CASE__    (		self ,  _lowerCamelCase ,  _lowerCamelCase = None   ):
       if not os.path.isdir(_lowerCamelCase   ):
             logger.error(F'''Vocabulary path ({save_directory}) should be a directory'''   )
             return
       a						:Optional[int]										=	os.path.join(
           _lowerCamelCase ,  (filename_prefix + '''-''' if filename_prefix else '''''') + VOCAB_FILES_NAMES['''vocab_file''']   )

       if os.path.abspath(self.vocab_file   ) != os.path.abspath(_lowerCamelCase   ) and os.path.isfile(self.vocab_file   ):
             copyfile(self.vocab_file ,  _lowerCamelCase   )
       elif not os.path.isfile(self.vocab_file   ):
             with open(_lowerCamelCase ,  '''wb'''   ) as fi:
                   a						:List[str]										=	self.sp_model.serialized_model_proto()
                   fi.write(_lowerCamelCase   )

       return (out_vocab_file,)









from __future__ import annotations

import random
import unittest

from transformers import TransfoXLConfig, 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
from ...test_pipeline_mixin import PipelineTesterMixin


if is_tf_available():
     import tensorflow as tf

     from transformers import (
         TF_TRANSFO_XL_PRETRAINED_MODEL_ARCHIVE_LIST,
         TFTransfoXLForSequenceClassification,
         TFTransfoXLLMHeadModel,
         TFTransfoXLModel,
     )







class 		_snake_case  :




 def __init__(		self ,  _lowerCamelCase ,  ):
       a						:List[str]										=	parent
       a						:Dict										=	13
       a						:Optional[int]										=	7
       a						:Optional[Any]										=	30
       a						:Optional[Any]										=	self.seq_length + self.mem_len
       a						:Tuple										=	15
       a						:List[str]										=	True
       a						:List[Any]										=	True
       a						:List[Any]										=	99
       a						:Optional[Any]										=	[10, 50, 80]
       a						:Optional[int]										=	32
       a						:List[Any]										=	32
       a						:Dict										=	4
       a						:List[Any]										=	8
       a						:Optional[Any]										=	128
       a						:Dict										=	2
       a						:List[Any]										=	2
       a						:str										=	None
       a						:str										=	1
       a						:List[Any]										=	0
       a						:List[str]										=	3
       a						:str										=	self.vocab_size - 1
       a						:Optional[Any]										=	0.01




 def 	SCREAMING_SNAKE_CASE__    (		self   ):
       a						:Dict										=	ids_tensor([self.batch_size, self.seq_length] ,  self.vocab_size   )
       a						:Optional[Any]										=	ids_tensor([self.batch_size, self.seq_length] ,  self.vocab_size   )

       a						:Tuple										=	None
       if self.use_labels:
             a						:Tuple										=	ids_tensor([self.batch_size, self.seq_length] ,  self.vocab_size   )

       a						:Union[str, Any]										=	TransfoXLConfig(
           vocab_size=self.vocab_size ,  mem_len=self.mem_len ,  clamp_len=self.clamp_len ,  cutoffs=self.cutoffs ,  d_model=self.hidden_size ,  d_embed=self.d_embed ,  n_head=self.num_attention_heads ,  d_head=self.d_head ,  d_inner=self.d_inner ,  div_val=self.div_val ,  n_layer=self.num_hidden_layers ,  eos_token_id=self.eos_token_id ,  pad_token_id=self.vocab_size - 1 ,  init_range=self.init_range ,  num_labels=self.num_labels ,  )

       return (config, input_ids_a, input_ids_a, lm_labels)




 def 	SCREAMING_SNAKE_CASE__    (		self   ):
       random.seed(self.seed   )
       tf.random.set_seed(self.seed   )




 def 	SCREAMING_SNAKE_CASE__    (		self ,  _lowerCamelCase ,  _lowerCamelCase ,  _lowerCamelCase ,  _lowerCamelCase   ):
       a						:int										=	TFTransfoXLModel(_lowerCamelCase   )

       a							,    a						:List[Any]										=	model(_lowerCamelCase   ).to_tuple()

       a						:List[str]										=	{'''input_ids''': input_ids_a, '''mems''': mems_a}

       a							,    a						:Optional[int]										=	model(_lowerCamelCase   ).to_tuple()

       self.parent.assertEqual(hidden_states_a.shape ,  (self.batch_size, self.seq_length, self.hidden_size)   )
       self.parent.assertEqual(hidden_states_a.shape ,  (self.batch_size, self.seq_length, self.hidden_size)   )
       self.parent.assertListEqual(
           [mem.shape for mem in mems_a] ,  [(self.mem_len, self.batch_size, self.hidden_size)] * self.num_hidden_layers ,  )
       self.parent.assertListEqual(
           [mem.shape for mem in mems_a] ,  [(self.mem_len, self.batch_size, self.hidden_size)] * self.num_hidden_layers ,  )




 def 	SCREAMING_SNAKE_CASE__    (		self ,  _lowerCamelCase ,  _lowerCamelCase ,  _lowerCamelCase ,  _lowerCamelCase   ):
       a						:str										=	TFTransfoXLLMHeadModel(_lowerCamelCase   )

       a							,    a						:Tuple										=	model(_lowerCamelCase   ).to_tuple()

       a						:Any										=	{'''input_ids''': input_ids_a, '''labels''': lm_labels}
       a							,    a						:Dict										=	model(_lowerCamelCase   ).to_tuple()

       a							,    a						:Dict										=	model([input_ids_a, mems_a]   ).to_tuple()

       a						:str										=	{'''input_ids''': input_ids_a, '''mems''': mems_a, '''labels''': lm_labels}

       a							,    a						:Any										=	model(_lowerCamelCase   ).to_tuple()

       self.parent.assertEqual(lm_logits_a.shape ,  (self.batch_size, self.seq_length, self.vocab_size)   )
       self.parent.assertListEqual(
           [mem.shape for mem in mems_a] ,  [(self.mem_len, self.batch_size, self.hidden_size)] * self.num_hidden_layers ,  )

       self.parent.assertEqual(lm_logits_a.shape ,  (self.batch_size, self.seq_length, self.vocab_size)   )
       self.parent.assertListEqual(
           [mem.shape for mem in mems_a] ,  [(self.mem_len, self.batch_size, self.hidden_size)] * self.num_hidden_layers ,  )




 def 	SCREAMING_SNAKE_CASE__    (		self ,  _lowerCamelCase ,  _lowerCamelCase ,  _lowerCamelCase ,  _lowerCamelCase   ):
       a						:Optional[Any]										=	TFTransfoXLForSequenceClassification(_lowerCamelCase   )
       a						:Any										=	model(_lowerCamelCase   )
       self.parent.assertEqual(result.logits.shape ,  (self.batch_size, self.num_labels)   )




 def 	SCREAMING_SNAKE_CASE__    (		self   ):
       a						:str										=	self.prepare_config_and_inputs()
       ((a)							,    (a)							,    (a)							,    (a))						:Optional[int]										=	config_and_inputs
       a						:Union[str, Any]										=	{'''input_ids''': input_ids_a}
       return config, inputs_dict







@require_tf
class 		_snake_case  (				_snake_case						,   _snake_case						,   unittest.TestCase							):
 SCREAMING_SNAKE_CASE__				=	(
     (TFTransfoXLModel, TFTransfoXLLMHeadModel, TFTransfoXLForSequenceClassification) if is_tf_available() else ()
 )
 SCREAMING_SNAKE_CASE__				=	() if is_tf_available() else ()
 SCREAMING_SNAKE_CASE__				=	(
     {
         'feature-extraction': TFTransfoXLModel,
         'text-classification': TFTransfoXLForSequenceClassification,
         'text-generation': TFTransfoXLLMHeadModel,
         'zero-shot': TFTransfoXLForSequenceClassification,
     }
     if is_tf_available()
     else {}
 )
 # TODO: add this test when TFTransfoXLLMHead has a linear output layer implemented
 SCREAMING_SNAKE_CASE__				=	False
 SCREAMING_SNAKE_CASE__				=	False
 SCREAMING_SNAKE_CASE__				=	False
 SCREAMING_SNAKE_CASE__				=	False




 def 	SCREAMING_SNAKE_CASE__    (		self ,  _lowerCamelCase ,  _lowerCamelCase ,  _lowerCamelCase ,  _lowerCamelCase ,  _lowerCamelCase   ):
       if pipeline_test_casse_name == "TextGenerationPipelineTests":
             # Get `ValueError: AttributeError: 'NoneType' object has no attribute 'new_ones'` or `AssertionError`.
             # `TransfoXLConfig` was never used in pipeline tests: cannot create a simple
             # tokenizer.
             return True

       return False




 def 	SCREAMING_SNAKE_CASE__    (		self   ):
       a						:str										=	TFTransfoXLModelTester(self   )
       a						:str										=	ConfigTester(self ,  config_class=_lowerCamelCase ,  d_embed=37   )




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




 def 	SCREAMING_SNAKE_CASE__    (		self   ):
       self.model_tester.set_seed()
       a						:str										=	self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_transfo_xl_model(*_lowerCamelCase   )




 def 	SCREAMING_SNAKE_CASE__    (		self   ):
       self.model_tester.set_seed()
       a						:Dict										=	self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_transfo_xl_lm_head(*_lowerCamelCase   )




 def 	SCREAMING_SNAKE_CASE__    (		self   ):
       a						:List[Any]										=	self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_transfo_xl_for_sequence_classification(*_lowerCamelCase   )




 def 	SCREAMING_SNAKE_CASE__    (		self   ):
       a							,    a						:Any										=	self.model_tester.prepare_config_and_inputs_for_common()
       a						:int										=	[TFTransfoXLForSequenceClassification]

       for model_class in self.all_model_classes:
             a						:Any										=	model_class(_lowerCamelCase   )
             assert isinstance(model.get_input_embeddings() ,  tf.keras.layers.Layer   )
             if model_class in list_other_models_with_output_ebd:
                   a						:Dict										=	model.get_output_embeddings()
                   assert isinstance(_lowerCamelCase ,  tf.keras.layers.Layer   )
                   a						:Dict										=	model.get_bias()
                   assert name is None
             else:
                   a						:int										=	model.get_output_embeddings()
                   assert x is None
                   a						:Optional[int]										=	model.get_bias()
                   assert name is None




 def 	SCREAMING_SNAKE_CASE__    (		self   ):
       # TODO JP: Make TransfoXL XLA compliant
       pass




 @slow
 def 	SCREAMING_SNAKE_CASE__    (		self   ):
       for model_name in TF_TRANSFO_XL_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
             a						:List[Any]										=	TFTransfoXLModel.from_pretrained(_lowerCamelCase   )
             self.assertIsNotNone(_lowerCamelCase   )




 @unittest.skip(reason='''This model doesn\'t play well with fit() due to not returning a single loss.'''   )
 def 	SCREAMING_SNAKE_CASE__    (		self   ):
       pass







@require_tf
class 		_snake_case  (				unittest.TestCase							):




 @unittest.skip('''Skip test until #12651 is resolved.'''   )
 @slow
 def 	SCREAMING_SNAKE_CASE__    (		self   ):
       a						:Any										=	TFTransfoXLLMHeadModel.from_pretrained('''transfo-xl-wt103'''   )
       # fmt: off
       a						:Union[str, Any]										=	tf.convert_to_tensor([[33,1297,2,1,1009,4,1109,1_1739,4762,358,5,25,245,22,1706,17,2_0098,5,3215,21,37,1110,3,13,1041,4,24,603,490,2,7_1477,2_0098,10_4447,2,2_0961,1,2604,4,1,329,3,6224,831,1_6002,2,8,603,7_8967,2_9546,23,803,20,25,416,5,8,232,4,277,6,1855,4601,3,2_9546,54,8,3609,5,5_7211,49,4,1,277,18,8,1755,1_5691,3,341,25,416,693,4_2573,71,17,401,94,31,1_7919,2,2_9546,7873,18,1,435,23,1_1011,755,5,5167,3,7983,98,84,2,2_9546,3267,8,3609,4,1,4865,1075,2,6087,71,6,346,8,5854,3,2_9546,824,1400,1868,2,19,160,2,311,8,5496,2,2_0920,17,25,1_5097,3,24,24,0]] ,  dtype=tf.intaa   )  # noqa: E231
       # fmt: on
       #  In 1991 , the remains of Russian Tsar Nicholas II and his family
       #  ( except for Alexei and Maria ) are discovered .
       #  The voice of Nicholas's young son , Tsarevich Alexei Nikolaevich , narrates the
       #  remainder of the story . 1883 Western Siberia ,
       #  a young Grigori Rasputin is asked by his father and a group of men to perform magic .
       #  Rasputin has a vision and denounces one of the men as a horse thief . Although his
       #  father initially slaps him for making such an accusation , Rasputin watches as the
       #  man is chased outside and beaten . Twenty years later , Rasputin sees a vision of
       #  the Virgin Mary , prompting him to become a priest . Rasputin quickly becomes famous ,
       #  with people , even a bishop , begging for his blessing . <eod> </s> <eos>

       # fmt: off
       a						:List[Any]										=	[33,1297,2,1,1009,4,1109,1_1739,4762,358,5,25,245,22,1706,17,2_0098,5,3215,21,37,1110,3,13,1041,4,24,603,490,2,7_1477,2_0098,10_4447,2,2_0961,1,2604,4,1,329,3,6224,831,1_6002,2,8,603,7_8967,2_9546,23,803,20,25,416,5,8,232,4,277,6,1855,4601,3,2_9546,54,8,3609,5,5_7211,49,4,1,277,18,8,1755,1_5691,3,341,25,416,693,4_2573,71,17,401,94,31,1_7919,2,2_9546,7873,18,1,435,23,1_1011,755,5,5167,3,7983,98,84,2,2_9546,3267,8,3609,4,1,4865,1075,2,6087,71,6,346,8,5854,3,2_9546,824,1400,1868,2,19,160,2,311,8,5496,2,2_0920,17,25,1_5097,3,24,24,0,33,1,1857,2,1,1009,4,1109,1_1739,4762,358,5,25,245,28,1110,3,13,1041,4,24,603,490,2,7_1477,2_0098,10_4447,2,2_0961,1,2604,4,1,329,3,0]  # noqa: E231
       # fmt: on
       #  In 1991, the remains of Russian Tsar Nicholas II and his family (
       #  except for Alexei and Maria ) are discovered. The voice of young son,
       #  Tsarevich Alexei Nikolaevich, narrates the remainder of the story.
       #  1883 Western Siberia, a young Grigori Rasputin is asked by his father
       #  and a group of men to perform magic. Rasputin has a vision and
       #  denounces one of the men as a horse thief. Although his father initially
       #  slaps him for making such an accusation, Rasputin watches as the man
       #  is chased outside and beaten. Twenty years later, Rasputin sees a vision
       #  of the Virgin Mary, prompting him to become a priest.
       #  Rasputin quickly becomes famous, with people, even a bishop, begging for
       #  his blessing. <unk> <unk> <eos> In the 1990s, the remains of Russian Tsar
       # Nicholas II and his family were discovered. The voice of <unk> young son,
       # Tsarevich Alexei Nikolaevich, narrates the remainder of the story.<eos>

       a						:Optional[Any]										=	model.generate(_lowerCamelCase ,  max_length=200 ,  do_sample=_lowerCamelCase   )
       self.assertListEqual(output_ids[0].numpy().tolist() ,  _lowerCamelCase   )





