


import unittest

import numpy as np

from transformers.testing_utils import require_torch, require_vision
from transformers.utils import is_torch_available, is_vision_available

from ...test_image_processing_common import ImageProcessingSavingTestMixin, prepare_image_inputs


if is_torch_available():
   import torch

if is_vision_available():
   from PIL import Image

   from transformers import DeiTImageProcessor


class     __lowerCAmelCase     ( unittest.TestCase					):






  """simple docstring"""





  def __init__(     self       :       Union[str, Any]    ,				_lowerCAmelCase       :       List[str]    ,				_lowerCAmelCase       :       Optional[int]=7    ,				_lowerCAmelCase       :       List[str]=3    ,				_lowerCAmelCase       :       List[str]=1_8    ,				_lowerCAmelCase       :       int=3_0    ,				_lowerCAmelCase       :       List[Any]=4_0_0    ,				_lowerCAmelCase       :       Any=True    ,				_lowerCAmelCase       :       Any=None    ,				_lowerCAmelCase       :       Tuple=True    ,				_lowerCAmelCase       :       int=None    ,				_lowerCAmelCase       :       Union[str, Any]=True    ,				_lowerCAmelCase       :       Union[str, Any]=[0.5, 0.5, 0.5]    ,				_lowerCAmelCase       :       str=[0.5, 0.5, 0.5]    ,				)   -> List[str]:




     """simple docstring"""
     snake_case_					    =					size if size is not None else {"height": 2_0, "width": 2_0}
     snake_case_					    =					crop_size if crop_size is not None else {"height": 1_8, "width": 1_8}

     snake_case_					    =					parent
     snake_case_					    =					batch_size
     snake_case_					    =					num_channels
     snake_case_					    =					image_size
     snake_case_					    =					min_resolution
     snake_case_					    =					max_resolution
     snake_case_					    =					do_resize
     snake_case_					    =					size
     snake_case_					    =					do_center_crop
     snake_case_					    =					crop_size
     snake_case_					    =					do_normalize
     snake_case_					    =					image_mean
     snake_case_					    =					image_std



  def 					lowerCAmelCase__  (     self       :       str  )   -> Tuple:




     """simple docstring"""
     return {
         "do_resize": self.do_resize,
         "size": self.size,
         "do_center_crop": self.do_center_crop,
         "crop_size": self.crop_size,
         "do_normalize": self.do_normalize,
         "image_mean": self.image_mean,
         "image_std": self.image_std,
     }






@require_torch
@require_vision
class     __lowerCAmelCase     ( a ,  unittest.TestCase					):






  """simple docstring"""





  _SCREAMING_SNAKE_CASE		    =       DeiTImageProcessor if is_vision_available() else None
  _SCREAMING_SNAKE_CASE		    =       True



  def 					lowerCAmelCase__  (     self       :       Optional[Any]  )   -> Tuple:




     """simple docstring"""
     snake_case_					    =					DeiTImageProcessingTester(self  )



  @property
  def 					lowerCAmelCase__  (     self       :       Union[str, Any]  )   -> List[str]:




     """simple docstring"""
     return self.image_processor_tester.prepare_image_processor_dict()



  def 					lowerCAmelCase__  (     self       :       int  )   -> str:




     """simple docstring"""
     snake_case_					    =					self.image_processing_class(**self.image_processor_dict  )
     self.assertTrue(hasattr(_lowerCAmelCase    ,				"do_resize"  )  )
     self.assertTrue(hasattr(_lowerCAmelCase    ,				"size"  )  )
     self.assertTrue(hasattr(_lowerCAmelCase    ,				"do_center_crop"  )  )
     self.assertTrue(hasattr(_lowerCAmelCase    ,				"center_crop"  )  )
     self.assertTrue(hasattr(_lowerCAmelCase    ,				"do_normalize"  )  )
     self.assertTrue(hasattr(_lowerCAmelCase    ,				"image_mean"  )  )
     self.assertTrue(hasattr(_lowerCAmelCase    ,				"image_std"  )  )



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




     """simple docstring"""
     snake_case_					    =					self.image_processing_class.from_dict(self.image_processor_dict  )
     self.assertEqual(image_processor.size    ,				{"height": 2_0, "width": 2_0}  )
     self.assertEqual(image_processor.crop_size    ,				{"height": 1_8, "width": 1_8}  )

     snake_case_					    =					self.image_processing_class.from_dict(self.image_processor_dict    ,				size=4_2    ,				crop_size=8_4  )
     self.assertEqual(image_processor.size    ,				{"height": 4_2, "width": 4_2}  )
     self.assertEqual(image_processor.crop_size    ,				{"height": 8_4, "width": 8_4}  )



  def 					lowerCAmelCase__  (     self       :       List[str]  )   -> Dict:




     """simple docstring"""
     pass



  def 					lowerCAmelCase__  (     self       :       Dict  )   -> str:




     """simple docstring"""
     # Initialize image_processing
     snake_case_					    =					self.image_processing_class(**self.image_processor_dict  )
     # create random PIL images
     snake_case_					    =					prepare_image_inputs(self.image_processor_tester    ,				equal_resolution=_lowerCAmelCase  )
     for image in image_inputs:
        self.assertIsInstance(_lowerCAmelCase    ,				Image.Image  )

     # Test not batched input
     snake_case_					    =					image_processing(image_inputs[0]    ,				return_tensors="pt"  ).pixel_values
     self.assertEqual(
         encoded_images.shape    ,				(
             1,
             self.image_processor_tester.num_channels,
             self.image_processor_tester.crop_size["height"],
             self.image_processor_tester.crop_size["width"],
         )    ,				)

     # Test batched
     snake_case_					    =					image_processing(_lowerCAmelCase    ,				return_tensors="pt"  ).pixel_values
     self.assertEqual(
         encoded_images.shape    ,				(
             self.image_processor_tester.batch_size,
             self.image_processor_tester.num_channels,
             self.image_processor_tester.crop_size["height"],
             self.image_processor_tester.crop_size["width"],
         )    ,				)



  def 					lowerCAmelCase__  (     self       :       int  )   -> List[str]:




     """simple docstring"""
     # Initialize image_processing
     snake_case_					    =					self.image_processing_class(**self.image_processor_dict  )
     # create random numpy tensors
     snake_case_					    =					prepare_image_inputs(self.image_processor_tester    ,				equal_resolution=_lowerCAmelCase    ,				numpify=_lowerCAmelCase  )
     for image in image_inputs:
        self.assertIsInstance(_lowerCAmelCase    ,				np.ndarray  )

     # Test not batched input
     snake_case_					    =					image_processing(image_inputs[0]    ,				return_tensors="pt"  ).pixel_values
     self.assertEqual(
         encoded_images.shape    ,				(
             1,
             self.image_processor_tester.num_channels,
             self.image_processor_tester.crop_size["height"],
             self.image_processor_tester.crop_size["width"],
         )    ,				)

     # Test batched
     snake_case_					    =					image_processing(_lowerCAmelCase    ,				return_tensors="pt"  ).pixel_values
     self.assertEqual(
         encoded_images.shape    ,				(
             self.image_processor_tester.batch_size,
             self.image_processor_tester.num_channels,
             self.image_processor_tester.crop_size["height"],
             self.image_processor_tester.crop_size["width"],
         )    ,				)



  def 					lowerCAmelCase__  (     self       :       Any  )   -> Tuple:




     """simple docstring"""
     # Initialize image_processing
     snake_case_					    =					self.image_processing_class(**self.image_processor_dict  )
     # create random PyTorch tensors
     snake_case_					    =					prepare_image_inputs(self.image_processor_tester    ,				equal_resolution=_lowerCAmelCase    ,				torchify=_lowerCAmelCase  )
     for image in image_inputs:
        self.assertIsInstance(_lowerCAmelCase    ,				torch.Tensor  )

     # Test not batched input
     snake_case_					    =					image_processing(image_inputs[0]    ,				return_tensors="pt"  ).pixel_values
     self.assertEqual(
         encoded_images.shape    ,				(
             1,
             self.image_processor_tester.num_channels,
             self.image_processor_tester.crop_size["height"],
             self.image_processor_tester.crop_size["width"],
         )    ,				)

     # Test batched
     snake_case_					    =					image_processing(_lowerCAmelCase    ,				return_tensors="pt"  ).pixel_values
     self.assertEqual(
         encoded_images.shape    ,				(
             self.image_processor_tester.batch_size,
             self.image_processor_tester.num_channels,
             self.image_processor_tester.crop_size["height"],
             self.image_processor_tester.crop_size["width"],
         )    ,				)








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	:Union[str, Any]  		=     random.Random()



def 			_lowerCAmelCase						(							lowerCAmelCase_							:Union[str, Any]		,						lowerCAmelCase_							:Optional[int]=1.0		,						lowerCAmelCase_							:List[str]=None		,						lowerCAmelCase_							:str=None							)->Union[str, Any]:
   '''simple docstring'''






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






  """simple docstring"""





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




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



  def 					lowerCAmelCase__  (     self       :       Tuple    ,				**_lowerCAmelCase       :       Tuple  )   -> Optional[int]:




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



  def 					lowerCAmelCase__  (     self       :       Union[str, Any]    ,				**_lowerCAmelCase       :       Union[str, Any]  )   -> int:




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



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




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



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




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

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

     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    ,				_lowerCAmelCase  )

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



  def 					lowerCAmelCase__  (     self       :       Optional[Any]  )   -> Tuple:




     """simple docstring"""
     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=_lowerCAmelCase    ,				padding_value=1.0  )

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

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

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



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




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

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

     snake_case_					    =					floats_list((3, 1_0_0_0)  )

     snake_case_					    =					feature_extractor(_lowerCAmelCase    ,				return_tensors="np"  )
     snake_case_					    =					processor(_lowerCAmelCase    ,				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 					lowerCAmelCase__  (     self       :       Tuple  )   -> List[Any]:




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

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

     snake_case_					    =					"This is a test string"

     snake_case_					    =					processor(text=_lowerCAmelCase  )

     snake_case_					    =					tokenizer(_lowerCAmelCase  )

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



  def 					lowerCAmelCase__  (     self       :       Any  )   -> str:




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

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

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

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

     self.assertListEqual(_lowerCAmelCase    ,				_lowerCAmelCase  )



  def 					lowerCAmelCase__  (     self       :       Optional[int]  )   -> Dict:




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

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

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



  def 					lowerCAmelCase__  (     self       :       Tuple  )   -> int:




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

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

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

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

     self.assertIsInstance(_lowerCAmelCase    ,				_lowerCAmelCase  )

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




