
import unittest

import numpy as np
import timeout_decorator  # noqa

from transformers import BlenderbotConfig, is_flax_available
from transformers.testing_utils import jax_device, require_flax, slow

from ...generation.test_flax_utils import FlaxGenerationTesterMixin
from ...test_modeling_flax_common import FlaxModelTesterMixin, ids_tensor


if is_flax_available():
 import os

 # The slow tests are often failing with OOM error on GPU
 # This makes JAX allocate exactly what is needed on demand, and deallocate memory that is no longer needed
 # but will be slower as stated here https://jax.readthedocs.io/en/latest/gpu_memory_allocation.html
 _snake_case      = '''platform'''

 import jax
 import jax.numpy as jnp

 from transformers import BlenderbotTokenizer
 from transformers.models.blenderbot.modeling_flax_blenderbot import (
     FlaxBlenderbotForConditionalGeneration,
     FlaxBlenderbotModel,
     shift_tokens_right,
 )

def  __lowerCamelCase					( _lowercase						,     _lowercase						,     _lowercase=None						,     _lowercase=None						,     _lowercase=None						,     _lowercase=None						,     _lowercase=None						,     _lowercase=None						,     )       ->      List[str]:
     if attention_mask is None:
          UpperCamelCase						    =					np.where(input_ids != config.pad_token_id						,     1						,     0			)
     if decoder_attention_mask is None:
          UpperCamelCase						    =					np.where(decoder_input_ids != config.pad_token_id						,     1						,     0			)
     if head_mask is None:
          UpperCamelCase						    =					np.ones((config.encoder_layers, config.encoder_attention_heads)			)
     if decoder_head_mask is None:
          UpperCamelCase						    =					np.ones((config.decoder_layers, config.decoder_attention_heads)			)
     if cross_attn_head_mask is None:
          UpperCamelCase						    =					np.ones((config.decoder_layers, config.decoder_attention_heads)			)
     return {
         "input_ids": input_ids,
         "decoder_input_ids": decoder_input_ids,
         "attention_mask": attention_mask,
         "decoder_attention_mask": attention_mask,
     }
class       _lowerCAmelCase  :

 """simple docstring"""

 def __init__(						self			:			Optional[Any]					, SCREAMING_SNAKE_CASE__			:			int					, SCREAMING_SNAKE_CASE__			:			Optional[Any]=13					, SCREAMING_SNAKE_CASE__			:			int=7					, SCREAMING_SNAKE_CASE__			:			Any=True					, SCREAMING_SNAKE_CASE__			:			Dict=False					, SCREAMING_SNAKE_CASE__			:			int=99					, SCREAMING_SNAKE_CASE__			:			List[str]=16					, SCREAMING_SNAKE_CASE__			:			str=2					, SCREAMING_SNAKE_CASE__			:			Optional[int]=4					, SCREAMING_SNAKE_CASE__			:			Optional[Any]=4					, SCREAMING_SNAKE_CASE__			:			Optional[Any]="gelu"					, SCREAMING_SNAKE_CASE__			:			Dict=0.1					, SCREAMING_SNAKE_CASE__			:			int=0.1					, SCREAMING_SNAKE_CASE__			:			List[Any]=32					, SCREAMING_SNAKE_CASE__			:			List[str]=2					, SCREAMING_SNAKE_CASE__			:			Tuple=1					, SCREAMING_SNAKE_CASE__			:			Optional[int]=0					, SCREAMING_SNAKE_CASE__			:			int=0.02					, ):






      """simple docstring"""



      UpperCamelCase						    =					parent
      UpperCamelCase						    =					batch_size
      UpperCamelCase						    =					seq_length
      UpperCamelCase						    =					is_training
      UpperCamelCase						    =					use_labels
      UpperCamelCase						    =					vocab_size
      UpperCamelCase						    =					hidden_size
      UpperCamelCase						    =					num_hidden_layers
      UpperCamelCase						    =					num_attention_heads
      UpperCamelCase						    =					intermediate_size
      UpperCamelCase						    =					hidden_act
      UpperCamelCase						    =					hidden_dropout_prob
      UpperCamelCase						    =					attention_probs_dropout_prob
      UpperCamelCase						    =					max_position_embeddings
      UpperCamelCase						    =					eos_token_id
      UpperCamelCase						    =					pad_token_id
      UpperCamelCase						    =					bos_token_id
      UpperCamelCase						    =					initializer_range

 def      __lowerCAmelCase  (						self			:			Any   ):






      """simple docstring"""



      UpperCamelCase						    =					np.clip(ids_tensor([self.batch_size, self.seq_length - 1]					, self.vocab_size   )					, 3					, self.vocab_size   )
      UpperCamelCase						    =					np.concatenate((input_ids, 2 * np.ones((self.batch_size, 1)					, dtype=np.intaa   ))					, -1   )

      UpperCamelCase						    =					shift_tokens_right(SCREAMING_SNAKE_CASE__					, 1					, 2   )

      UpperCamelCase						    =					BlenderbotConfig(
          vocab_size=self.vocab_size					, d_model=self.hidden_size					, encoder_layers=self.num_hidden_layers					, decoder_layers=self.num_hidden_layers					, encoder_attention_heads=self.num_attention_heads					, decoder_attention_heads=self.num_attention_heads					, encoder_ffn_dim=self.intermediate_size					, decoder_ffn_dim=self.intermediate_size					, dropout=self.hidden_dropout_prob					, attention_dropout=self.attention_probs_dropout_prob					, max_position_embeddings=self.max_position_embeddings					, eos_token_id=self.eos_token_id					, bos_token_id=self.bos_token_id					, pad_token_id=self.pad_token_id					, initializer_range=self.initializer_range					, use_cache=SCREAMING_SNAKE_CASE__					, )
      UpperCamelCase						    =					prepare_blenderbot_inputs_dict(SCREAMING_SNAKE_CASE__					, SCREAMING_SNAKE_CASE__					, SCREAMING_SNAKE_CASE__   )
      return config, inputs_dict

 def      __lowerCAmelCase  (						self			:			Optional[int]   ):






      """simple docstring"""



      UpperCamelCase    ,		UpperCamelCase						    =					self.prepare_config_and_inputs()
      return config, inputs_dict

 def      __lowerCAmelCase  (						self			:			Union[str, Any]					, SCREAMING_SNAKE_CASE__			:			str					, SCREAMING_SNAKE_CASE__			:			List[Any]					, SCREAMING_SNAKE_CASE__			:			List[str]   ):






      """simple docstring"""



      UpperCamelCase						    =					20
      UpperCamelCase						    =					model_class_name(SCREAMING_SNAKE_CASE__   )

      UpperCamelCase						    =					model.encode(inputs_dict['input_ids']   )

      UpperCamelCase    ,		UpperCamelCase						    =					(
          inputs_dict['decoder_input_ids'],
          inputs_dict['decoder_attention_mask'],
      )

      UpperCamelCase						    =					model.init_cache(decoder_input_ids.shape[0]					, SCREAMING_SNAKE_CASE__					, SCREAMING_SNAKE_CASE__   )
      UpperCamelCase						    =					jnp.ones((decoder_input_ids.shape[0], max_decoder_length)					, dtype='i4'   )

      UpperCamelCase						    =					jnp.broadcast_to(
          jnp.arange(decoder_input_ids.shape[-1] - 1   )[None, :]					, (decoder_input_ids.shape[0], decoder_input_ids.shape[-1] - 1)					, )
      UpperCamelCase						    =					model.decode(
          decoder_input_ids[:, :-1]					, SCREAMING_SNAKE_CASE__					, decoder_attention_mask=SCREAMING_SNAKE_CASE__					, past_key_values=SCREAMING_SNAKE_CASE__					, decoder_position_ids=SCREAMING_SNAKE_CASE__					, )

      UpperCamelCase						    =					jnp.array(decoder_input_ids.shape[0] * [[decoder_input_ids.shape[-1] - 1]]					, dtype='i4'   )
      UpperCamelCase						    =					model.decode(
          decoder_input_ids[:, -1:]					, SCREAMING_SNAKE_CASE__					, decoder_attention_mask=SCREAMING_SNAKE_CASE__					, past_key_values=outputs_cache.past_key_values					, decoder_position_ids=SCREAMING_SNAKE_CASE__					, )

      UpperCamelCase						    =					model.decode(SCREAMING_SNAKE_CASE__					, SCREAMING_SNAKE_CASE__   )

      UpperCamelCase						    =					np.max(np.abs((outputs_cache_next[0][:, -1, :5] - outputs[0][:, -1, :5])   )   )
      self.parent.assertTrue(diff < 1e-3					, msg=F'Max diff is {diff}'   )






 def      __lowerCAmelCase  (						self			:			Dict					, SCREAMING_SNAKE_CASE__			:			int					, SCREAMING_SNAKE_CASE__			:			List[Any]					, SCREAMING_SNAKE_CASE__			:			Optional[Any]   ):






      """simple docstring"""



      UpperCamelCase						    =					20
      UpperCamelCase						    =					model_class_name(SCREAMING_SNAKE_CASE__   )

      UpperCamelCase						    =					model.encode(inputs_dict['input_ids']   )

      UpperCamelCase    ,		UpperCamelCase						    =					(
          inputs_dict['decoder_input_ids'],
          inputs_dict['decoder_attention_mask'],
      )

      UpperCamelCase						    =					jnp.concatenate(
          [
              decoder_attention_mask,
              jnp.zeros((decoder_attention_mask.shape[0], max_decoder_length - decoder_attention_mask.shape[1])   ),
          ]					, axis=-1					, )

      UpperCamelCase						    =					model.init_cache(decoder_input_ids.shape[0]					, SCREAMING_SNAKE_CASE__					, SCREAMING_SNAKE_CASE__   )
      UpperCamelCase						    =					jnp.broadcast_to(
          jnp.arange(decoder_input_ids.shape[-1] - 1   )[None, :]					, (decoder_input_ids.shape[0], decoder_input_ids.shape[-1] - 1)					, )

      UpperCamelCase						    =					model.decode(
          decoder_input_ids[:, :-1]					, SCREAMING_SNAKE_CASE__					, decoder_attention_mask=SCREAMING_SNAKE_CASE__					, past_key_values=SCREAMING_SNAKE_CASE__					, decoder_position_ids=SCREAMING_SNAKE_CASE__					, )
      UpperCamelCase						    =					jnp.array(decoder_input_ids.shape[0] * [[decoder_input_ids.shape[-1] - 1]]					, dtype='i4'   )
      UpperCamelCase						    =					model.decode(
          decoder_input_ids[:, -1:]					, SCREAMING_SNAKE_CASE__					, past_key_values=outputs_cache.past_key_values					, decoder_attention_mask=SCREAMING_SNAKE_CASE__					, decoder_position_ids=SCREAMING_SNAKE_CASE__					, )

      UpperCamelCase						    =					model.decode(SCREAMING_SNAKE_CASE__					, SCREAMING_SNAKE_CASE__					, decoder_attention_mask=SCREAMING_SNAKE_CASE__   )

      UpperCamelCase						    =					np.max(np.abs((outputs_cache_next[0][:, -1, :5] - outputs[0][:, -1, :5])   )   )
      self.parent.assertTrue(diff < 1e-3					, msg=F'Max diff is {diff}'   )




@require_flax
class       _lowerCAmelCase  (		unittest.TestCase							):

 """simple docstring"""
 SCREAMING_SNAKE_CASE_				:					List[str]       						=99

 def      __lowerCAmelCase  (						self			:			int   ):






      """simple docstring"""



      UpperCamelCase						    =					np.array(
          [
              [71, 82, 18, 33, 46, 91, 2],
              [68, 34, 26, 58, 30, 82, 2],
              [5, 97, 17, 39, 94, 40, 2],
              [76, 83, 94, 25, 70, 78, 2],
              [87, 59, 41, 35, 48, 66, 2],
              [55, 13, 16, 58, 5, 2, 1],  # note padding
              [64, 27, 31, 51, 12, 75, 2],
              [52, 64, 86, 17, 83, 39, 2],
              [48, 61, 9, 24, 71, 82, 2],
              [26, 1, 60, 48, 22, 13, 2],
              [21, 5, 62, 28, 14, 76, 2],
              [45, 98, 37, 86, 59, 48, 2],
              [70, 70, 50, 9, 28, 0, 2],
          ]					, dtype=np.intaa					, )

      UpperCamelCase						    =					input_ids.shape[0]
      UpperCamelCase						    =					BlenderbotConfig(
          vocab_size=self.vocab_size					, d_model=24					, encoder_layers=2					, decoder_layers=2					, encoder_attention_heads=2					, decoder_attention_heads=2					, encoder_ffn_dim=32					, decoder_ffn_dim=32					, max_position_embeddings=48					, eos_token_id=2					, pad_token_id=1					, bos_token_id=0					, )
      return config, input_ids, batch_size

 def      __lowerCAmelCase  (						self			:			Union[str, Any]   ):






      """simple docstring"""



      UpperCamelCase    ,		UpperCamelCase    ,		UpperCamelCase						    =					self._get_config_and_data()
      UpperCamelCase						    =					FlaxBlenderbotForConditionalGeneration(SCREAMING_SNAKE_CASE__   )
      UpperCamelCase						    =					lm_model(input_ids=SCREAMING_SNAKE_CASE__   )
      UpperCamelCase						    =					(batch_size, input_ids.shape[1], config.vocab_size)
      self.assertEqual(outputs['logits'].shape					, SCREAMING_SNAKE_CASE__   )

 def      __lowerCAmelCase  (						self			:			int   ):






      """simple docstring"""



      UpperCamelCase						    =					BlenderbotConfig(
          vocab_size=self.vocab_size					, d_model=14					, encoder_layers=2					, decoder_layers=2					, encoder_attention_heads=2					, decoder_attention_heads=2					, encoder_ffn_dim=8					, decoder_ffn_dim=8					, max_position_embeddings=48					, )
      UpperCamelCase						    =					FlaxBlenderbotForConditionalGeneration(SCREAMING_SNAKE_CASE__   )
      UpperCamelCase						    =					np.array([[71, 82, 18, 33, 46, 91, 2], [68, 34, 26, 58, 30, 2, 1]]					, dtype=np.intaa   )
      UpperCamelCase						    =					np.array([[82, 71, 82, 18, 2], [58, 68, 2, 1, 1]]					, dtype=np.intaa   )
      UpperCamelCase						    =					lm_model(input_ids=SCREAMING_SNAKE_CASE__					, decoder_input_ids=SCREAMING_SNAKE_CASE__   )
      UpperCamelCase						    =					(*summary.shape, config.vocab_size)
      self.assertEqual(outputs['logits'].shape					, SCREAMING_SNAKE_CASE__   )






 def      __lowerCAmelCase  (						self			:			List[str]   ):






      """simple docstring"""



      UpperCamelCase						    =					np.array([[71, 82, 18, 33, 2, 1, 1], [68, 34, 26, 58, 30, 82, 2]]					, dtype=np.intaa   )
      UpperCamelCase						    =					shift_tokens_right(SCREAMING_SNAKE_CASE__					, 1					, 2   )
      UpperCamelCase						    =					np.equal(SCREAMING_SNAKE_CASE__					, 1   ).astype(np.floataa   ).sum()
      UpperCamelCase						    =					np.equal(SCREAMING_SNAKE_CASE__					, 1   ).astype(np.floataa   ).sum()
      self.assertEqual(shifted.shape					, input_ids.shape   )
      self.assertEqual(SCREAMING_SNAKE_CASE__					, n_pad_before - 1   )
      self.assertTrue(np.equal(shifted[:, 0]					, 2   ).all()   )




@require_flax
class       _lowerCAmelCase  (		__magic_name__			,	unittest.TestCase			,	__magic_name__							):

 """simple docstring"""
 SCREAMING_SNAKE_CASE_				:					Tuple       						=True
 SCREAMING_SNAKE_CASE_				:					Any       						=(
     (
         FlaxBlenderbotModel,
         FlaxBlenderbotForConditionalGeneration,
     )
     if is_flax_available()
     else ()
 )
 SCREAMING_SNAKE_CASE_				:					Any       						=(FlaxBlenderbotForConditionalGeneration,) if is_flax_available() else ()

 def      __lowerCAmelCase  (						self			:			Optional[Any]   ):






      """simple docstring"""



      UpperCamelCase						    =					FlaxBlenderbotModelTester(self   )

 def      __lowerCAmelCase  (						self			:			Union[str, Any]   ):






      """simple docstring"""



      UpperCamelCase    ,		UpperCamelCase						    =					self.model_tester.prepare_config_and_inputs()
      for model_class in self.all_model_classes:
           self.model_tester.check_use_cache_forward(SCREAMING_SNAKE_CASE__					, SCREAMING_SNAKE_CASE__					, SCREAMING_SNAKE_CASE__   )

 def      __lowerCAmelCase  (						self			:			Any   ):






      """simple docstring"""



      UpperCamelCase    ,		UpperCamelCase						    =					self.model_tester.prepare_config_and_inputs()
      for model_class in self.all_model_classes:
           self.model_tester.check_use_cache_forward_with_attn_mask(SCREAMING_SNAKE_CASE__					, SCREAMING_SNAKE_CASE__					, SCREAMING_SNAKE_CASE__   )

 def      __lowerCAmelCase  (						self			:			List[Any]   ):






      """simple docstring"""



      UpperCamelCase    ,		UpperCamelCase						    =					self.model_tester.prepare_config_and_inputs_for_common()

      for model_class in self.all_model_classes:
           with self.subTest(model_class.__name__   ):
                UpperCamelCase						    =					self._prepare_for_class(SCREAMING_SNAKE_CASE__					, SCREAMING_SNAKE_CASE__   )
                UpperCamelCase						    =					model_class(SCREAMING_SNAKE_CASE__   )

                @jax.jit
                def encode_jitted(SCREAMING_SNAKE_CASE__			:			Union[str, Any]					, SCREAMING_SNAKE_CASE__			:			Optional[Any]=None					, **SCREAMING_SNAKE_CASE__			:			Tuple   ):
                     return model.encode(input_ids=SCREAMING_SNAKE_CASE__					, attention_mask=SCREAMING_SNAKE_CASE__   )

                with self.subTest('JIT Enabled'   ):
                     UpperCamelCase						    =					encode_jitted(**SCREAMING_SNAKE_CASE__   ).to_tuple()

                with self.subTest('JIT Disabled'   ):
                     with jax.disable_jit():
                          UpperCamelCase						    =					encode_jitted(**SCREAMING_SNAKE_CASE__   ).to_tuple()

                self.assertEqual(len(SCREAMING_SNAKE_CASE__   )					, len(SCREAMING_SNAKE_CASE__   )   )
                for jitted_output, output in zip(SCREAMING_SNAKE_CASE__					, SCREAMING_SNAKE_CASE__   ):
                     self.assertEqual(jitted_output.shape					, output.shape   )

 def      __lowerCAmelCase  (						self			:			str   ):






      """simple docstring"""



      UpperCamelCase    ,		UpperCamelCase						    =					self.model_tester.prepare_config_and_inputs_for_common()

      for model_class in self.all_model_classes:
           with self.subTest(model_class.__name__   ):
                UpperCamelCase						    =					model_class(SCREAMING_SNAKE_CASE__   )
                UpperCamelCase						    =					model.encode(inputs_dict['input_ids']					, inputs_dict['attention_mask']   )

                UpperCamelCase						    =					{
                    'decoder_input_ids': inputs_dict['decoder_input_ids'],
                    'decoder_attention_mask': inputs_dict['decoder_attention_mask'],
                    'encoder_outputs': encoder_outputs,
                }

                @jax.jit
                def decode_jitted(SCREAMING_SNAKE_CASE__			:			Optional[int]					, SCREAMING_SNAKE_CASE__			:			List[str]					, SCREAMING_SNAKE_CASE__			:			str   ):
                     return model.decode(
                         decoder_input_ids=SCREAMING_SNAKE_CASE__					, decoder_attention_mask=SCREAMING_SNAKE_CASE__					, encoder_outputs=SCREAMING_SNAKE_CASE__					, )

                with self.subTest('JIT Enabled'   ):
                     UpperCamelCase						    =					decode_jitted(**SCREAMING_SNAKE_CASE__   ).to_tuple()

                with self.subTest('JIT Disabled'   ):
                     with jax.disable_jit():
                          UpperCamelCase						    =					decode_jitted(**SCREAMING_SNAKE_CASE__   ).to_tuple()

                self.assertEqual(len(SCREAMING_SNAKE_CASE__   )					, len(SCREAMING_SNAKE_CASE__   )   )
                for jitted_output, output in zip(SCREAMING_SNAKE_CASE__					, SCREAMING_SNAKE_CASE__   ):
                     self.assertEqual(jitted_output.shape					, output.shape   )

 @slow
 def      __lowerCAmelCase  (						self			:			str   ):






      """simple docstring"""



      for model_class_name in self.all_model_classes:
           UpperCamelCase						    =					model_class_name.from_pretrained('facebook/blenderbot-400M-distill'   )
           # FlaxBlenderbotForSequenceClassification expects eos token in input_ids
           UpperCamelCase						    =					np.ones((1, 1)   ) * model.config.eos_token_id
           UpperCamelCase						    =					model(SCREAMING_SNAKE_CASE__   )
           self.assertIsNotNone(SCREAMING_SNAKE_CASE__   )






 @unittest.skipUnless(jax_device != 'cpu'					, '3B test too slow on CPU.'   )
 @slow
 def      __lowerCAmelCase  (						self			:			Tuple   ):






      """simple docstring"""



      UpperCamelCase						    =					{'num_beams': 1, 'early_stopping': True, 'min_length': 15, 'max_length': 25}
      UpperCamelCase						    =					{'skip_special_tokens': True, 'clean_up_tokenization_spaces': True}

      UpperCamelCase						    =					FlaxBlenderbotForConditionalGeneration.from_pretrained('facebook/blenderbot-3B'					, from_pt=SCREAMING_SNAKE_CASE__   )
      UpperCamelCase						    =					BlenderbotTokenizer.from_pretrained('facebook/blenderbot-3B'   )

      UpperCamelCase						    =					['Sam']
      UpperCamelCase						    =					tokenizer(SCREAMING_SNAKE_CASE__					, return_tensors='jax'   )

      UpperCamelCase						    =					model.generate(**SCREAMING_SNAKE_CASE__					, **SCREAMING_SNAKE_CASE__   )
      UpperCamelCase						    =					'Sam is a great name. It means "sun" in Gaelic.'

      UpperCamelCase						    =					tokenizer.batch_decode(SCREAMING_SNAKE_CASE__					, **SCREAMING_SNAKE_CASE__   )
      assert generated_txt[0].strip() == tgt_text




import unittest

from transformers import JukeboxTokenizer
from transformers.testing_utils import require_torch
class       _lowerCAmelCase  (		unittest.TestCase							):

 """simple docstring"""
 SCREAMING_SNAKE_CASE_				:					List[Any]       						=JukeboxTokenizer
 SCREAMING_SNAKE_CASE_				:					str       						={
     "artist": "Zac Brown Band",
     "genres": "Country",
     "lyrics": "I met a traveller from an antique land,\n        Who said \"Two vast and trunkless legs of stone\n        Stand in the desert. . . . Near them, on the sand,\n        Half sunk a shattered visage lies, whose frown,\n        And wrinkled lip, and sneer of cold command,\n        Tell that its sculptor well those passions read\n        Which yet survive, stamped on these lifeless things,\n        The hand that mocked them, and the heart that fed;\n        And on the pedestal, these words appear:\n        My name is Ozymandias, King of Kings;\n        Look on my Works, ye Mighty, and despair!\n        Nothing beside remains. Round the decay\n        Of that colossal Wreck, boundless and bare\n        The lone and level sands stretch far away\n        ",
 }

 @require_torch
 def      __lowerCAmelCase  (						self			:			Tuple   ):






      """simple docstring"""



      import torch

      UpperCamelCase						    =					JukeboxTokenizer.from_pretrained('openai/jukebox-1b-lyrics'   )
      UpperCamelCase						    =					tokenizer(**self.metas   )['input_ids']
      # fmt: off
      UpperCamelCase						    =					[
          torch.tensor([[
              0, 0, 0, 71_69, 5_07, 9, 76, 39, 31, 46, 76, 27,
              76, 46, 44, 27, 48, 31, 38, 38, 31, 44, 76, 32,
              44, 41, 39, 76, 27, 40, 76, 27, 40, 46, 35, 43,
              47, 31, 76, 38, 27, 40, 30, 64, 78, 76, 76, 76,
              76, 76, 76, 76, 76, 23, 34, 41, 76, 45, 27, 35,
              30, 76, 71, 20, 49, 41, 76, 48, 27, 45, 46, 76,
              27, 40, 30, 76, 46, 44, 47, 40, 37, 38, 31, 45,
              45, 76, 38, 31, 33, 45, 76, 41, 32, 76, 45, 46,
              41, 40, 31, 78, 76, 76, 76, 76, 76, 76, 76, 76,
              19, 46, 27, 40, 30, 76, 35, 40, 76, 46, 34, 31,
              76, 30, 31, 45, 31, 44, 46, 63, 76, 63, 76, 63,
              76, 63, 76, 14, 31, 27, 44, 76, 46, 34, 31, 39,
              64, 76, 41, 40, 76, 46, 34, 31, 76, 45, 27, 40,
              30, 64, 78, 76, 76, 76, 76, 76, 76, 76, 76, 8,
              27, 38, 32, 76, 45, 47, 40, 37, 76, 27, 76, 45,
              34, 27, 46, 46, 31, 44, 31, 30, 76, 48, 35, 45,
              27, 33, 31, 76, 38, 35, 31, 45, 64, 76, 49, 34,
              41, 45, 31, 76, 32, 44, 41, 49, 40, 64, 78, 76,
              76, 76, 76, 76, 76, 76, 76, 1, 40, 30, 76, 49,
              44, 35, 40, 37, 38, 31, 30, 76, 38, 35, 42, 64,
              76, 27, 40, 30, 76, 45, 40, 31, 31, 44, 76, 41,
              32, 76, 29, 41, 38, 30, 76, 29, 41, 39, 39, 27,
              40, 30, 64, 78, 76, 76, 76, 76, 76, 76, 76, 76,
              20, 31, 38, 38, 76, 46, 34, 27, 46, 76, 35, 46,
              45, 76, 45, 29, 47, 38, 42, 46, 41, 44, 76, 49,
              31, 38, 38, 76, 46, 34, 41, 45, 31, 76, 42, 27,
              45, 45, 35, 41, 40, 45, 76, 44, 31, 27, 30, 78,
              76, 76, 76, 76, 76, 76, 76, 76, 23, 34, 35, 29,
              34, 76, 51, 31, 46, 76, 45, 47, 44, 48, 35, 48,
              31, 64, 76, 45, 46, 27, 39, 42, 31, 30, 76, 41,
              40, 76, 46, 34, 31, 45, 31, 76, 38, 35, 32, 31,
              38, 31, 45, 45, 76, 46, 34, 35, 40, 33, 45, 64,
              78, 76, 76, 76, 76, 76, 76, 76, 76, 20, 34, 31,
              76, 34, 27, 40, 30, 76, 46, 34, 27, 46, 76, 39,
              41, 29, 37, 31, 30, 76, 46, 34, 31, 39, 64, 76,
              27, 40, 30, 76, 46, 34, 31, 76, 34, 31, 27, 44,
              46, 76, 46, 34, 27, 46, 76, 32, 31, 30, 66, 78,
              76, 76, 76, 76, 76, 76, 76, 76, 1, 40, 30, 76,
              41, 40, 76, 46, 34, 31, 76, 42, 31, 30, 31, 45,
              46, 27, 38, 64, 76, 46, 34, 31, 45, 31, 76, 49,
              41, 44, 30, 45, 76, 27, 42, 42, 31, 27, 44, 65,
              78, 76, 76, 76, 76, 76, 76, 76, 76, 13, 51, 76,
              40, 27, 39, 31, 76, 35, 45, 76, 15, 52, 51, 39,
              27, 40, 30, 35, 27, 45, 64, 76, 11, 35, 40, 33,
              76, 41, 32, 76, 11, 35, 40, 33, 45, 66, 78, 76,
              76, 76, 76, 76, 76, 76, 76, 12, 41, 41, 37, 76,
              41, 40, 76, 39, 51, 76, 23, 41, 44, 37, 45, 64,
              76, 51, 31, 76, 13, 35, 33, 34, 46, 51, 64, 76,
              27, 40, 30, 76, 30, 31, 45, 42, 27, 35, 44, 67,
              78, 76, 76, 76, 76, 76, 76, 76, 76, 14, 41, 46,
              34, 35, 40, 33, 76, 28, 31, 45, 35, 30, 31, 76,
              44, 31, 39, 27, 35, 40, 45, 63, 76, 18, 41, 47,
              40, 30, 76, 46, 34, 31, 76, 30, 31, 29, 27, 51,
              78, 76, 76, 76, 76, 76, 76, 76, 76, 15, 32, 76,
              46, 34, 27, 46, 76, 29, 41, 38, 41, 45, 45, 27,
              38, 76, 23, 44, 31, 29, 37, 64, 76, 28, 41, 47,
              40, 30, 38, 31, 45, 45, 76, 27, 40, 30, 76, 28,
              27, 44, 31, 78, 76, 76, 76, 76, 76, 76, 76, 76,
              20, 34, 31, 76, 38, 41, 40, 31, 76, 27, 40, 30,
              76, 38, 31, 48, 31, 38, 76, 45, 27, 40, 30, 45,
              76, 45, 46, 44, 31, 46, 29, 34, 76, 32, 27, 44,
              76, 27, 49, 27, 51, 78, 76, 76, 76, 76, 76, 76,
              76, 76]]   ),
          torch.tensor([[0, 0, 0, 10_69, 11]]   ),
          torch.tensor([[0, 0, 0, 10_69, 11]]   ),
      ]
      # fmt: on
      self.assertTrue(torch.allclose(tokens[0]					, EXPECTED_OUTPUT[0]   )   )
      self.assertTrue(torch.allclose(tokens[1]					, EXPECTED_OUTPUT[1]   )   )
      self.assertTrue(torch.allclose(tokens[2]					, EXPECTED_OUTPUT[2]   )   )






 @require_torch
 def      __lowerCAmelCase  (						self			:			Union[str, Any]   ):






      """simple docstring"""



      import torch

      UpperCamelCase						    =					JukeboxTokenizer.from_pretrained('openai/jukebox-5b-lyrics'   )
      UpperCamelCase						    =					tokenizer(**self.metas   )['input_ids']
      # fmt: off
      UpperCamelCase						    =					[
          torch.tensor([[
              0, 0, 0, 10_69, 11, -1, -1, -1, -1, 9, 77, 39,
              31, 46, 77, 27, 77, 46, 44, 27, 48, 31, 38, 38,
              31, 44, 77, 32, 44, 41, 39, 77, 27, 40, 77, 27,
              40, 46, 35, 43, 47, 31, 77, 38, 27, 40, 30, 64,
              79, 77, 77, 77, 77, 77, 77, 77, 77, 23, 34, 41,
              77, 45, 27, 35, 30, 77, 72, 20, 49, 41, 77, 48,
              27, 45, 46, 77, 27, 40, 30, 77, 46, 44, 47, 40,
              37, 38, 31, 45, 45, 77, 38, 31, 33, 45, 77, 41,
              32, 77, 45, 46, 41, 40, 31, 79, 77, 77, 77, 77,
              77, 77, 77, 77, 19, 46, 27, 40, 30, 77, 35, 40,
              77, 46, 34, 31, 77, 30, 31, 45, 31, 44, 46, 63,
              77, 63, 77, 63, 77, 63, 77, 14, 31, 27, 44, 77,
              46, 34, 31, 39, 64, 77, 41, 40, 77, 46, 34, 31,
              77, 45, 27, 40, 30, 64, 79, 77, 77, 77, 77, 77,
              77, 77, 77, 8, 27, 38, 32, 77, 45, 47, 40, 37,
              77, 27, 77, 45, 34, 27, 46, 46, 31, 44, 31, 30,
              77, 48, 35, 45, 27, 33, 31, 77, 38, 35, 31, 45,
              64, 77, 49, 34, 41, 45, 31, 77, 32, 44, 41, 49,
              40, 64, 79, 77, 77, 77, 77, 77, 77, 77, 77, 1,
              40, 30, 77, 49, 44, 35, 40, 37, 38, 31, 30, 77,
              38, 35, 42, 64, 77, 27, 40, 30, 77, 45, 40, 31,
              31, 44, 77, 41, 32, 77, 29, 41, 38, 30, 77, 29,
              41, 39, 39, 27, 40, 30, 64, 79, 77, 77, 77, 77,
              77, 77, 77, 77, 20, 31, 38, 38, 77, 46, 34, 27,
              46, 77, 35, 46, 45, 77, 45, 29, 47, 38, 42, 46,
              41, 44, 77, 49, 31, 38, 38, 77, 46, 34, 41, 45,
              31, 77, 42, 27, 45, 45, 35, 41, 40, 45, 77, 44,
              31, 27, 30, 79, 77, 77, 77, 77, 77, 77, 77, 77,
              23, 34, 35, 29, 34, 77, 51, 31, 46, 77, 45, 47,
              44, 48, 35, 48, 31, 64, 77, 45, 46, 27, 39, 42,
              31, 30, 77, 41, 40, 77, 46, 34, 31, 45, 31, 77,
              38, 35, 32, 31, 38, 31, 45, 45, 77, 46, 34, 35,
              40, 33, 45, 64, 79, 77, 77, 77, 77, 77, 77, 77,
              77, 20, 34, 31, 77, 34, 27, 40, 30, 77, 46, 34,
              27, 46, 77, 39, 41, 29, 37, 31, 30, 77, 46, 34,
              31, 39, 64, 77, 27, 40, 30, 77, 46, 34, 31, 77,
              34, 31, 27, 44, 46, 77, 46, 34, 27, 46, 77, 32,
              31, 30, 66, 79, 77, 77, 77, 77, 77, 77, 77, 77,
              1, 40, 30, 77, 41, 40, 77, 46, 34, 31, 77, 42,
              31, 30, 31, 45, 46, 27, 38, 64, 77, 46, 34, 31,
              45, 31, 77, 49, 41, 44, 30, 45, 77, 27, 42, 42,
              31, 27, 44, 65, 79, 77, 77, 77, 77, 77, 77, 77,
              77, 13, 51, 77, 40, 27, 39, 31, 77, 35, 45, 77,
              15, 52, 51, 39, 27, 40, 30, 35, 27, 45, 64, 77,
              11, 35, 40, 33, 77, 41, 32, 77, 11, 35, 40, 33,
              45, 66, 79, 77, 77, 77, 77, 77, 77, 77, 77, 12,
              41, 41, 37, 77, 41, 40, 77, 39, 51, 77, 23, 41,
              44, 37, 45, 64, 77, 51, 31, 77, 13, 35, 33, 34,
              46, 51, 64, 77, 27, 40, 30, 77, 30, 31, 45, 42,
              27, 35, 44, 67, 79, 77, 77, 77, 77, 77, 77, 77,
              77, 14, 41, 46, 34, 35, 40, 33, 77, 28, 31, 45,
              35, 30, 31, 77, 44, 31, 39, 27, 35, 40, 45, 63,
              77, 18, 41, 47, 40, 30, 77, 46, 34, 31, 77, 30,
              31, 29, 27, 51, 79, 77, 77, 77, 77, 77, 77, 77,
              77, 15, 32, 77, 46, 34, 27, 46, 77, 29, 41, 38,
              41, 45, 45, 27, 38, 77, 23, 44, 31, 29, 37, 64,
              77, 28, 41, 47, 40, 30, 38, 31, 45, 45, 77, 27,
              40, 30, 77, 28, 27, 44, 31, 79, 77, 77, 77, 77,
              77, 77, 77, 77, 20, 34, 31, 77, 38, 41, 40, 31,
              77, 27, 40, 30, 77, 38, 31, 48, 31, 38, 77, 45,
              27, 40, 30, 45, 77, 45, 46, 44, 31, 46, 29, 34,
              77, 32, 27, 44, 77, 27, 49, 27, 51, 79, 77, 77,
              77, 77, 77, 77, 77, 77]]   ),
          torch.tensor([[0, 0, 0, 10_69, 11, -1, -1, -1, -1]]   ),
          torch.tensor([[0, 0, 0, 10_69, 11, -1, -1, -1, -1]]   ),
      ]
      # fmt: on
      self.assertTrue(torch.allclose(tokens[0]					, EXPECTED_OUTPUT[0]   )   )
      self.assertTrue(torch.allclose(tokens[1]					, EXPECTED_OUTPUT[1]   )   )
      self.assertTrue(torch.allclose(tokens[2]					, EXPECTED_OUTPUT[2]   )   )


