


from __future__ import annotations

import unittest

from transformers import FunnelConfig, is_tf_available
from transformers.testing_utils import require_tf

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 import (
						    TFFunnelBaseModel,
						    TFFunnelForMaskedLM,
						    TFFunnelForMultipleChoice,
						    TFFunnelForPreTraining,
						    TFFunnelForQuestionAnswering,
						    TFFunnelForSequenceClassification,
						    TFFunnelForTokenClassification,
						    TFFunnelModel,
						)







class  snake_case__:







						'''simple docstring'''




						def __init__( self      ,  __lowercase      ,  __lowercase=1_3      ,  __lowercase=7      ,  __lowercase=True      ,  __lowercase=True      ,  __lowercase=True      ,  __lowercase=True      ,  __lowercase=9_9      ,  __lowercase=[1, 1, 2]      ,  __lowercase=1      ,  __lowercase=3_2      ,  __lowercase=4      ,  __lowercase=8      ,  __lowercase=3_7      ,  __lowercase="gelu_new"      ,  __lowercase=0.1      ,  __lowercase=0.1      ,  __lowercase=0.0      ,  __lowercase=5_1_2      ,  __lowercase=3      ,  __lowercase=0.02      ,  __lowercase=3      ,  __lowercase=4      ,  __lowercase=None      ,  __lowercase=False      ,  )    ->			Optional[Any]:
										lowerCAmelCase_       :					Any			 = parent
										lowerCAmelCase_       :					int			 = batch_size
										lowerCAmelCase_       :					str			 = seq_length
										lowerCAmelCase_       :					str			 = is_training
										lowerCAmelCase_       :					Tuple			 = use_input_mask
										lowerCAmelCase_       :					int			 = use_token_type_ids
										lowerCAmelCase_       :					str			 = use_labels
										lowerCAmelCase_       :					List[str]			 = vocab_size
										lowerCAmelCase_       :					Tuple			 = block_sizes
										lowerCAmelCase_       :					List[Any]			 = num_decoder_layers
										lowerCAmelCase_       :					Any			 = d_model
										lowerCAmelCase_       :					Any			 = n_head
										lowerCAmelCase_       :					Union[str, Any]			 = d_head
										lowerCAmelCase_       :					int			 = d_inner
										lowerCAmelCase_       :					List[str]			 = hidden_act
										lowerCAmelCase_       :					Any			 = hidden_dropout
										lowerCAmelCase_       :					Any			 = attention_dropout
										lowerCAmelCase_       :					List[str]			 = activation_dropout
										lowerCAmelCase_       :					int			 = max_position_embeddings
										lowerCAmelCase_       :					int			 = type_vocab_size
										lowerCAmelCase_       :					Union[str, Any]			 = 2
										lowerCAmelCase_       :					int			 = num_labels
										lowerCAmelCase_       :					Dict			 = num_choices
										lowerCAmelCase_       :					Tuple			 = scope
										lowerCAmelCase_       :					List[str]			 = initializer_std

										# Used in the tests to check the size of the first attention layer
										lowerCAmelCase_       :					str			 = n_head
										# Used in the tests to check the size of the first hidden state
										lowerCAmelCase_       :					Union[str, Any]			 = self.d_model
										# Used in the tests to check the number of output hidden states/attentions
										lowerCAmelCase_       :					Union[str, Any]			 = sum(self.block_sizes							) + (0 if base else self.num_decoder_layers)
										# FunnelModel adds two hidden layers: input embeddings and the sum of the upsampled encoder hidden state with
										# the last hidden state of the first block (which is the first hidden state of the decoder).
										if not base:
														lowerCAmelCase_       :					str			 = self.num_hidden_layers + 2




						def   lowercase_       ( self							)    ->			Tuple:
										lowerCAmelCase_       :					Dict			 = ids_tensor([self.batch_size, self.seq_length]      ,  self.vocab_size							)

										lowerCAmelCase_       :					int			 = None
										if self.use_input_mask:
														lowerCAmelCase_       :					List[str]			 = random_attention_mask([self.batch_size, self.seq_length]							)

										lowerCAmelCase_       :					Any			 = None
										if self.use_token_type_ids:
														lowerCAmelCase_       :					str			 = ids_tensor([self.batch_size, self.seq_length]      ,  self.type_vocab_size							)

										lowerCAmelCase_       :					List[Any]			 = None
										lowerCAmelCase_       :					Any			 = None
										lowerCAmelCase_       :					int			 = None
										if self.use_labels:
														lowerCAmelCase_       :					int			 = ids_tensor([self.batch_size]      ,  self.type_sequence_label_size							)
														lowerCAmelCase_       :					int			 = ids_tensor([self.batch_size, self.seq_length]      ,  self.num_labels							)
														lowerCAmelCase_       :					Optional[int]			 = ids_tensor([self.batch_size]      ,  self.num_choices							)

										lowerCAmelCase_       :					Union[str, Any]			 = FunnelConfig(
										    vocab_size=self.vocab_size      ,  block_sizes=self.block_sizes      ,  num_decoder_layers=self.num_decoder_layers      ,  d_model=self.d_model      ,  n_head=self.n_head      ,  d_head=self.d_head      ,  d_inner=self.d_inner      ,  hidden_act=self.hidden_act      ,  hidden_dropout=self.hidden_dropout      ,  attention_dropout=self.attention_dropout      ,  activation_dropout=self.activation_dropout      ,  max_position_embeddings=self.max_position_embeddings      ,  type_vocab_size=self.type_vocab_size      ,  initializer_std=self.initializer_std      ,  )

										return (
										    config,
										    input_ids,
										    token_type_ids,
										    input_mask,
										    sequence_labels,
										    token_labels,
										    choice_labels,
										)




						def   lowercase_       ( self      ,  __lowercase      ,  __lowercase      ,  __lowercase      ,  __lowercase      ,  __lowercase      ,  __lowercase      ,  __lowercase      ,  )    ->			List[Any]:
										lowerCAmelCase_       :					Any			 = TFFunnelModel(config=UpperCamelCase__							)
										lowerCAmelCase_       :					Any			 = {"input_ids": input_ids, "attention_mask": input_mask, "token_type_ids": token_type_ids}
										lowerCAmelCase_       :					Optional[Any]			 = model(UpperCamelCase__							)

										lowerCAmelCase_       :					Tuple			 = [input_ids, input_mask]
										lowerCAmelCase_       :					Dict			 = model(UpperCamelCase__							)

										lowerCAmelCase_       :					Any			 = model(UpperCamelCase__							)
										self.parent.assertEqual(result.last_hidden_state.shape      ,  (self.batch_size, self.seq_length, self.d_model)							)

										lowerCAmelCase_       :					Any			 = False
										lowerCAmelCase_       :					Any			 = TFFunnelModel(config=UpperCamelCase__							)
										lowerCAmelCase_       :					str			 = model(UpperCamelCase__							)
										self.parent.assertEqual(result.last_hidden_state.shape      ,  (self.batch_size, self.seq_length, self.d_model)							)

										lowerCAmelCase_       :					List[str]			 = False
										lowerCAmelCase_       :					str			 = TFFunnelModel(config=UpperCamelCase__							)
										lowerCAmelCase_       :					List[str]			 = model(UpperCamelCase__							)
										self.parent.assertEqual(result.last_hidden_state.shape      ,  (self.batch_size, self.seq_length, self.d_model)							)




						def   lowercase_       ( self      ,  __lowercase      ,  __lowercase      ,  __lowercase      ,  __lowercase      ,  __lowercase      ,  __lowercase      ,  __lowercase      ,  )    ->			Dict:
										lowerCAmelCase_       :					List[Any]			 = TFFunnelBaseModel(config=UpperCamelCase__							)
										lowerCAmelCase_       :					int			 = {"input_ids": input_ids, "attention_mask": input_mask, "token_type_ids": token_type_ids}
										lowerCAmelCase_       :					Tuple			 = model(UpperCamelCase__							)

										lowerCAmelCase_       :					List[str]			 = [input_ids, input_mask]
										lowerCAmelCase_       :					Optional[int]			 = model(UpperCamelCase__							)

										lowerCAmelCase_       :					Optional[Any]			 = model(UpperCamelCase__							)
										self.parent.assertEqual(result.last_hidden_state.shape      ,  (self.batch_size, 2, self.d_model)							)

										lowerCAmelCase_       :					Any			 = False
										lowerCAmelCase_       :					int			 = TFFunnelBaseModel(config=UpperCamelCase__							)
										lowerCAmelCase_       :					List[Any]			 = model(UpperCamelCase__							)
										self.parent.assertEqual(result.last_hidden_state.shape      ,  (self.batch_size, 3, self.d_model)							)

										lowerCAmelCase_       :					List[Any]			 = False
										lowerCAmelCase_       :					List[str]			 = TFFunnelBaseModel(config=UpperCamelCase__							)
										lowerCAmelCase_       :					List[Any]			 = model(UpperCamelCase__							)
										self.parent.assertEqual(result.last_hidden_state.shape      ,  (self.batch_size, 2, self.d_model)							)




						def   lowercase_       ( self      ,  __lowercase      ,  __lowercase      ,  __lowercase      ,  __lowercase      ,  __lowercase      ,  __lowercase      ,  __lowercase      ,  )    ->			List[str]:
										lowerCAmelCase_       :					Tuple			 = TFFunnelForPreTraining(config=UpperCamelCase__							)
										lowerCAmelCase_       :					Dict			 = {"input_ids": input_ids, "attention_mask": input_mask, "token_type_ids": token_type_ids}
										lowerCAmelCase_       :					Any			 = model(UpperCamelCase__							)
										self.parent.assertEqual(result.logits.shape      ,  (self.batch_size, self.seq_length)							)




						def   lowercase_       ( self      ,  __lowercase      ,  __lowercase      ,  __lowercase      ,  __lowercase      ,  __lowercase      ,  __lowercase      ,  __lowercase      ,  )    ->			Union[str, Any]:
										lowerCAmelCase_       :					Dict			 = TFFunnelForMaskedLM(config=UpperCamelCase__							)
										lowerCAmelCase_       :					Tuple			 = {"input_ids": input_ids, "attention_mask": input_mask, "token_type_ids": token_type_ids}
										lowerCAmelCase_       :					Optional[int]			 = model(UpperCamelCase__							)
										self.parent.assertEqual(result.logits.shape      ,  (self.batch_size, self.seq_length, self.vocab_size)							)




						def   lowercase_       ( self      ,  __lowercase      ,  __lowercase      ,  __lowercase      ,  __lowercase      ,  __lowercase      ,  __lowercase      ,  __lowercase      ,  )    ->			Any:
										lowerCAmelCase_       :					List[Any]			 = self.num_labels
										lowerCAmelCase_       :					int			 = TFFunnelForSequenceClassification(config=UpperCamelCase__							)
										lowerCAmelCase_       :					Optional[Any]			 = {"input_ids": input_ids, "attention_mask": input_mask, "token_type_ids": token_type_ids}
										lowerCAmelCase_       :					Dict			 = model(UpperCamelCase__							)
										self.parent.assertEqual(result.logits.shape      ,  (self.batch_size, self.num_labels)							)




						def   lowercase_       ( self      ,  __lowercase      ,  __lowercase      ,  __lowercase      ,  __lowercase      ,  __lowercase      ,  __lowercase      ,  __lowercase      ,  )    ->			Dict:
										lowerCAmelCase_       :					Optional[int]			 = self.num_choices
										lowerCAmelCase_       :					Optional[Any]			 = TFFunnelForMultipleChoice(config=UpperCamelCase__							)
										lowerCAmelCase_       :					int			 = tf.tile(tf.expand_dims(UpperCamelCase__      ,  1							)      ,  (1, self.num_choices, 1)							)
										lowerCAmelCase_       :					List[str]			 = tf.tile(tf.expand_dims(UpperCamelCase__      ,  1							)      ,  (1, self.num_choices, 1)							)
										lowerCAmelCase_       :					Dict			 = tf.tile(tf.expand_dims(UpperCamelCase__      ,  1							)      ,  (1, self.num_choices, 1)							)
										lowerCAmelCase_       :					Any			 = {
										    "input_ids": multiple_choice_inputs_ids,
										    "attention_mask": multiple_choice_input_mask,
										    "token_type_ids": multiple_choice_token_type_ids,
										}
										lowerCAmelCase_       :					List[Any]			 = model(UpperCamelCase__							)
										self.parent.assertEqual(result.logits.shape      ,  (self.batch_size, self.num_choices)							)




						def   lowercase_       ( self      ,  __lowercase      ,  __lowercase      ,  __lowercase      ,  __lowercase      ,  __lowercase      ,  __lowercase      ,  __lowercase      ,  )    ->			int:
										lowerCAmelCase_       :					int			 = self.num_labels
										lowerCAmelCase_       :					Any			 = TFFunnelForTokenClassification(config=UpperCamelCase__							)
										lowerCAmelCase_       :					List[Any]			 = {"input_ids": input_ids, "attention_mask": input_mask, "token_type_ids": token_type_ids}
										lowerCAmelCase_       :					Optional[Any]			 = model(UpperCamelCase__							)
										self.parent.assertEqual(result.logits.shape      ,  (self.batch_size, self.seq_length, self.num_labels)							)




						def   lowercase_       ( self      ,  __lowercase      ,  __lowercase      ,  __lowercase      ,  __lowercase      ,  __lowercase      ,  __lowercase      ,  __lowercase      ,  )    ->			Union[str, Any]:
										lowerCAmelCase_       :					Union[str, Any]			 = TFFunnelForQuestionAnswering(config=UpperCamelCase__							)
										lowerCAmelCase_       :					Tuple			 = {"input_ids": input_ids, "attention_mask": input_mask, "token_type_ids": token_type_ids}
										lowerCAmelCase_       :					List[str]			 = model(UpperCamelCase__							)
										self.parent.assertEqual(result.start_logits.shape      ,  (self.batch_size, self.seq_length)							)
										self.parent.assertEqual(result.end_logits.shape      ,  (self.batch_size, self.seq_length)							)




						def   lowercase_       ( self							)    ->			Tuple:
										lowerCAmelCase_       :					Dict			 = self.prepare_config_and_inputs()
										(
										    lowerCAmelCase_
										)       :					Union[str, Any]			 = config_and_inputs
										lowerCAmelCase_       :					int			 = {"input_ids": input_ids, "token_type_ids": token_type_ids, "attention_mask": input_mask}
										return config, inputs_dict







@require_tf
class  snake_case__(							snake_case_,  snake_case_,  unittest.TestCase							):







						'''simple docstring'''




						SCREAMING_SNAKE_CASE__					:     List[str]    =							(
						    (
						        TFFunnelModel,
						        TFFunnelForMaskedLM,
						        TFFunnelForPreTraining,
						        TFFunnelForQuestionAnswering,
						        TFFunnelForTokenClassification,
						    )
						    if is_tf_available()
						    else ()
						)
						SCREAMING_SNAKE_CASE__					:     Union[str, Any]    =							(
						    {
						        '''feature-extraction''': (TFFunnelBaseModel, TFFunnelModel),
						        '''fill-mask''': TFFunnelForMaskedLM,
						        '''question-answering''': TFFunnelForQuestionAnswering,
						        '''text-classification''': TFFunnelForSequenceClassification,
						        '''token-classification''': TFFunnelForTokenClassification,
						        '''zero-shot''': TFFunnelForSequenceClassification,
						    }
						    if is_tf_available()
						    else {}
						)
						SCREAMING_SNAKE_CASE__					:     int    =							False
						SCREAMING_SNAKE_CASE__					:     Optional[Any]    =							False




						def   lowercase_       ( self							)    ->			str:
										lowerCAmelCase_       :					Union[str, Any]			 = TFFunnelModelTester(self							)
										lowerCAmelCase_       :					Optional[Any]			 = ConfigTester(self      ,  config_class=UpperCamelCase__							)




						def   lowercase_       ( self							)    ->			int:
										self.config_tester.run_common_tests()




						def   lowercase_       ( self							)    ->			Tuple:
										lowerCAmelCase_       :					Dict			 = self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_model(*UpperCamelCase__							)




						def   lowercase_       ( self							)    ->			List[str]:
										lowerCAmelCase_       :					int			 = self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_for_pretraining(*UpperCamelCase__							)




						def   lowercase_       ( self							)    ->			Dict:
										lowerCAmelCase_       :					Dict			 = self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_for_masked_lm(*UpperCamelCase__							)




						def   lowercase_       ( self							)    ->			Dict:
										lowerCAmelCase_       :					Optional[int]			 = self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_for_token_classification(*UpperCamelCase__							)




						def   lowercase_       ( self							)    ->			str:
										lowerCAmelCase_       :					List[Any]			 = self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_for_question_answering(*UpperCamelCase__							)







@require_tf
class  snake_case__(							snake_case_,  unittest.TestCase							):







						'''simple docstring'''




						SCREAMING_SNAKE_CASE__					:     List[str]    =							(
						    (TFFunnelBaseModel, TFFunnelForMultipleChoice, TFFunnelForSequenceClassification) if is_tf_available() else ()
						)
						SCREAMING_SNAKE_CASE__					:     Union[str, Any]    =							False
						SCREAMING_SNAKE_CASE__					:     Any    =							False




						def   lowercase_       ( self							)    ->			str:
										lowerCAmelCase_       :					List[Any]			 = TFFunnelModelTester(self      ,  base=UpperCamelCase__							)
										lowerCAmelCase_       :					List[Any]			 = ConfigTester(self      ,  config_class=UpperCamelCase__							)




						def   lowercase_       ( self							)    ->			Optional[int]:
										self.config_tester.run_common_tests()




						def   lowercase_       ( self							)    ->			Union[str, Any]:
										lowerCAmelCase_       :					List[Any]			 = self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_base_model(*UpperCamelCase__							)




						def   lowercase_       ( self							)    ->			Tuple:
										lowerCAmelCase_       :					List[Any]			 = self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_for_sequence_classification(*UpperCamelCase__							)




						def   lowercase_       ( self							)    ->			List[Any]:
										lowerCAmelCase_       :					List[str]			 = self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_for_multiple_choice(*UpperCamelCase__							)



"""simple docstring"""



import unittest

from transformers import JukeboxTokenizer
from transformers.testing_utils import require_torch







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







   @require_torch
   def  lowerCamelCase		(	self						)	->		int:

       '''simple docstring'''




       import torch

       snake_case    :      Any      					=    JukeboxTokenizer.from_pretrained("openai/jukebox-1b-lyrics"						)
       snake_case    :      Optional[Any]      					=    tokenizer(**self.metas						)["input_ids"]
       # fmt: off
       snake_case    :      Optional[int]      					=    [
           torch.tensor([[
               0, 0, 0, 7169, 507, 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, 1069, 11]]						),
           torch.tensor([[0, 0, 0, 1069, 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						)	->		Any:

       '''simple docstring'''




       import torch

       snake_case    :      Tuple      					=    JukeboxTokenizer.from_pretrained("openai/jukebox-5b-lyrics"						)
       snake_case    :      Optional[Any]      					=    tokenizer(**self.metas						)["input_ids"]
       # fmt: off
       snake_case    :      List[Any]      					=    [
           torch.tensor([[
               0, 0, 0, 1069, 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, 1069, 11, -1, -1, -1, -1]]						),
           torch.tensor([[0, 0, 0, 1069, 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]						)						)





