






'''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


lowerCamelCase_					:			Tuple     						=				random.Random()







def 						__magic_name__(			_A    ,   _A=1.0    ,   _A=None    ,   _A=None       ):
						'''simple docstring'''





						if rng is None:
												UpperCamelCase__       =			global_rng

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


			'''simple docstring'''





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

									'''simple docstring'''







									UpperCamelCase__       =			"""facebook/musicgen-small"""
									UpperCamelCase__       =			tempfile.mkdtemp()






			def 					A   ( self				:    List[Any]			,   **lowercase				:    Optional[Any]      )				->     str:

									'''simple docstring'''







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






			def 					A   ( self				:    Dict			,   **lowercase				:    List[str]      )				->     str:

									'''simple docstring'''







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






			def 					A   ( self				:    Optional[Any]      )				->     Any:

									'''simple docstring'''







									shutil.rmtree(self.tmpdirname      )






			def 					A   ( self				:    Dict      )				->     Dict:

									'''simple docstring'''







									UpperCamelCase__       =			self.get_tokenizer()
									UpperCamelCase__       =			self.get_feature_extractor()

									UpperCamelCase__       =			MusicgenProcessor(tokenizer=lowercase			,   feature_extractor=lowercase      )

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

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

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






			def 					A   ( self				:    Dict      )				->     Union[str, Any]:

									'''simple docstring'''







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

									UpperCamelCase__       =			self.get_tokenizer(bos_token="""(BOS)"""			,   eos_token="""(EOS)"""      )
									UpperCamelCase__       =			self.get_feature_extractor(do_normalize=lowercase			,   padding_value=1.0      )

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

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

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






			def 					A   ( self				:    Any      )				->     Optional[Any]:

									'''simple docstring'''







									UpperCamelCase__       =			self.get_feature_extractor()
									UpperCamelCase__       =			self.get_tokenizer()

									UpperCamelCase__       =			MusicgenProcessor(tokenizer=lowercase			,   feature_extractor=lowercase      )

									UpperCamelCase__       =			floats_list((3, 1_0_0_0)      )

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

									'''simple docstring'''







									UpperCamelCase__       =			self.get_feature_extractor()
									UpperCamelCase__       =			self.get_tokenizer()

									UpperCamelCase__       =			MusicgenProcessor(tokenizer=lowercase			,   feature_extractor=lowercase      )

									UpperCamelCase__       =			"""This is a test string"""

									UpperCamelCase__       =			processor(text=lowercase      )

									UpperCamelCase__       =			tokenizer(lowercase      )

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






			def 					A   ( self				:    Optional[int]      )				->     List[Any]:

									'''simple docstring'''







									UpperCamelCase__       =			self.get_feature_extractor()
									UpperCamelCase__       =			self.get_tokenizer()

									UpperCamelCase__       =			MusicgenProcessor(tokenizer=lowercase			,   feature_extractor=lowercase      )

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

									UpperCamelCase__       =			processor.batch_decode(sequences=lowercase      )
									UpperCamelCase__       =			tokenizer.batch_decode(lowercase      )

									self.assertListEqual(lowercase			,   lowercase      )






			def 					A   ( self				:    int      )				->     List[Any]:

									'''simple docstring'''







									UpperCamelCase__       =			self.get_feature_extractor()
									UpperCamelCase__       =			self.get_tokenizer()

									UpperCamelCase__       =			MusicgenProcessor(tokenizer=lowercase			,   feature_extractor=lowercase      )

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







			def 					A   ( self				:    Tuple      )				->     List[Any]:

									'''simple docstring'''







									UpperCamelCase__       =			self.get_feature_extractor(padding_side="""left"""      )
									UpperCamelCase__       =			self.get_tokenizer()

									UpperCamelCase__       =			MusicgenProcessor(tokenizer=lowercase			,   feature_extractor=lowercase      )

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

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

									self.assertIsInstance(lowercase			,   lowercase      )

									for audio in decoded_audios:
															self.assertIsInstance(lowercase			,   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 dataclasses import dataclass
from typing import List, Optional, Union

import numpy as np
import PIL
from PIL import Image

from ...utils import BaseOutput, is_torch_available, is_transformers_available
@dataclass
# Copied from diffusers.pipelines.stable_diffusion.__init__.StableDiffusionPipelineOutput with Stable->Alt
class  _SCREAMING_SNAKE_CASE				(		SCREAMING_SNAKE_CASE						):


			'''simple docstring'''





			__a				:				Union[List[PIL.Image.Image], np.ndarray]
			__a				:				Optional[List[bool]]


if is_transformers_available() and is_torch_available():
					from .modeling_roberta_series import RobertaSeriesModelWithTransformation
					from .pipeline_alt_diffusion import AltDiffusionPipeline
					from .pipeline_alt_diffusion_imgaimg import AltDiffusionImgaImgPipeline
