





import random
import shutil
import tempfile
import unittest

import numpy as np

from transformers import TaTokenizer, TaTokenizerFast
from transformers.testing_utils import require_sentencepiece, require_torch
from transformers.utils.import_utils import is_speech_available, is_torch_available


if is_torch_available():
      pass

if is_speech_available():
      from transformers import EncodecFeatureExtractor, MusicgenProcessor


__lowercase				    =      random.Random()


def        __SCREAMING_SNAKE_CASE	(				__lowercase:		int  ,				__lowercase:		Tuple=1.0  ,				__lowercase:		Optional[int]=None  ,				__lowercase:		List[str]=None):



  '''simple docstring'''






  if rng is None:
    __lowerCAmelCase								=					global_rng

  __lowerCAmelCase								=					[]
  for batch_idx in range(shape[0]):
    values.append([])
    for _ in range(shape[1]):
      values[-1].append(rng.random() * scale)

  return values




@require_torch
@require_sentencepiece
class 	__snake_case					(      unittest.TestCase ):






    '''simple docstring'''





    def 						A		( self    :		int				):

      """simple docstring"""





      __lowerCAmelCase								=					'''facebook/musicgen-small'''
      __lowerCAmelCase								=					tempfile.mkdtemp()





    def 						A		( self    :		Tuple      ,    **snake_case    :		List[Any]				):

      """simple docstring"""





      return TaTokenizer.from_pretrained(self.checkpoint      ,    **snake_case				)





    def 						A		( self    :		List[Any]      ,    **snake_case    :		int				):

      """simple docstring"""





      return EncodecFeatureExtractor.from_pretrained(self.checkpoint      ,    **snake_case				)





    def 						A		( self    :		Tuple				):

      """simple docstring"""





      shutil.rmtree(self.tmpdirname				)





    def 						A		( self    :		List[str]				):

      """simple docstring"""





      __lowerCAmelCase								=					self.get_tokenizer()
      __lowerCAmelCase								=					self.get_feature_extractor()

      __lowerCAmelCase								=					MusicgenProcessor(tokenizer=snake_case      ,    feature_extractor=snake_case				)

      processor.save_pretrained(self.tmpdirname				)
      __lowerCAmelCase								=					MusicgenProcessor.from_pretrained(self.tmpdirname				)

      self.assertEqual(processor.tokenizer.get_vocab()      ,    tokenizer.get_vocab()				)
      self.assertIsInstance(processor.tokenizer      ,    snake_case				)

      self.assertEqual(processor.feature_extractor.to_json_string()      ,    feature_extractor.to_json_string()				)
      self.assertIsInstance(processor.feature_extractor      ,    snake_case				)





    def 						A		( self    :		Optional[int]				):

      """simple docstring"""





      __lowerCAmelCase								=					MusicgenProcessor(tokenizer=self.get_tokenizer()      ,    feature_extractor=self.get_feature_extractor()				)
      processor.save_pretrained(self.tmpdirname				)

      __lowerCAmelCase								=					self.get_tokenizer(bos_token='''(BOS)'''      ,    eos_token='''(EOS)'''				)
      __lowerCAmelCase								=					self.get_feature_extractor(do_normalize=snake_case      ,    padding_value=1.0				)

      __lowerCAmelCase								=					MusicgenProcessor.from_pretrained(
          self.tmpdirname      ,    bos_token='''(BOS)'''      ,    eos_token='''(EOS)'''      ,    do_normalize=snake_case      ,    padding_value=1.0				)

      self.assertEqual(processor.tokenizer.get_vocab()      ,    tokenizer_add_kwargs.get_vocab()				)
      self.assertIsInstance(processor.tokenizer      ,    snake_case				)

      self.assertEqual(processor.feature_extractor.to_json_string()      ,    feature_extractor_add_kwargs.to_json_string()				)
      self.assertIsInstance(processor.feature_extractor      ,    snake_case				)





    def 						A		( self    :		int				):

      """simple docstring"""





      __lowerCAmelCase								=					self.get_feature_extractor()
      __lowerCAmelCase								=					self.get_tokenizer()

      __lowerCAmelCase								=					MusicgenProcessor(tokenizer=snake_case      ,    feature_extractor=snake_case				)

      __lowerCAmelCase								=					floats_list((3, 1_000)				)

      __lowerCAmelCase								=					feature_extractor(snake_case      ,    return_tensors='''np'''				)
      __lowerCAmelCase								=					processor(snake_case      ,    return_tensors='''np'''				)

      for key in input_feat_extract.keys():
        self.assertAlmostEqual(input_feat_extract[key].sum()      ,    input_processor[key].sum()      ,    delta=1e-2				)





    def 						A		( self    :		str				):

      """simple docstring"""





      __lowerCAmelCase								=					self.get_feature_extractor()
      __lowerCAmelCase								=					self.get_tokenizer()

      __lowerCAmelCase								=					MusicgenProcessor(tokenizer=snake_case      ,    feature_extractor=snake_case				)

      __lowerCAmelCase								=					'''This is a test string'''

      __lowerCAmelCase								=					processor(text=snake_case				)

      __lowerCAmelCase								=					tokenizer(snake_case				)

      for key in encoded_tok.keys():
        self.assertListEqual(encoded_tok[key]      ,    encoded_processor[key]				)





    def 						A		( self    :		List[str]				):

      """simple docstring"""





      __lowerCAmelCase								=					self.get_feature_extractor()
      __lowerCAmelCase								=					self.get_tokenizer()

      __lowerCAmelCase								=					MusicgenProcessor(tokenizer=snake_case      ,    feature_extractor=snake_case				)

      __lowerCAmelCase								=					[[1, 4, 5, 8, 1, 0, 8], [3, 4, 3, 1, 1, 8, 9]]

      __lowerCAmelCase								=					processor.batch_decode(sequences=snake_case				)
      __lowerCAmelCase								=					tokenizer.batch_decode(snake_case				)

      self.assertListEqual(snake_case      ,    snake_case				)





    def 						A		( self    :		Tuple				):

      """simple docstring"""





      __lowerCAmelCase								=					self.get_feature_extractor()
      __lowerCAmelCase								=					self.get_tokenizer()

      __lowerCAmelCase								=					MusicgenProcessor(tokenizer=snake_case      ,    feature_extractor=snake_case				)

      self.assertListEqual(
          processor.model_input_names      ,    feature_extractor.model_input_names      ,    msg='''`processor` and `feature_extractor` model input names do not match'''      ,    )





    def 						A		( self    :		List[Any]				):

      """simple docstring"""





      __lowerCAmelCase								=					self.get_feature_extractor(padding_side='''left'''				)
      __lowerCAmelCase								=					self.get_tokenizer()

      __lowerCAmelCase								=					MusicgenProcessor(tokenizer=snake_case      ,    feature_extractor=snake_case				)

      __lowerCAmelCase								=					[floats_list((1, x)				)[0] for x in range(5      ,    20      ,    5				)]
      __lowerCAmelCase								=					processor(snake_case				).padding_mask

      __lowerCAmelCase								=					np.asarray(floats_list((3, 20)				)				)[:, None, :]
      __lowerCAmelCase								=					processor.batch_decode(snake_case      ,    padding_mask=snake_case				)

      self.assertIsInstance(snake_case      ,    snake_case				)

      for audio in decoded_audios:
        self.assertIsInstance(snake_case      ,    np.ndarray				)

      self.assertTrue(decoded_audios[0].shape == (1, 10)				)
      self.assertTrue(decoded_audios[1].shape == (1, 15)				)
      self.assertTrue(decoded_audios[2].shape == (1, 20)				)







def        __SCREAMING_SNAKE_CASE	(				__lowercase:		int = 10_00):



  '''simple docstring'''






  __lowerCAmelCase								=					0
  for i in range(__lowercase):
    if i % 3 == 0 or i % 5 == 0:
      result += i
  return result


if __name__ == "__main__":
      print(f"""{solution() = }""")
