




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


SCREAMING_SNAKE_CASE_    :       int       =							random.Random()
def 							__lowerCAmelCase			(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 		__UpperCAmelCase(		unittest.TestCase			):





     """simple docstring"""



     def 					__SCREAMING_SNAKE_CASE		(   self			:							Union[str, Any]     )      ->      List[Any]:






         """simple docstring"""
         a__  			=							"""facebook/musicgen-small"""
         a__  			=							tempfile.mkdtemp()

     def 					__SCREAMING_SNAKE_CASE		(   self			:							Tuple    ,					**A			:							Tuple     )      ->      List[str]:






         """simple docstring"""
         return TaTokenizer.from_pretrained(self.checkpoint    ,					**A     )

     def 					__SCREAMING_SNAKE_CASE		(   self			:							Union[str, Any]    ,					**A			:							List[Any]     )      ->      int:






         """simple docstring"""
         return EncodecFeatureExtractor.from_pretrained(self.checkpoint    ,					**A     )

     def 					__SCREAMING_SNAKE_CASE		(   self			:							Union[str, Any]     )      ->      Tuple:






         """simple docstring"""
         shutil.rmtree(self.tmpdirname     )

     def 					__SCREAMING_SNAKE_CASE		(   self			:							Dict     )      ->      Optional[Any]:






         """simple docstring"""
         a__  			=							self.get_tokenizer()
         a__  			=							self.get_feature_extractor()

         a__  			=							MusicgenProcessor(tokenizer=A    ,					feature_extractor=A     )

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

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

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

     def 					__SCREAMING_SNAKE_CASE		(   self			:							Dict     )      ->      List[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=A    ,					padding_value=1.0     )

         a__  			=							MusicgenProcessor.from_pretrained(
             self.tmpdirname    ,					bos_token="""(BOS)"""    ,					eos_token="""(EOS)"""    ,					do_normalize=A    ,					padding_value=1.0     )

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

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

     def 					__SCREAMING_SNAKE_CASE		(   self			:							Optional[int]     )      ->      str:






         """simple docstring"""
         a__  			=							self.get_feature_extractor()
         a__  			=							self.get_tokenizer()

         a__  			=							MusicgenProcessor(tokenizer=A    ,					feature_extractor=A     )

         a__  			=							floats_list((3, 10_00)     )

         a__  			=							feature_extractor(A    ,					return_tensors="""np"""     )
         a__  			=							processor(A    ,					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 					__SCREAMING_SNAKE_CASE		(   self			:							Optional[int]     )      ->      List[str]:






         """simple docstring"""
         a__  			=							self.get_feature_extractor()
         a__  			=							self.get_tokenizer()

         a__  			=							MusicgenProcessor(tokenizer=A    ,					feature_extractor=A     )

         a__  			=							"""This is a test string"""

         a__  			=							processor(text=A     )

         a__  			=							tokenizer(A     )

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

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






         """simple docstring"""
         a__  			=							self.get_feature_extractor()
         a__  			=							self.get_tokenizer()

         a__  			=							MusicgenProcessor(tokenizer=A    ,					feature_extractor=A     )

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

         a__  			=							processor.batch_decode(sequences=A     )
         a__  			=							tokenizer.batch_decode(A     )

         self.assertListEqual(A    ,					A     )

     def 					__SCREAMING_SNAKE_CASE		(   self			:							str     )      ->      str:






         """simple docstring"""
         a__  			=							self.get_feature_extractor()
         a__  			=							self.get_tokenizer()

         a__  			=							MusicgenProcessor(tokenizer=A    ,					feature_extractor=A     )

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






     def 					__SCREAMING_SNAKE_CASE		(   self			:							List[str]     )      ->      Optional[Any]:






         """simple docstring"""
         a__  			=							self.get_feature_extractor(padding_side="""left"""     )
         a__  			=							self.get_tokenizer()

         a__  			=							MusicgenProcessor(tokenizer=A    ,					feature_extractor=A     )

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

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

         self.assertIsInstance(A    ,					A     )

         for audio in decoded_audios:
             self.assertIsInstance(A    ,					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)     )












from __future__ import annotations

import sys
def 							__lowerCAmelCase			(UpperCAmelCase_		):
    if n < 0:
        raise ValueError("""Negative arguments are not supported"""		)
    return _fib(UpperCAmelCase_		)[0]
def 							__lowerCAmelCase			(UpperCAmelCase_		):
    if n == 0:  # (F(0), F(1))
        return (0, 1)

    # F(2n) = F(n)[2F(n+1) − F(n)]
    # F(2n+1) = F(n+1)^2+F(n)^2
    a__			,		a__  			=							_fib(n // 2		)
    a__  			=							a * (b * 2 - a)
    a__  			=							a * a + b * b
    return (d, c + d) if n % 2 else (c, d)


if __name__ == "__main__":
 SCREAMING_SNAKE_CASE_    :       Dict       =							int(sys.argv[1])
 print(F"fibonacci({n}) is {fibonacci(n)}")






