
"""simple docstring"""




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


a		:					Dict    	=					random.Random()



def 						__magic_name__		(				UpperCamelCase    :		Optional[int]       ,		UpperCamelCase    :		Any=1.0       ,		UpperCamelCase    :		str=None       ,		UpperCamelCase    :		Tuple=None    )    ->	Tuple:
    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 						lowercase(unittest.TestCase					):



     def  lowercase__     (       self      )		->    str:







         """simple docstring"""



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



     def  lowercase__     (       self    ,							**__SCREAMING_SNAKE_CASE      )		->    Optional[int]:







         """simple docstring"""



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



     def  lowercase__     (       self    ,							**__SCREAMING_SNAKE_CASE      )		->    str:







         """simple docstring"""



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



     def  lowercase__     (       self      )		->    List[str]:







         """simple docstring"""



         shutil.rmtree(self.tmpdirname      )



     def  lowercase__     (       self      )		->    Tuple:







         """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  lowercase__     (       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  lowercase__     (       self      )		->    Dict:







         """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_0_0_0)      )

         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  lowercase__     (       self      )		->    Tuple:







         """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  lowercase__     (       self      )		->    Optional[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  lowercase__     (       self      )		->    Any:







         """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  lowercase__     (       self      )		->    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    ,							2_0    ,							5      )]
         a__    = processor(__SCREAMING_SNAKE_CASE      ).padding_mask

         a__    = np.asarray(floats_list((3, 2_0)      )      )[:, 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, 1_0)      )
         self.assertTrue(decoded_audios[1].shape == (1, 1_5)      )
         self.assertTrue(decoded_audios[2].shape == (1, 2_0)      )




"""simple docstring"""




from itertools import combinations, product



def 						__magic_name__		(				UpperCamelCase    :		int       ,		UpperCamelCase    :		int       ,		UpperCamelCase    :		int       ,		UpperCamelCase    :		int    )    ->	bool:
    if xa == ya == 0 or xa == ya == 0:
        return False
    a__    = xa * xa + ya * ya
    a__    = xa * xa + ya * ya
    a__    = (xa - xa) * (xa - xa) + (ya - ya) * (ya - ya)
    return (
        a_square + b_square == c_square
        or a_square + c_square == b_square
        or b_square + c_square == a_square
    )



def 						__magic_name__		(				UpperCamelCase    :		int = 50    )    ->	int:
    return sum(
        1
        for pta, pta in combinations(product(range(limit + 1    )       ,		repeat=2    )       ,		2    )
        if is_right(*UpperCamelCase       ,		*UpperCamelCase    )    )


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


