

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


lowerCAmelCase_ 			=			random.Random()


def 						__SCREAMING_SNAKE_CASE      (SCREAMING_SNAKE_CASE__						,	SCREAMING_SNAKE_CASE__=1.0						,	SCREAMING_SNAKE_CASE__=None						,	SCREAMING_SNAKE_CASE__=None ):
						if rng is None:
												snake_case_     =			global_rng

						snake_case_     =			[]
						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        snake_case__(  self				:       List[Any]							)   ->Tuple:
									snake_case_     =			'''facebook/musicgen-small'''
									snake_case_     =			tempfile.mkdtemp()







			def        snake_case__(  self				:       Tuple							,     **_UpperCamelCase				:       Tuple							)   ->str:
									return TaTokenizer.from_pretrained(self.checkpoint							,     **_UpperCamelCase							)







			def        snake_case__(  self				:       str							,     **_UpperCamelCase				:       List[Any]							)   ->Any:
									return EncodecFeatureExtractor.from_pretrained(self.checkpoint							,     **_UpperCamelCase							)







			def        snake_case__(  self				:       List[str]							)   ->List[str]:
									shutil.rmtree(self.tmpdirname							)







			def        snake_case__(  self				:       Union[str, Any]							)   ->Optional[int]:
									snake_case_     =			self.get_tokenizer()
									snake_case_     =			self.get_feature_extractor()

									snake_case_     =			MusicgenProcessor(tokenizer=_UpperCamelCase							,     feature_extractor=_UpperCamelCase							)

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

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

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







			def        snake_case__(  self				:       Dict							)   ->Dict:
									snake_case_     =			MusicgenProcessor(tokenizer=self.get_tokenizer()							,     feature_extractor=self.get_feature_extractor()							)
									processor.save_pretrained(self.tmpdirname							)

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

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

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

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







			def        snake_case__(  self				:       Any							)   ->int:
									snake_case_     =			self.get_feature_extractor()
									snake_case_     =			self.get_tokenizer()

									snake_case_     =			MusicgenProcessor(tokenizer=_UpperCamelCase							,     feature_extractor=_UpperCamelCase							)

									snake_case_     =			floats_list((3, 1_0_0_0)							)

									snake_case_     =			feature_extractor(_UpperCamelCase							,     return_tensors='''np'''							)
									snake_case_     =			processor(_UpperCamelCase							,     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        snake_case__(  self				:       List[Any]							)   ->Tuple:
									snake_case_     =			self.get_feature_extractor()
									snake_case_     =			self.get_tokenizer()

									snake_case_     =			MusicgenProcessor(tokenizer=_UpperCamelCase							,     feature_extractor=_UpperCamelCase							)

									snake_case_     =			'''This is a test string'''

									snake_case_     =			processor(text=_UpperCamelCase							)

									snake_case_     =			tokenizer(_UpperCamelCase							)

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







			def        snake_case__(  self				:       Optional[int]							)   ->List[Any]:
									snake_case_     =			self.get_feature_extractor()
									snake_case_     =			self.get_tokenizer()

									snake_case_     =			MusicgenProcessor(tokenizer=_UpperCamelCase							,     feature_extractor=_UpperCamelCase							)

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

									snake_case_     =			processor.batch_decode(sequences=_UpperCamelCase							)
									snake_case_     =			tokenizer.batch_decode(_UpperCamelCase							)

									self.assertListEqual(_UpperCamelCase							,     _UpperCamelCase							)







			def        snake_case__(  self				:       Any							)   ->List[Any]:
									snake_case_     =			self.get_feature_extractor()
									snake_case_     =			self.get_tokenizer()

									snake_case_     =			MusicgenProcessor(tokenizer=_UpperCamelCase							,     feature_extractor=_UpperCamelCase							)

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







			def        snake_case__(  self				:       Dict							)   ->Union[str, Any]:
									snake_case_     =			self.get_feature_extractor(padding_side='''left'''							)
									snake_case_     =			self.get_tokenizer()

									snake_case_     =			MusicgenProcessor(tokenizer=_UpperCamelCase							,     feature_extractor=_UpperCamelCase							)

									snake_case_     =			[floats_list((1, x)							)[0] for x in range(5							,     2_0							,     5							)]
									snake_case_     =			processor(_UpperCamelCase							).padding_mask

									snake_case_     =			np.asarray(floats_list((3, 2_0)							)							)[:, None, :]
									snake_case_     =			processor.batch_decode(_UpperCamelCase							,     padding_mask=_UpperCamelCase							)

									self.assertIsInstance(_UpperCamelCase							,     _UpperCamelCase							)

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


def 						__SCREAMING_SNAKE_CASE      (SCREAMING_SNAKE_CASE__						,	SCREAMING_SNAKE_CASE__ ):
						return (input_a, input_a).count(0 ) % 2


def 						__SCREAMING_SNAKE_CASE      ():
						assert xor_gate(0						,	0 ) == 0
						assert xor_gate(0						,	1 ) == 1
						assert xor_gate(1						,	0 ) == 1
						assert xor_gate(1						,	1 ) == 0


if __name__ == "__main__":
					print(xor_gate(0, 0))
					print(xor_gate(0, 1))