



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


__snake_case		:int 						=	random.Random()





def 	__snake_case      (     _UpperCAmelCase  ,					_UpperCAmelCase=1.0  ,					_UpperCAmelCase=None  ,					_UpperCAmelCase=None							):
    if rng is None:
        __a					=							global_rng

    __a					=							[]
    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        _A			(      unittest.TestCase       ):



       def 						_lowerCamelCase     (						self				:	Tuple):


           '''simple docstring'''

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



       def 						_lowerCamelCase     (						self				:	Optional[Any]	,						**__SCREAMING_SNAKE_CASE				:	List[str]):


           '''simple docstring'''

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



       def 						_lowerCamelCase     (						self				:	Union[str, Any]	,						**__SCREAMING_SNAKE_CASE				:	str):


           '''simple docstring'''

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



       def 						_lowerCamelCase     (						self				:	str):


           '''simple docstring'''

           shutil.rmtree(self.tmpdirname)



       def 						_lowerCamelCase     (						self				:	str):


           '''simple docstring'''

           __a					=							self.get_tokenizer()
           __a					=							self.get_feature_extractor()

           __a					=							MusicgenProcessor(tokenizer=__SCREAMING_SNAKE_CASE	,						feature_extractor=__SCREAMING_SNAKE_CASE)

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

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

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



       def 						_lowerCamelCase     (						self				:	str):


           '''simple docstring'''

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

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

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

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

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



       def 						_lowerCamelCase     (						self				:	int):


           '''simple docstring'''

           __a					=							self.get_feature_extractor()
           __a					=							self.get_tokenizer()

           __a					=							MusicgenProcessor(tokenizer=__SCREAMING_SNAKE_CASE	,						feature_extractor=__SCREAMING_SNAKE_CASE)

           __a					=							floats_list((3, 1_000))

           __a					=							feature_extractor(__SCREAMING_SNAKE_CASE	,						return_tensors='''np''')
           __a					=							processor(__SCREAMING_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 						_lowerCamelCase     (						self				:	str):


           '''simple docstring'''

           __a					=							self.get_feature_extractor()
           __a					=							self.get_tokenizer()

           __a					=							MusicgenProcessor(tokenizer=__SCREAMING_SNAKE_CASE	,						feature_extractor=__SCREAMING_SNAKE_CASE)

           __a					=							'''This is a test string'''

           __a					=							processor(text=__SCREAMING_SNAKE_CASE)

           __a					=							tokenizer(__SCREAMING_SNAKE_CASE)

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



       def 						_lowerCamelCase     (						self				:	int):


           '''simple docstring'''

           __a					=							self.get_feature_extractor()
           __a					=							self.get_tokenizer()

           __a					=							MusicgenProcessor(tokenizer=__SCREAMING_SNAKE_CASE	,						feature_extractor=__SCREAMING_SNAKE_CASE)

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

           __a					=							processor.batch_decode(sequences=__SCREAMING_SNAKE_CASE)
           __a					=							tokenizer.batch_decode(__SCREAMING_SNAKE_CASE)

           self.assertListEqual(__SCREAMING_SNAKE_CASE	,						__SCREAMING_SNAKE_CASE)



       def 						_lowerCamelCase     (						self				:	Tuple):


           '''simple docstring'''

           __a					=							self.get_feature_extractor()
           __a					=							self.get_tokenizer()

           __a					=							MusicgenProcessor(tokenizer=__SCREAMING_SNAKE_CASE	,						feature_extractor=__SCREAMING_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 						_lowerCamelCase     (						self				:	Union[str, Any]):


           '''simple docstring'''

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

           __a					=							MusicgenProcessor(tokenizer=__SCREAMING_SNAKE_CASE	,						feature_extractor=__SCREAMING_SNAKE_CASE)

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

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

           self.assertIsInstance(__SCREAMING_SNAKE_CASE	,						__SCREAMING_SNAKE_CASE)

           for audio in decoded_audios:
               self.assertIsInstance(__SCREAMING_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 	__snake_case      (     _UpperCAmelCase  ,					_UpperCAmelCase = 2							):
    return round((float(_UpperCAmelCase							) * 9 / 5) + 32  ,					_UpperCAmelCase							)





def 	__snake_case      (     _UpperCAmelCase  ,					_UpperCAmelCase = 2							):
    return round(float(_UpperCAmelCase							) + 2_73.15  ,					_UpperCAmelCase							)





def 	__snake_case      (     _UpperCAmelCase  ,					_UpperCAmelCase = 2							):
    return round((float(_UpperCAmelCase							) * 9 / 5) + 4_91.67  ,					_UpperCAmelCase							)





def 	__snake_case      (     _UpperCAmelCase  ,					_UpperCAmelCase = 2							):
    return round((float(_UpperCAmelCase							) - 32) * 5 / 9  ,					_UpperCAmelCase							)





def 	__snake_case      (     _UpperCAmelCase  ,					_UpperCAmelCase = 2							):
    return round(((float(_UpperCAmelCase							) - 32) * 5 / 9) + 2_73.15  ,					_UpperCAmelCase							)





def 	__snake_case      (     _UpperCAmelCase  ,					_UpperCAmelCase = 2							):
    return round(float(_UpperCAmelCase							) + 4_59.67  ,					_UpperCAmelCase							)





def 	__snake_case      (     _UpperCAmelCase  ,					_UpperCAmelCase = 2							):
    return round(float(_UpperCAmelCase							) - 2_73.15  ,					_UpperCAmelCase							)





def 	__snake_case      (     _UpperCAmelCase  ,					_UpperCAmelCase = 2							):
    return round(((float(_UpperCAmelCase							) - 2_73.15) * 9 / 5) + 32  ,					_UpperCAmelCase							)





def 	__snake_case      (     _UpperCAmelCase  ,					_UpperCAmelCase = 2							):
    return round((float(_UpperCAmelCase							) * 9 / 5)  ,					_UpperCAmelCase							)





def 	__snake_case      (     _UpperCAmelCase  ,					_UpperCAmelCase = 2							):
    return round((float(_UpperCAmelCase							) - 4_91.67) * 5 / 9  ,					_UpperCAmelCase							)





def 	__snake_case      (     _UpperCAmelCase  ,					_UpperCAmelCase = 2							):
    return round(float(_UpperCAmelCase							) - 4_59.67  ,					_UpperCAmelCase							)





def 	__snake_case      (     _UpperCAmelCase  ,					_UpperCAmelCase = 2							):
    return round((float(_UpperCAmelCase							) * 5 / 9)  ,					_UpperCAmelCase							)





def 	__snake_case      (     _UpperCAmelCase  ,					_UpperCAmelCase = 2							):
    return round((float(_UpperCAmelCase							) * 1.25 + 2_73.15)  ,					_UpperCAmelCase							)





def 	__snake_case      (     _UpperCAmelCase  ,					_UpperCAmelCase = 2							):
    return round((float(_UpperCAmelCase							) * 2.25 + 32)  ,					_UpperCAmelCase							)





def 	__snake_case      (     _UpperCAmelCase  ,					_UpperCAmelCase = 2							):
    return round((float(_UpperCAmelCase							) * 1.25)  ,					_UpperCAmelCase							)





def 	__snake_case      (     _UpperCAmelCase  ,					_UpperCAmelCase = 2							):
    return round((float(_UpperCAmelCase							) * 2.25 + 32 + 4_59.67)  ,					_UpperCAmelCase							)


if __name__ == "__main__":
 import doctest

 doctest.testmod()





