
'''simple docstring'''


import math
from typing import Any, Callable, List, Optional, Tuple, Union

import numpy as np
import torch

from ...models import TaFilmDecoder
from ...schedulers import DDPMScheduler
from ...utils import is_onnx_available, logging, randn_tensor


if is_onnx_available():
					from ..onnx_utils import OnnxRuntimeModel

from ..pipeline_utils import AudioPipelineOutput, DiffusionPipeline
from .continous_encoder import SpectrogramContEncoder
from .notes_encoder import SpectrogramNotesEncoder


__lowercase							:   Dict					=     logging.get_logger(__name__)  # pylint: disable=invalid-name

__lowercase							:   Tuple					=     256

class 	__lowercase				(  _A    ):
			lowerCamelCase			:		Union[str, Any]	      =			["melgan"]

			def __init__(self			,   A			,   A			,   A			,   A			,   A			,   )     ->   None:
								super().__init__()

								# From MELGAN
								lowerCamelCase_					:      int     =		math.log(1E-5      )  # Matches MelGAN training.
								lowerCamelCase_					:      List[Any]     =		4.0  # Largest value for most examples
								lowerCamelCase_					:      List[str]     =		1_2_8

								self.register_modules(
								    notes_encoder=A			,   continuous_encoder=A			,   decoder=A			,   scheduler=A			,   melgan=A			,   )

			def        UpperCAmelCase__ (self			,   A			,   A=(-1.0, 1.0)			,   A=False      )     ->   Any:
								lowerCamelCase_					:      Optional[int]     =		output_range
								if clip:
													lowerCamelCase_					:      List[str]     =		torch.clip(A			,   self.min_value			,   self.max_value      )
								# Scale to [0, 1].
								lowerCamelCase_					:      Tuple     =		(features - self.min_value) / (self.max_value - self.min_value)
								# Scale to [min_out, max_out].
								return zero_one * (max_out - min_out) + min_out

			def        UpperCAmelCase__ (self			,   A			,   A=(-1.0, 1.0)			,   A=False      )     ->   Any:
								lowerCamelCase_					:      Union[str, Any]     =		input_range
								lowerCamelCase_					:      Any     =		torch.clip(A			,   A			,   A      ) if clip else outputs
								# Scale to [0, 1].
								lowerCamelCase_					:      Optional[Any]     =		(outputs - min_out) / (max_out - min_out)
								# Scale to [self.min_value, self.max_value].
								return zero_one * (self.max_value - self.min_value) + self.min_value

			def        UpperCAmelCase__ (self			,   A			,   A			,   A      )     ->   Optional[int]:
								lowerCamelCase_					:      Optional[int]     =		input_tokens > 0
								lowerCamelCase_					:      List[Any]     =		self.notes_encoder(
								    encoder_input_tokens=A			,   encoder_inputs_mask=A      )

								lowerCamelCase_					:      List[Any]     =		self.continuous_encoder(
								    encoder_inputs=A			,   encoder_inputs_mask=A      )

								return [(tokens_encoded, tokens_mask), (continuous_encoded, continuous_mask)]

			def        UpperCAmelCase__ (self			,   A			,   A			,   A      )     ->   Union[str, Any]:
								lowerCamelCase_					:      Tuple     =		noise_time
								if not torch.is_tensor(A      ):
													lowerCamelCase_					:      Tuple     =		torch.tensor([timesteps]			,   dtype=torch.long			,   device=input_tokens.device      )
								elif torch.is_tensor(A      ) and len(timesteps.shape      ) == 0:
													lowerCamelCase_					:      str     =		timesteps[None].to(input_tokens.device      )

								# broadcast to batch dimension in a way that's compatible with ONNX/Core ML
								lowerCamelCase_					:      int     =		timesteps * torch.ones(input_tokens.shape[0]			,   dtype=timesteps.dtype			,   device=timesteps.device      )

								lowerCamelCase_					:      str     =		self.decoder(
								    encodings_and_masks=A			,   decoder_input_tokens=A			,   decoder_noise_time=A      )
								return logits






			@torch.no_grad()
			def __call__(self			,   A			,   A = None			,   A = 1_0_0			,   A = True			,   A = "numpy"			,   A = None			,   A = 1			,   )     ->   Union[AudioPipelineOutput, Tuple]:
								if (callback_steps is None) or (
								    callback_steps is not None and (not isinstance(A			,   A      ) or callback_steps <= 0)
								):
													raise ValueError(
													    F"""`callback_steps` has to be a positive integer but is {callback_steps} of type"""
													    F""" {type(A      )}."""      )

								lowerCamelCase_					:      List[Any]     =		np.zeros([1, TARGET_FEATURE_LENGTH, self.n_dims]			,   dtype=np.floataa      )
								lowerCamelCase_					:      Any     =		np.zeros([1, 0, self.n_dims]			,   np.floataa      )
								lowerCamelCase_					:      List[str]     =		torch.ones((1, TARGET_FEATURE_LENGTH)			,   dtype=A			,   device=self.device      )

								for i, encoder_input_tokens in enumerate(A      ):
													if i == 0:
																		lowerCamelCase_					:      int     =		torch.from_numpy(pred_mel[:1].copy()      ).to(
																		    device=self.device			,   dtype=self.decoder.dtype      )
																		# The first chunk has no previous context.
																		lowerCamelCase_					:      List[str]     =		torch.zeros((1, TARGET_FEATURE_LENGTH)			,   dtype=A			,   device=self.device      )
													else:
																		# The full song pipeline does not feed in a context feature, so the mask
																		# will be all 0s after the feature converter. Because we know we're
																		# feeding in a full context chunk from the previous prediction, set it
																		# to all 1s.
																		lowerCamelCase_					:      List[Any]     =		ones

													lowerCamelCase_					:      List[Any]     =		self.scale_features(
													    A			,   output_range=[-1.0, 1.0]			,   clip=A      )

													lowerCamelCase_					:      List[Any]     =		self.encode(
													    input_tokens=torch.IntTensor([encoder_input_tokens]      ).to(device=self.device      )			,   continuous_inputs=A			,   continuous_mask=A			,   )

													# Sample encoder_continuous_inputs shaped gaussian noise to begin loop
													lowerCamelCase_					:      List[str]     =		randn_tensor(
													    shape=encoder_continuous_inputs.shape			,   generator=A			,   device=self.device			,   dtype=self.decoder.dtype			,   )

													# set step values
													self.scheduler.set_timesteps(A      )

													# Denoising diffusion loop
													for j, t in enumerate(self.progress_bar(self.scheduler.timesteps      )      ):
																		lowerCamelCase_					:      List[str]     =		self.decode(
																		    encodings_and_masks=A			,   input_tokens=A			,   noise_time=t / self.scheduler.config.num_train_timesteps			,   )

																		# Compute previous output: x_t -> x_t-1
																		lowerCamelCase_					:      str     =		self.scheduler.step(A			,   A			,   A			,   generator=A      ).prev_sample

													lowerCamelCase_					:      Any     =		self.scale_to_features(A			,   input_range=[-1.0, 1.0]      )
													lowerCamelCase_					:      Union[str, Any]     =		mel[:1]
													lowerCamelCase_					:      Tuple     =		mel.cpu().float().numpy()

													lowerCamelCase_					:      List[Any]     =		np.concatenate([full_pred_mel, pred_mel[:1]]			,   axis=1      )

													# call the callback, if provided
													if callback is not None and i % callback_steps == 0:
																		callback(A			,   A      )

													logger.info('''Generated segment'''			,   A      )

								if output_type == "numpy" and not is_onnx_available():
													raise ValueError(
													    '''Cannot return output in \'np\' format if ONNX is not available. Make sure to have ONNX installed or set \'output_type\' to \'mel\'.'''      )
								elif output_type == "numpy" and self.melgan is None:
													raise ValueError(
													    '''Cannot return output in \'np\' format if melgan component is not defined. Make sure to define `self.melgan` or set \'output_type\' to \'mel\'.'''      )

								if output_type == "numpy":
													lowerCamelCase_					:      str     =		self.melgan(input_features=full_pred_mel.astype(np.floataa      )      )
								else:
													lowerCamelCase_					:      Any     =		full_pred_mel

								if not return_dict:
													return (output,)

								return AudioPipelineOutput(audios=A      )




'''simple docstring'''


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

			def __init__(self			,   A			,   ):
								lowerCamelCase_					:      int     =		parent
								lowerCamelCase_					:      Dict     =		1_3
								lowerCamelCase_					:      Any     =		7
								lowerCamelCase_					:      Dict     =		3_0
								lowerCamelCase_					:      Optional[Any]     =		self.seq_length + self.mem_len
								lowerCamelCase_					:      Tuple     =		1_5
								lowerCamelCase_					:      Tuple     =		True
								lowerCamelCase_					:      List[Any]     =		True
								lowerCamelCase_					:      Dict     =		9_9
								lowerCamelCase_					:      Any     =		[1_0, 5_0, 8_0]
								lowerCamelCase_					:      List[str]     =		3_2
								lowerCamelCase_					:      Tuple     =		3_2
								lowerCamelCase_					:      Optional[Any]     =		4
								lowerCamelCase_					:      Union[str, Any]     =		8
								lowerCamelCase_					:      Dict     =		1_2_8
								lowerCamelCase_					:      Dict     =		2
								lowerCamelCase_					:      Tuple     =		2
								lowerCamelCase_					:      Any     =		None
								lowerCamelCase_					:      Optional[Any]     =		1
								lowerCamelCase_					:      Union[str, Any]     =		0
								lowerCamelCase_					:      str     =		3
								lowerCamelCase_					:      Dict     =		self.vocab_size - 1
								lowerCamelCase_					:      Dict     =		0.01

			def        UpperCAmelCase__ (self      ):
								lowerCamelCase_					:      List[Any]     =		ids_tensor([self.batch_size, self.seq_length]			,   self.vocab_size      )
								lowerCamelCase_					:      Optional[int]     =		ids_tensor([self.batch_size, self.seq_length]			,   self.vocab_size      )

								lowerCamelCase_					:      Union[str, Any]     =		None
								if self.use_labels:
													lowerCamelCase_					:      Tuple     =		ids_tensor([self.batch_size, self.seq_length]			,   self.vocab_size      )

								lowerCamelCase_					:      str     =		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        UpperCAmelCase__ (self      ):
								random.seed(self.seed      )
								tf.random.set_seed(self.seed      )

			def        UpperCAmelCase__ (self			,   A			,   A			,   A			,   A      ):
								lowerCamelCase_					:      int     =		TFTransfoXLModel(A      )

								lowerCamelCase_,      lowerCamelCase_					:      Tuple     =		model(A      ).to_tuple()

								lowerCamelCase_					:      Union[str, Any]     =		{'''input_ids''': input_ids_a, '''mems''': mems_a}

								lowerCamelCase_,      lowerCamelCase_					:      Any     =		model(A      ).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        UpperCAmelCase__ (self			,   A			,   A			,   A			,   A      ):
								lowerCamelCase_					:      List[Any]     =		TFTransfoXLLMHeadModel(A      )

								lowerCamelCase_,      lowerCamelCase_					:      List[Any]     =		model(A      ).to_tuple()

								lowerCamelCase_					:      Optional[int]     =		{'''input_ids''': input_ids_a, '''labels''': lm_labels}
								lowerCamelCase_,      lowerCamelCase_					:      Union[str, Any]     =		model(A      ).to_tuple()

								lowerCamelCase_,      lowerCamelCase_					:      Tuple     =		model([input_ids_a, mems_a]      ).to_tuple()

								lowerCamelCase_					:      List[str]     =		{'''input_ids''': input_ids_a, '''mems''': mems_a, '''labels''': lm_labels}

								lowerCamelCase_,      lowerCamelCase_					:      str     =		model(A      ).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        UpperCAmelCase__ (self			,   A			,   A			,   A			,   A      ):
								lowerCamelCase_					:      Dict     =		TFTransfoXLForSequenceClassification(A      )
								lowerCamelCase_					:      Optional[int]     =		model(A      )
								self.parent.assertEqual(result.logits.shape			,   (self.batch_size, self.num_labels)      )






			def        UpperCAmelCase__ (self      ):
								lowerCamelCase_					:      Tuple     =		self.prepare_config_and_inputs()
								((lowerCamelCase_),      (lowerCamelCase_),      (lowerCamelCase_),      (lowerCamelCase_))					:      List[Any]     =		config_and_inputs
								lowerCamelCase_					:      Tuple     =		{'''input_ids''': input_ids_a}
								return config, inputs_dict

@require_tf
class 	__lowercase				(  _lowercase      ,     _lowercase      ,     unittest.TestCase    ):
			lowerCamelCase			:		Any	      =			(
			    (TFTransfoXLModel, TFTransfoXLLMHeadModel, TFTransfoXLForSequenceClassification) if is_tf_available() else ()
			)
			lowerCamelCase			:		Tuple	      =			() if is_tf_available() else ()
			lowerCamelCase			:		Any	      =			(
			    {
			        "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
			lowerCamelCase			:		str	      =			False
			lowerCamelCase			:		Optional[int]	      =			False
			lowerCamelCase			:		Dict	      =			False
			lowerCamelCase			:		Optional[int]	      =			False

			def        UpperCAmelCase__ (self			,   A			,   A			,   A			,   A			,   A      ):
								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        UpperCAmelCase__ (self      ):
								lowerCamelCase_					:      Optional[Any]     =		TFTransfoXLModelTester(self      )
								lowerCamelCase_					:      Optional[Any]     =		ConfigTester(self			,   config_class=A			,   d_embed=3_7      )

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

			def        UpperCAmelCase__ (self      ):
								self.model_tester.set_seed()
								lowerCamelCase_					:      List[Any]     =		self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_transfo_xl_model(*A      )

			def        UpperCAmelCase__ (self      ):
								self.model_tester.set_seed()
								lowerCamelCase_					:      Optional[Any]     =		self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_transfo_xl_lm_head(*A      )

			def        UpperCAmelCase__ (self      ):
								lowerCamelCase_					:      Dict     =		self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_transfo_xl_for_sequence_classification(*A      )

			def        UpperCAmelCase__ (self      ):
								lowerCamelCase_,      lowerCamelCase_					:      Union[str, Any]     =		self.model_tester.prepare_config_and_inputs_for_common()
								lowerCamelCase_					:      List[Any]     =		[TFTransfoXLForSequenceClassification]

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

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

			@slow
			def        UpperCAmelCase__ (self      ):
								for model_name in TF_TRANSFO_XL_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
													lowerCamelCase_					:      Optional[Any]     =		TFTransfoXLModel.from_pretrained(A      )
													self.assertIsNotNone(A      )






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

@require_tf
class 	__lowercase				(  unittest.TestCase    ):

			@unittest.skip('''Skip test until #12651 is resolved.'''      )
			@slow
			def        UpperCAmelCase__ (self      ):
								lowerCamelCase_					:      Union[str, Any]     =		TFTransfoXLLMHeadModel.from_pretrained('''transfo-xl-wt103'''      )
								# fmt: off
								lowerCamelCase_					:      Optional[Any]     =		tf.convert_to_tensor([[3_3,1_2_9_7,2,1,1_0_0_9,4,1_1_0_9,1_1_7_3_9,4_7_6_2,3_5_8,5,2_5,2_4_5,2_2,1_7_0_6,1_7,2_0_0_9_8,5,3_2_1_5,2_1,3_7,1_1_1_0,3,1_3,1_0_4_1,4,2_4,6_0_3,4_9_0,2,7_1_4_7_7,2_0_0_9_8,1_0_4_4_4_7,2,2_0_9_6_1,1,2_6_0_4,4,1,3_2_9,3,6_2_2_4,8_3_1,1_6_0_0_2,2,8,6_0_3,7_8_9_6_7,2_9_5_4_6,2_3,8_0_3,2_0,2_5,4_1_6,5,8,2_3_2,4,2_7_7,6,1_8_5_5,4_6_0_1,3,2_9_5_4_6,5_4,8,3_6_0_9,5,5_7_2_1_1,4_9,4,1,2_7_7,1_8,8,1_7_5_5,1_5_6_9_1,3,3_4_1,2_5,4_1_6,6_9_3,4_2_5_7_3,7_1,1_7,4_0_1,9_4,3_1,1_7_9_1_9,2,2_9_5_4_6,7_8_7_3,1_8,1,4_3_5,2_3,1_1_0_1_1,7_5_5,5,5_1_6_7,3,7_9_8_3,9_8,8_4,2,2_9_5_4_6,3_2_6_7,8,3_6_0_9,4,1,4_8_6_5,1_0_7_5,2,6_0_8_7,7_1,6,3_4_6,8,5_8_5_4,3,2_9_5_4_6,8_2_4,1_4_0_0,1_8_6_8,2,1_9,1_6_0,2,3_1_1,8,5_4_9_6,2,2_0_9_2_0,1_7,2_5,1_5_0_9_7,3,2_4,2_4,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
								lowerCamelCase_					:      Union[str, Any]     =		[3_3,1_2_9_7,2,1,1_0_0_9,4,1_1_0_9,1_1_7_3_9,4_7_6_2,3_5_8,5,2_5,2_4_5,2_2,1_7_0_6,1_7,2_0_0_9_8,5,3_2_1_5,2_1,3_7,1_1_1_0,3,1_3,1_0_4_1,4,2_4,6_0_3,4_9_0,2,7_1_4_7_7,2_0_0_9_8,1_0_4_4_4_7,2,2_0_9_6_1,1,2_6_0_4,4,1,3_2_9,3,6_2_2_4,8_3_1,1_6_0_0_2,2,8,6_0_3,7_8_9_6_7,2_9_5_4_6,2_3,8_0_3,2_0,2_5,4_1_6,5,8,2_3_2,4,2_7_7,6,1_8_5_5,4_6_0_1,3,2_9_5_4_6,5_4,8,3_6_0_9,5,5_7_2_1_1,4_9,4,1,2_7_7,1_8,8,1_7_5_5,1_5_6_9_1,3,3_4_1,2_5,4_1_6,6_9_3,4_2_5_7_3,7_1,1_7,4_0_1,9_4,3_1,1_7_9_1_9,2,2_9_5_4_6,7_8_7_3,1_8,1,4_3_5,2_3,1_1_0_1_1,7_5_5,5,5_1_6_7,3,7_9_8_3,9_8,8_4,2,2_9_5_4_6,3_2_6_7,8,3_6_0_9,4,1,4_8_6_5,1_0_7_5,2,6_0_8_7,7_1,6,3_4_6,8,5_8_5_4,3,2_9_5_4_6,8_2_4,1_4_0_0,1_8_6_8,2,1_9,1_6_0,2,3_1_1,8,5_4_9_6,2,2_0_9_2_0,1_7,2_5,1_5_0_9_7,3,2_4,2_4,0,3_3,1,1_8_5_7,2,1,1_0_0_9,4,1_1_0_9,1_1_7_3_9,4_7_6_2,3_5_8,5,2_5,2_4_5,2_8,1_1_1_0,3,1_3,1_0_4_1,4,2_4,6_0_3,4_9_0,2,7_1_4_7_7,2_0_0_9_8,1_0_4_4_4_7,2,2_0_9_6_1,1,2_6_0_4,4,1,3_2_9,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>

								lowerCamelCase_					:      Optional[Any]     =		model.generate(A			,   max_length=2_0_0			,   do_sample=A      )
								self.assertListEqual(output_ids[0].numpy().tolist()			,   A      )


