






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


lowercase_								=	random.Random()



def    lowerCAmelCase							(       __UpperCamelCase						,			__UpperCamelCase=1.0						,			__UpperCamelCase=None						,			__UpperCamelCase=None					):




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


   '''simple docstring'''

   def 							_SCREAMING_SNAKE_CASE							(      self					:	Any    ):

     '''simple docstring'''
     __A		     =					'''facebook/musicgen-small'''
     __A		     =					tempfile.mkdtemp()


   def 							_SCREAMING_SNAKE_CASE							(      self					:	List[Any],			**_lowerCamelCase					:	Tuple    ):

     '''simple docstring'''
     return TaTokenizer.from_pretrained(self.checkpoint,			**__UpperCAmelCase    )


   def 							_SCREAMING_SNAKE_CASE							(      self					:	List[str],			**_lowerCamelCase					:	Optional[int]    ):

     '''simple docstring'''
     return EncodecFeatureExtractor.from_pretrained(self.checkpoint,			**__UpperCAmelCase    )


   def 							_SCREAMING_SNAKE_CASE							(      self					:	int    ):

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


   def 							_SCREAMING_SNAKE_CASE							(      self					:	str    ):

     '''simple docstring'''
     __A		     =					self.get_tokenizer()
     __A		     =					self.get_feature_extractor()

     __A		     =					MusicgenProcessor(tokenizer=__UpperCAmelCase,			feature_extractor=__UpperCAmelCase    )

     processor.save_pretrained(self.tmpdirname    )
     __A		     =					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 							_SCREAMING_SNAKE_CASE							(      self					:	Any    ):

     '''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=__UpperCAmelCase,			padding_value=1.0    )

     __A		     =					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 							_SCREAMING_SNAKE_CASE							(      self					:	Optional[Any]    ):

     '''simple docstring'''
     __A		     =					self.get_feature_extractor()
     __A		     =					self.get_tokenizer()

     __A		     =					MusicgenProcessor(tokenizer=__UpperCAmelCase,			feature_extractor=__UpperCAmelCase    )

     __A		     =					floats_list((3, 10_00)    )

     __A		     =					feature_extractor(__UpperCAmelCase,			return_tensors='''np'''    )
     __A		     =					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 							_SCREAMING_SNAKE_CASE							(      self					:	List[str]    ):

     '''simple docstring'''
     __A		     =					self.get_feature_extractor()
     __A		     =					self.get_tokenizer()

     __A		     =					MusicgenProcessor(tokenizer=__UpperCAmelCase,			feature_extractor=__UpperCAmelCase    )

     __A		     =					'''This is a test string'''

     __A		     =					processor(text=__UpperCAmelCase    )

     __A		     =					tokenizer(__UpperCAmelCase    )

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


   def 							_SCREAMING_SNAKE_CASE							(      self					:	int    ):

     '''simple docstring'''
     __A		     =					self.get_feature_extractor()
     __A		     =					self.get_tokenizer()

     __A		     =					MusicgenProcessor(tokenizer=__UpperCAmelCase,			feature_extractor=__UpperCAmelCase    )

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

     __A		     =					processor.batch_decode(sequences=__UpperCAmelCase    )
     __A		     =					tokenizer.batch_decode(__UpperCAmelCase    )

     self.assertListEqual(__UpperCAmelCase,			__UpperCAmelCase    )


   def 							_SCREAMING_SNAKE_CASE							(      self					:	Tuple    ):

     '''simple docstring'''
     __A		     =					self.get_feature_extractor()
     __A		     =					self.get_tokenizer()

     __A		     =					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 							_SCREAMING_SNAKE_CASE							(      self					:	Tuple    ):

     '''simple docstring'''
     __A		     =					self.get_feature_extractor(padding_side='''left'''    )
     __A		     =					self.get_tokenizer()

     __A		     =					MusicgenProcessor(tokenizer=__UpperCAmelCase,			feature_extractor=__UpperCAmelCase    )

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

     __A		     =					np.asarray(floats_list((3, 20)    )    )[:, None, :]
     __A		     =					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, 10)    )
     self.assertTrue(decoded_audios[1].shape == (1, 15)    )
     self.assertTrue(decoded_audios[2].shape == (1, 20)    )








"""simple docstring"""






import gc
import tempfile
import unittest

import numpy as np
import torch

from diffusers import VersatileDiffusionDualGuidedPipeline
from diffusers.utils.testing_utils import load_image, nightly, require_torch_gpu, torch_device


__snake_case												=							False


@nightly
@require_torch_gpu
class      __lowerCamelCase	(       unittest.TestCase					):

     '''simple docstring'''


     def 				_UpperCAmelCase   (   self				)							->				Tuple:
          # clean up the VRAM after each test
          super().tearDown()
          gc.collect()
          torch.cuda.empty_cache()


     def 				_UpperCAmelCase   (   self				)							->				List[str]:
          _a     						=					VersatileDiffusionDualGuidedPipeline.from_pretrained('''shi-labs/versatile-diffusion'''				)
          # remove text_unet
          pipe.remove_unused_weights()
          pipe.to(__UpperCAmelCase				)
          pipe.set_progress_bar_config(disable=__UpperCAmelCase				)

          _a     						=					load_image(
              '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/versatile_diffusion/benz.jpg'''				)

          _a     						=					torch.manual_seed(0				)
          _a     						=					pipe(
              prompt='''first prompt'''     ,					image=__UpperCAmelCase     ,					text_to_image_strength=0.75     ,					generator=__UpperCAmelCase     ,					guidance_scale=7.5     ,					num_inference_steps=2     ,					output_type='''numpy'''     ,					).images

          with tempfile.TemporaryDirectory() as tmpdirname:
               pipe.save_pretrained(__UpperCAmelCase				)
               _a     						=					VersatileDiffusionDualGuidedPipeline.from_pretrained(__UpperCAmelCase				)

          pipe.to(__UpperCAmelCase				)
          pipe.set_progress_bar_config(disable=__UpperCAmelCase				)

          _a     						=					generator.manual_seed(0				)
          _a     						=					pipe(
              prompt='''first prompt'''     ,					image=__UpperCAmelCase     ,					text_to_image_strength=0.75     ,					generator=__UpperCAmelCase     ,					guidance_scale=7.5     ,					num_inference_steps=2     ,					output_type='''numpy'''     ,					).images

          assert np.abs(image - new_image				).sum() < 1e-5, "Models don't have the same forward pass"





     def 				_UpperCAmelCase   (   self				)							->				Dict:
          _a     						=					VersatileDiffusionDualGuidedPipeline.from_pretrained('''shi-labs/versatile-diffusion'''				)
          pipe.remove_unused_weights()
          pipe.to(__UpperCAmelCase				)
          pipe.set_progress_bar_config(disable=__UpperCAmelCase				)

          _a     						=					'''cyberpunk 2077'''
          _a     						=					load_image(
              '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/versatile_diffusion/benz.jpg'''				)
          _a     						=					torch.manual_seed(0				)
          _a     						=					pipe(
              prompt=__UpperCAmelCase     ,					image=__UpperCAmelCase     ,					text_to_image_strength=0.75     ,					generator=__UpperCAmelCase     ,					guidance_scale=7.5     ,					num_inference_steps=50     ,					output_type='''numpy'''     ,					).images

          _a     						=					image[0, 253:256, 253:256, -1]

          assert image.shape == (1, 512, 512, 3)
          _a     						=					np.array([0.0787, 0.0849, 0.0826, 0.0812, 0.0807, 0.0795, 0.0818, 0.0798, 0.0779]				)

          assert np.abs(image_slice.flatten() - expected_slice				).max() < 1e-2