


import math
from collections import OrderedDict

import torch
from packaging import version
from torch import Tensor, nn

from .utils import logging


_A							     =       logging.get_logger(__name__)

class 			lowerCamelCase_					(    nn.Module    ):





							def __init__(							self    ):
								super().__init__()
								if version.parse(torch.__version__    ) < version.parse("""1.12.0"""    ):
									raise ImportError(
									    f"""You are using torch=={torch.__version__}, but torch>=1.12.0 is required to use """
									    """PytorchGELUTanh. Please upgrade torch."""    )





							def   __magic_name__      (							self			,       _SCREAMING_SNAKE_CASE    ):
								return nn.functional.gelu(_SCREAMING_SNAKE_CASE			,       approximate="""tanh"""    )







class 			lowerCamelCase_					(    nn.Module    ):





							def   __magic_name__      (							self			,       _SCREAMING_SNAKE_CASE    ):
								return 0.5 * input * (1.0 + torch.tanh(math.sqrt(2.0 / math.pi    ) * (input + 0.0_4_4_7_1_5 * torch.pow(_SCREAMING_SNAKE_CASE			,       3.0    ))    ))







class 			lowerCamelCase_					(    nn.Module    ):





							def __init__(							self			,       _SCREAMING_SNAKE_CASE = False    ):
								super().__init__()
								if use_gelu_python:
									a_     			=   self._gelu_python
								else:
									a_     			=   nn.functional.gelu





							def   __magic_name__      (							self			,       _SCREAMING_SNAKE_CASE    ):
								return input * 0.5 * (1.0 + torch.erf(input / math.sqrt(2.0    )    ))





							def   __magic_name__      (							self			,       _SCREAMING_SNAKE_CASE    ):
								return self.act(_SCREAMING_SNAKE_CASE    )







class 			lowerCamelCase_					(    nn.Module    ):





							def   __magic_name__      (							self			,       _SCREAMING_SNAKE_CASE    ):
								return 0.5 * input * (1.0 + torch.tanh(input * 0.7_9_7_8_8_4_5_6_0_8 * (1.0 + 0.0_4_4_7_1_5 * input * input)    ))







class 			lowerCamelCase_					(    nn.Module    ):





							def   __magic_name__      (							self			,       _SCREAMING_SNAKE_CASE    ):
								return input * torch.sigmoid(1.7_0_2 * input    )







class 			lowerCamelCase_					(    nn.Module    ):





							def __init__(							self			,       _SCREAMING_SNAKE_CASE			,       _SCREAMING_SNAKE_CASE    ):
								if min > max:
									raise ValueError(f"""min should be < max (got min: {min}, max: {max})"""    )

								super().__init__()
								a_     			=   min
								a_     			=   max





							def   __magic_name__      (							self			,       _SCREAMING_SNAKE_CASE    ):
								return torch.clip(gelu(_SCREAMING_SNAKE_CASE    )			,       self.min			,       self.max    )







class 			lowerCamelCase_					(    nn.Module    ):





							def __init__(							self    ):
								super().__init__()
								a_     			=   math.sqrt(2 / math.pi    )





							def   __magic_name__      (							self			,       _SCREAMING_SNAKE_CASE    ):
								return 0.5 * input * (1 + torch.tanh(self.precomputed_constant * (input + 0.0_4_4_7_1_5 * torch.pow(_SCREAMING_SNAKE_CASE			,       3    ))    ))







class 			lowerCamelCase_					(    nn.Module    ):





							def   __magic_name__      (							self			,       _SCREAMING_SNAKE_CASE    ):
								return nn.functional.silu(_SCREAMING_SNAKE_CASE    )







class 			lowerCamelCase_					(    nn.Module    ):





							def __init__(							self    ):
								super().__init__()
								if version.parse(torch.__version__    ) < version.parse("""1.9.0"""    ):
									a_     			=   self._mish_python
								else:
									a_     			=   nn.functional.mish





							def   __magic_name__      (							self			,       _SCREAMING_SNAKE_CASE    ):
								return input * torch.tanh(nn.functional.softplus(_SCREAMING_SNAKE_CASE    )    )





							def   __magic_name__      (							self			,       _SCREAMING_SNAKE_CASE    ):
								return self.act(_SCREAMING_SNAKE_CASE    )







class 			lowerCamelCase_					(    nn.Module    ):





							def   __magic_name__      (							self			,       _SCREAMING_SNAKE_CASE    ):
								return input







class 			lowerCamelCase_					(    nn.Module    ):





							def   __magic_name__      (							self			,       _SCREAMING_SNAKE_CASE			,       _SCREAMING_SNAKE_CASE=0.7_0_7_1_0_7			,       _SCREAMING_SNAKE_CASE=0.2_8_2_0_9_5    ):
								a_     			=   (input - mu).div(sigma * math.sqrt(2.0    )    )
								return 0.5 * (1.0 + torch.erf(_SCREAMING_SNAKE_CASE    ))







class 			lowerCamelCase_					(    nn.Module    ):





							def   __magic_name__      (							self			,       _SCREAMING_SNAKE_CASE    ):
								a_     			=   nn.functional.relu(_SCREAMING_SNAKE_CASE    )
								a_     			=   torch.square(_SCREAMING_SNAKE_CASE    )
								return squared







class 			lowerCamelCase_					(    _SCREAMING_SNAKE_CASE    ):





							def __getitem__(							self			,       _SCREAMING_SNAKE_CASE    ):
								a_     			=   super().__getitem__(_SCREAMING_SNAKE_CASE    )
								a_			, a_     			=   content if isinstance(_SCREAMING_SNAKE_CASE			,       _SCREAMING_SNAKE_CASE    ) else (content, {})
								return cls(**_SCREAMING_SNAKE_CASE    )







_A							     =       {
    'gelu': GELUActivation,
    'gelu_10': (ClippedGELUActivation, {'min': -10, 'max': 10}),
    'gelu_fast': FastGELUActivation,
    'gelu_new': NewGELUActivation,
    'gelu_python': (GELUActivation, {'use_gelu_python': True}),
    'gelu_pytorch_tanh': PytorchGELUTanh,
    'gelu_accurate': AccurateGELUActivation,
    'laplace': LaplaceActivation,
    'linear': LinearActivation,
    'mish': MishActivation,
    'quick_gelu': QuickGELUActivation,
    'relu': nn.ReLU,
    'relu2': ReLUSquaredActivation,
    'relu6': nn.ReLUa,
    'sigmoid': nn.Sigmoid,
    'silu': SiLUActivation,
    'swish': SiLUActivation,
    'tanh': nn.Tanh,
}
_A							     =       ClassInstantier(ACTaCLS)

def 			__SCREAMING_SNAKE_CASE		(		UpperCamelCase		:      Tuple	)     ->	str:



	"""simple docstring"""






	if activation_string in ACTaFN:
		return ACTaFN[activation_string]
	else:
		raise KeyError(F"""function {activation_string} not found in ACT2FN mapping {list(ACTaFN.keys()	)}"""	)


# For backwards compatibility with: from activations import gelu_python
_A							     =       get_activation('gelu_python')
_A							     =       get_activation('gelu_new')
_A							     =       get_activation('gelu')
_A							     =       get_activation('gelu_fast')
_A							     =       get_activation('quick_gelu')
_A							     =       get_activation('silu')
_A							     =       get_activation('mish')
_A							     =       get_activation('linear')



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							     =       random.Random()

def 			__SCREAMING_SNAKE_CASE		(		UpperCamelCase		:      List[Any]     ,					UpperCamelCase		:      Any=1.0     ,					UpperCamelCase		:      Union[str, Any]=None     ,					UpperCamelCase		:      Union[str, Any]=None	)     ->	List[Any]:



	"""simple docstring"""






	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 			lowerCamelCase_					(    unittest.TestCase    ):





							def   __magic_name__      (							self    ):
								a_     			=   """facebook/musicgen-small"""
								a_     			=   tempfile.mkdtemp()





							def   __magic_name__      (							self			,       **_SCREAMING_SNAKE_CASE    ):
								return TaTokenizer.from_pretrained(self.checkpoint			,       **_SCREAMING_SNAKE_CASE    )





							def   __magic_name__      (							self			,       **_SCREAMING_SNAKE_CASE    ):
								return EncodecFeatureExtractor.from_pretrained(self.checkpoint			,       **_SCREAMING_SNAKE_CASE    )





							def   __magic_name__      (							self    ):
								shutil.rmtree(self.tmpdirname    )





							def   __magic_name__      (							self    ):
								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   __magic_name__      (							self    ):
								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   __magic_name__      (							self    ):
								a_     			=   self.get_feature_extractor()
								a_     			=   self.get_tokenizer()

								a_     			=   MusicgenProcessor(tokenizer=_SCREAMING_SNAKE_CASE			,       feature_extractor=_SCREAMING_SNAKE_CASE    )

								a_     			=   floats_list((3, 1000)    )

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