



import collections
import tempfile
import unittest

import numpy as np

from transformers.testing_utils import (
    is_pt_flax_cross_test,
    require_flax,
    require_torch,
    require_vision,
    slow,
    torch_device,
)
from transformers.utils import is_flax_available, is_torch_available, is_vision_available

from ...test_modeling_flax_common import floats_tensor, ids_tensor, random_attention_mask
from ..bert.test_modeling_flax_bert import FlaxBertModelTester
from ..clip.test_modeling_flax_clip import FlaxCLIPVisionModelTester
from ..vit.test_modeling_flax_vit import FlaxViTModelTester


if is_flax_available():
    from transformers import (
        FlaxBertModel,
        FlaxCLIPVisionModel,
        FlaxVisionTextDualEncoderModel,
        FlaxViTModel,
        VisionTextDualEncoderConfig,
        VisionTextDualEncoderProcessor,
    )
    from transformers.modeling_flax_pytorch_utils import (
        convert_pytorch_state_dict_to_flax,
        load_flax_weights_in_pytorch_model,
    )


if is_torch_available():
    import torch

    from transformers import VisionTextDualEncoderModel

if is_vision_available():
    from PIL import Image
def 		UpperCamelCase     (       snake_case__	:   Tuple     )     ->					str:
   if isinstance(snake_case__	,					collections.abc.Iterable     ):
      return x
   return (x, x)



@require_flax
class     lowerCAmelCase_		:
       def  snake_case_	(      self,      SCREAMING_SNAKE_CASE_,      SCREAMING_SNAKE_CASE_	)					->		Dict:
          pass
       def  snake_case_	(      self	)					->		Any:
          pass
       def  snake_case_	(      self	)					->		List[Any]:
          pass
       def  snake_case_	(      self,      SCREAMING_SNAKE_CASE_,      SCREAMING_SNAKE_CASE_,      SCREAMING_SNAKE_CASE_	)					->		Tuple:
          UpperCamelCase   :  Dict						     =     np.abs((a - b)	).max()
          self.assertLessEqual(SCREAMING_SNAKE_CASE_,      SCREAMING_SNAKE_CASE_,      F"""Difference between torch and flax is {diff} (>= {tol})."""	)
       def  snake_case_	(      self,      SCREAMING_SNAKE_CASE_,      SCREAMING_SNAKE_CASE_,      SCREAMING_SNAKE_CASE_,      SCREAMING_SNAKE_CASE_,      SCREAMING_SNAKE_CASE_=None,      **SCREAMING_SNAKE_CASE_	)					->		Tuple:
          UpperCamelCase   :  Any						     =     VisionTextDualEncoderConfig.from_vision_text_configs(SCREAMING_SNAKE_CASE_,      SCREAMING_SNAKE_CASE_	)

          UpperCamelCase   :  Optional[Any]						     =     FlaxVisionTextDualEncoderModel(SCREAMING_SNAKE_CASE_	)

          UpperCamelCase   :  Optional[int]						     =     model(input_ids=SCREAMING_SNAKE_CASE_,      pixel_values=SCREAMING_SNAKE_CASE_,      attention_mask=SCREAMING_SNAKE_CASE_	)

          self.assertEqual(output['text_embeds'].shape,      (input_ids.shape[0], config.projection_dim)	)
          self.assertEqual(output['image_embeds'].shape,      (pixel_values.shape[0], config.projection_dim)	)
       def  snake_case_	(      self,      SCREAMING_SNAKE_CASE_,      SCREAMING_SNAKE_CASE_,      SCREAMING_SNAKE_CASE_,      SCREAMING_SNAKE_CASE_,      SCREAMING_SNAKE_CASE_=None,      **SCREAMING_SNAKE_CASE_	)					->		Union[str, Any]:
          UpperCamelCase   :  Optional[int]						     =     self.get_vision_text_model(SCREAMING_SNAKE_CASE_,      SCREAMING_SNAKE_CASE_	)
          UpperCamelCase   :  str						     =     {'vision_model': vision_model, 'text_model': text_model}
          UpperCamelCase   :  List[str]						     =     FlaxVisionTextDualEncoderModel.from_vision_text_pretrained(**SCREAMING_SNAKE_CASE_	)

          UpperCamelCase   :  str						     =     model(input_ids=SCREAMING_SNAKE_CASE_,      pixel_values=SCREAMING_SNAKE_CASE_,      attention_mask=SCREAMING_SNAKE_CASE_	)

          self.assertEqual(output['text_embeds'].shape,      (input_ids.shape[0], model.config.projection_dim)	)
          self.assertEqual(output['image_embeds'].shape,      (pixel_values.shape[0], model.config.projection_dim)	)
       def  snake_case_	(      self,      SCREAMING_SNAKE_CASE_,      SCREAMING_SNAKE_CASE_,      SCREAMING_SNAKE_CASE_,      SCREAMING_SNAKE_CASE_,      SCREAMING_SNAKE_CASE_=None,      **SCREAMING_SNAKE_CASE_	)					->		Optional[Any]:
          UpperCamelCase   :  List[Any]						     =     self.get_vision_text_model(SCREAMING_SNAKE_CASE_,      SCREAMING_SNAKE_CASE_	)
          UpperCamelCase   :  Union[str, Any]						     =     {'vision_model': vision_model, 'text_model': text_model}
          UpperCamelCase   :  int						     =     FlaxVisionTextDualEncoderModel.from_vision_text_pretrained(**SCREAMING_SNAKE_CASE_	)

          UpperCamelCase   :  int						     =     model(input_ids=SCREAMING_SNAKE_CASE_,      pixel_values=SCREAMING_SNAKE_CASE_,      attention_mask=SCREAMING_SNAKE_CASE_	)
          UpperCamelCase   :  Union[str, Any]						     =     output[0]

          with tempfile.TemporaryDirectory() as tmpdirname:
             model.save_pretrained(SCREAMING_SNAKE_CASE_	)
             UpperCamelCase   :  int						     =     FlaxVisionTextDualEncoderModel.from_pretrained(SCREAMING_SNAKE_CASE_	)

             UpperCamelCase   :  Any						     =     model(input_ids=SCREAMING_SNAKE_CASE_,      pixel_values=SCREAMING_SNAKE_CASE_,      attention_mask=SCREAMING_SNAKE_CASE_	)
             UpperCamelCase   :  Dict						     =     after_output[0]
             UpperCamelCase   :  str						     =     np.amax(np.abs(out_a - out_a	)	)
             self.assertLessEqual(SCREAMING_SNAKE_CASE_,      1e-3	)
       def  snake_case_	(      self,      SCREAMING_SNAKE_CASE_,      SCREAMING_SNAKE_CASE_,      SCREAMING_SNAKE_CASE_,      SCREAMING_SNAKE_CASE_,      SCREAMING_SNAKE_CASE_=None,      **SCREAMING_SNAKE_CASE_	)					->		str:
          UpperCamelCase   :  Union[str, Any]						     =     self.get_vision_text_model(SCREAMING_SNAKE_CASE_,      SCREAMING_SNAKE_CASE_	)
          UpperCamelCase   :  int						     =     {'vision_model': vision_model, 'text_model': text_model}
          UpperCamelCase   :  Union[str, Any]						     =     FlaxVisionTextDualEncoderModel.from_vision_text_pretrained(**SCREAMING_SNAKE_CASE_	)

          UpperCamelCase   :  Tuple						     =     model(
              input_ids=SCREAMING_SNAKE_CASE_,      pixel_values=SCREAMING_SNAKE_CASE_,      attention_mask=SCREAMING_SNAKE_CASE_,      output_attentions=SCREAMING_SNAKE_CASE_	)

          UpperCamelCase   :  Optional[Any]						     =     output.vision_model_output.attentions
          self.assertEqual(len(SCREAMING_SNAKE_CASE_	),      vision_config.num_hidden_layers	)

          # in ViT, the seq_len equals the number of patches + 1 (we add 1 for the [CLS] token)
          UpperCamelCase   :  List[Any]						     =     to_atuple(vision_model.config.image_size	)
          UpperCamelCase   :  Dict						     =     to_atuple(vision_model.config.patch_size	)
          UpperCamelCase   :  Optional[int]						     =     (image_size[1] // patch_size[1]) * (image_size[0] // patch_size[0])
          UpperCamelCase   :  List[Any]						     =     num_patches + 1
          self.assertEqual(vision_attentions[0].shape[-3:],      (vision_config.num_attention_heads, seq_len, seq_len)	)

          UpperCamelCase   :  Union[str, Any]						     =     output.text_model_output.attentions
          self.assertEqual(len(SCREAMING_SNAKE_CASE_	),      text_config.num_hidden_layers	)

          self.assertEqual(
              text_attentions[0].shape[-3:],      (text_config.num_attention_heads, input_ids.shape[-1], input_ids.shape[-1]),      )
       def  snake_case_	(      self,      SCREAMING_SNAKE_CASE_,      SCREAMING_SNAKE_CASE_,      SCREAMING_SNAKE_CASE_	)					->		Any:
          pt_model.to(SCREAMING_SNAKE_CASE_	)
          pt_model.eval()

          # prepare inputs
          UpperCamelCase   :  Optional[Any]						     =     inputs_dict
          UpperCamelCase   :  List[Any]						     =     {k: torch.tensor(v.tolist()	) for k, v in flax_inputs.items()}

          with torch.no_grad():
             UpperCamelCase   :  Tuple						     =     pt_model(**SCREAMING_SNAKE_CASE_	).to_tuple()

          UpperCamelCase   :  List[str]						     =     fx_model(**SCREAMING_SNAKE_CASE_	).to_tuple()
          self.assertEqual(len(SCREAMING_SNAKE_CASE_	),      len(SCREAMING_SNAKE_CASE_	),      'Output lengths differ between Flax and PyTorch'	)
          for fx_output, pt_output in zip(fx_outputs[:4],      pt_outputs[:4]	):
             self.assert_almost_equals(SCREAMING_SNAKE_CASE_,      pt_output.numpy(),      4e-2	)

          # PT -> Flax
          with tempfile.TemporaryDirectory() as tmpdirname:
             pt_model.save_pretrained(SCREAMING_SNAKE_CASE_	)
             UpperCamelCase   :  List[Any]						     =     FlaxVisionTextDualEncoderModel.from_pretrained(SCREAMING_SNAKE_CASE_,      from_pt=SCREAMING_SNAKE_CASE_	)

          UpperCamelCase   :  Dict						     =     fx_model_loaded(**SCREAMING_SNAKE_CASE_	).to_tuple()
          self.assertEqual(len(SCREAMING_SNAKE_CASE_	),      len(SCREAMING_SNAKE_CASE_	),      'Output lengths differ between Flax and PyTorch'	)
          for fx_output_loaded, pt_output in zip(fx_outputs_loaded[:4],      pt_outputs[:4]	):
             self.assert_almost_equals(SCREAMING_SNAKE_CASE_,      pt_output.numpy(),      4e-2	)

          # Flax -> PT
          with tempfile.TemporaryDirectory() as tmpdirname:
             fx_model.save_pretrained(SCREAMING_SNAKE_CASE_	)
             UpperCamelCase   :  int						     =     VisionTextDualEncoderModel.from_pretrained(SCREAMING_SNAKE_CASE_,      from_flax=SCREAMING_SNAKE_CASE_	)

          pt_model_loaded.to(SCREAMING_SNAKE_CASE_	)
          pt_model_loaded.eval()

          with torch.no_grad():
             UpperCamelCase   :  List[str]						     =     pt_model_loaded(**SCREAMING_SNAKE_CASE_	).to_tuple()

          self.assertEqual(len(SCREAMING_SNAKE_CASE_	),      len(SCREAMING_SNAKE_CASE_	),      'Output lengths differ between Flax and PyTorch'	)
          for fx_output, pt_output_loaded in zip(fx_outputs[:4],      pt_outputs_loaded[:4]	):
             self.assert_almost_equals(SCREAMING_SNAKE_CASE_,      pt_output_loaded.numpy(),      4e-2	)
       def  snake_case_	(      self,      SCREAMING_SNAKE_CASE_,      SCREAMING_SNAKE_CASE_,      SCREAMING_SNAKE_CASE_	)					->		Tuple:
          UpperCamelCase   :  List[Any]						     =     VisionTextDualEncoderConfig.from_vision_text_configs(SCREAMING_SNAKE_CASE_,      SCREAMING_SNAKE_CASE_	)

          UpperCamelCase   :  Dict						     =     VisionTextDualEncoderModel(SCREAMING_SNAKE_CASE_	)
          UpperCamelCase   :  Any						     =     FlaxVisionTextDualEncoderModel(SCREAMING_SNAKE_CASE_	)

          UpperCamelCase   :  Optional[int]						     =     convert_pytorch_state_dict_to_flax(pt_model.state_dict(),      SCREAMING_SNAKE_CASE_	)
          UpperCamelCase   :  Optional[Any]						     =     fx_state

          self.check_pt_flax_equivalence(SCREAMING_SNAKE_CASE_,      SCREAMING_SNAKE_CASE_,      SCREAMING_SNAKE_CASE_	)
       def  snake_case_	(      self,      SCREAMING_SNAKE_CASE_,      SCREAMING_SNAKE_CASE_,      SCREAMING_SNAKE_CASE_	)					->		Tuple:
          UpperCamelCase   :  str						     =     VisionTextDualEncoderConfig.from_vision_text_configs(SCREAMING_SNAKE_CASE_,      SCREAMING_SNAKE_CASE_	)

          UpperCamelCase   :  Union[str, Any]						     =     VisionTextDualEncoderModel(SCREAMING_SNAKE_CASE_	)
          UpperCamelCase   :  List[Any]						     =     FlaxVisionTextDualEncoderModel(SCREAMING_SNAKE_CASE_	)

          UpperCamelCase   :  Optional[Any]						     =     load_flax_weights_in_pytorch_model(SCREAMING_SNAKE_CASE_,      fx_model.params	)

          self.check_pt_flax_equivalence(SCREAMING_SNAKE_CASE_,      SCREAMING_SNAKE_CASE_,      SCREAMING_SNAKE_CASE_	)
       def  snake_case_	(      self	)					->		List[str]:
          UpperCamelCase   :  List[Any]						     =     self.prepare_config_and_inputs()
          self.check_model_from_pretrained_configs(**SCREAMING_SNAKE_CASE_	)
       def  snake_case_	(      self	)					->		List[str]:
          UpperCamelCase   :  int						     =     self.prepare_config_and_inputs()
          self.check_vision_text_dual_encoder_from_pretrained(**SCREAMING_SNAKE_CASE_	)
       def  snake_case_	(      self	)					->		str:
          UpperCamelCase   :  str						     =     self.prepare_config_and_inputs()
          self.check_save_load(**SCREAMING_SNAKE_CASE_	)
       def  snake_case_	(      self	)					->		Optional[int]:
          UpperCamelCase   :  List[Any]						     =     self.prepare_config_and_inputs()
          self.check_vision_text_output_attention(**SCREAMING_SNAKE_CASE_	)
       @is_pt_flax_cross_test
       def  snake_case_	(      self	)					->		List[Any]:
          UpperCamelCase   :  Any						     =     self.prepare_config_and_inputs()
          UpperCamelCase   :  Union[str, Any]						     =     config_inputs_dict.pop('vision_config'	)
          UpperCamelCase   :  Union[str, Any]						     =     config_inputs_dict.pop('text_config'	)

          UpperCamelCase   :  Dict						     =     config_inputs_dict

          self.check_equivalence_pt_to_flax(SCREAMING_SNAKE_CASE_,      SCREAMING_SNAKE_CASE_,      SCREAMING_SNAKE_CASE_	)
          self.check_equivalence_flax_to_pt(SCREAMING_SNAKE_CASE_,      SCREAMING_SNAKE_CASE_,      SCREAMING_SNAKE_CASE_	)






       @slow
       def  snake_case_	(      self	)					->		Optional[int]:
          UpperCamelCase   :  str						     =     self.get_pretrained_model_and_inputs()

          UpperCamelCase   :  str						     =     model_a(**SCREAMING_SNAKE_CASE_	)
          UpperCamelCase   :  Dict						     =     outputs[0]

          with tempfile.TemporaryDirectory() as tmp_dirname:
             model_a.save_pretrained(SCREAMING_SNAKE_CASE_	)
             UpperCamelCase   :  int						     =     FlaxVisionTextDualEncoderModel.from_pretrained(SCREAMING_SNAKE_CASE_	)

             UpperCamelCase   :  Any						     =     model_a(**SCREAMING_SNAKE_CASE_	)
             UpperCamelCase   :  Dict						     =     after_outputs[0]
             UpperCamelCase   :  Any						     =     np.amax(np.abs(out_a - out_a	)	)
             self.assertLessEqual(SCREAMING_SNAKE_CASE_,      1e-5	)






@require_flax
class     lowerCAmelCase_		(  a__	,   unittest.TestCase							):
       def  snake_case_	(      self	)					->		str:
          UpperCamelCase   :  Optional[Any]						     =     FlaxVisionTextDualEncoderModel.from_vision_text_pretrained(
              'hf-internal-testing/tiny-random-vit',      'hf-internal-testing/tiny-bert',      vision_from_pt=SCREAMING_SNAKE_CASE_,      text_from_pt=SCREAMING_SNAKE_CASE_,      )
          UpperCamelCase   :  Optional[int]						     =     13
          UpperCamelCase   :  Tuple						     =     floats_tensor(
              [
                  batch_size,
                  model.config.vision_config.num_channels,
                  model.config.vision_config.image_size,
                  model.config.vision_config.image_size,
              ]	)
          UpperCamelCase   :  Optional[int]						     =     ids_tensor([batch_size, 4],      model.config.text_config.vocab_size	)
          UpperCamelCase   :  Optional[Any]						     =     random_attention_mask([batch_size, 4]	)
          UpperCamelCase   :  List[Any]						     =     {'pixel_values': pixel_values, 'input_ids': input_ids, 'attention_mask': attention_mask}

          return model, inputs
       def  snake_case_	(      self,      SCREAMING_SNAKE_CASE_,      SCREAMING_SNAKE_CASE_	)					->		int:
          UpperCamelCase   :  Optional[int]						     =     FlaxViTModel(SCREAMING_SNAKE_CASE_	)
          UpperCamelCase   :  List[Any]						     =     FlaxBertModel(SCREAMING_SNAKE_CASE_	)
          return vision_model, text_model






       def  snake_case_	(      self	)					->		int:
          UpperCamelCase   :  Union[str, Any]						     =     FlaxViTModelTester(self	)
          UpperCamelCase   :  List[Any]						     =     FlaxBertModelTester(self	)
          UpperCamelCase   :  Optional[Any]						     =     vit_model_tester.prepare_config_and_inputs()
          UpperCamelCase   :  Tuple						     =     bert_model_tester.prepare_config_and_inputs()

          UpperCamelCase   :  Optional[Any]						     =     vision_config_and_inputs

          UpperCamelCase   :  Optional[Any]						     =     text_config_and_inputs

          # make sure that cross attention layers are added
          return {
              "text_config": text_config,
              "vision_config": vision_config,
              "pixel_values": pixel_values,
              "attention_mask": attention_mask,
              "input_ids": input_ids,
              "token_type_ids": token_type_ids,
          }






@require_torch
class     lowerCAmelCase_		(  a__	,   unittest.TestCase							):
       def  snake_case_	(      self	)					->		Optional[Any]:
          UpperCamelCase   :  List[Any]						     =     FlaxVisionTextDualEncoderModel.from_vision_text_pretrained(
              'hf-internal-testing/tiny-random-clip',      'hf-internal-testing/tiny-bert',      vision_from_pt=SCREAMING_SNAKE_CASE_,      text_from_pt=SCREAMING_SNAKE_CASE_,      )
          UpperCamelCase   :  Dict						     =     13
          UpperCamelCase   :  List[Any]						     =     floats_tensor(
              [
                  batch_size,
                  model.config.vision_config.num_channels,
                  model.config.vision_config.image_size,
                  model.config.vision_config.image_size,
              ]	)
          UpperCamelCase   :  Tuple						     =     ids_tensor([batch_size, 4],      model.config.text_config.vocab_size	)
          UpperCamelCase   :  Optional[int]						     =     random_attention_mask([batch_size, 4]	)
          UpperCamelCase   :  str						     =     {'pixel_values': pixel_values, 'input_ids': input_ids, 'attention_mask': attention_mask}

          return model, inputs
       def  snake_case_	(      self,      SCREAMING_SNAKE_CASE_,      SCREAMING_SNAKE_CASE_	)					->		Optional[Any]:
          UpperCamelCase   :  List[str]						     =     FlaxCLIPVisionModel(SCREAMING_SNAKE_CASE_	)
          UpperCamelCase   :  Dict						     =     FlaxBertModel(SCREAMING_SNAKE_CASE_	)
          return vision_model, text_model






       def  snake_case_	(      self	)					->		Union[str, Any]:
          UpperCamelCase   :  Optional[int]						     =     FlaxCLIPVisionModelTester(self	)
          UpperCamelCase   :  int						     =     FlaxBertModelTester(self	)
          UpperCamelCase   :  Optional[Any]						     =     clip_model_tester.prepare_config_and_inputs()
          UpperCamelCase   :  Tuple						     =     bert_model_tester.prepare_config_and_inputs()

          UpperCamelCase   :  Tuple						     =     vision_config_and_inputs

          UpperCamelCase   :  Dict						     =     text_config_and_inputs

          # make sure that cross attention layers are added
          return {
              "text_config": text_config,
              "vision_config": vision_config,
              "pixel_values": pixel_values,
              "attention_mask": attention_mask,
              "input_ids": input_ids,
              "token_type_ids": token_type_ids,
          }






@require_flax
@require_vision
class     lowerCAmelCase_		(  unittest.TestCase							):
       @slow
       def  snake_case_	(      self	)					->		List[str]:
          UpperCamelCase   :  Optional[Any]						     =     FlaxVisionTextDualEncoderModel.from_pretrained('clip-italian/clip-italian',      logit_scale_init_value=1.0	)
          UpperCamelCase   :  Dict						     =     VisionTextDualEncoderProcessor.from_pretrained('clip-italian/clip-italian'	)

          UpperCamelCase   :  Optional[Any]						     =     Image.open('./tests/fixtures/tests_samples/COCO/000000039769.png'	)
          UpperCamelCase   :  int						     =     processor(
              text=['una foto di un gatto', 'una foto di un cane'],      images=SCREAMING_SNAKE_CASE_,      padding=SCREAMING_SNAKE_CASE_,      return_tensors='np'	)

          UpperCamelCase   :  Union[str, Any]						     =     model(**SCREAMING_SNAKE_CASE_	)

          # verify the logits
          self.assertEqual(outputs.logits_per_image.shape,      (inputs.pixel_values.shape[0], inputs.input_ids.shape[0])	)
          self.assertEqual(
              outputs.logits_per_text.shape,      (inputs.input_ids.shape[0], inputs.pixel_values.shape[0]),      )

          UpperCamelCase   :  int						     =     np.array([[1.2_28_47_27, 0.3_10_41_22]]	)

          self.assertTrue(np.allclose(outputs.logits_per_image,      SCREAMING_SNAKE_CASE_,      atol=1e-3	)	)








import unittest

from transformers import JukeboxTokenizer
from transformers.testing_utils import require_torch



class     lowerCAmelCase_		(  unittest.TestCase							):
       UpperCAmelCase__    : Union[str, Any]       					=  JukeboxTokenizer
       UpperCAmelCase__    : Optional[int]       					=  {
           "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  snake_case_	(      self	)					->		Optional[Any]:
          import torch

          UpperCamelCase   :  Tuple						     =     JukeboxTokenizer.from_pretrained('openai/jukebox-1b-lyrics'	)
          UpperCamelCase   :  List[str]						     =     tokenizer(**self.metas	)['input_ids']
          # fmt: off
          UpperCamelCase   :  Dict						     =     [
              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  snake_case_	(      self	)					->		Optional[Any]:
          import torch

          UpperCamelCase   :  str						     =     JukeboxTokenizer.from_pretrained('openai/jukebox-5b-lyrics'	)
          UpperCamelCase   :  Dict						     =     tokenizer(**self.metas	)['input_ids']
          # fmt: off
          UpperCamelCase   :  Optional[int]						     =     [
              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]	)	)



