code: 
  
  """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
  
  
  __A  :					List[str]												=	random.Random()
  def      __SCREAMING_SNAKE_CASE		(		lowercase__    ,							lowercase__=1.0    ,							lowercase__=None    ,							lowercase__=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     __UpperCamelCase				(     unittest.TestCase		):
  
  
  						def       SCREAMING_SNAKE_CASE__     (self				:	Optional[int]):
  											A    =      "facebook/musicgen-small"
  											A    =      tempfile.mkdtemp()
  
  
  						def       SCREAMING_SNAKE_CASE__     (self				:	Tuple  ,  **__SCREAMING_SNAKE_CASE				:	Union[str, Any]):
  											return TaTokenizer.from_pretrained(self.checkpoint  ,  **lowerCamelCase__)
  
  
  						def       SCREAMING_SNAKE_CASE__     (self				:	Tuple  ,  **__SCREAMING_SNAKE_CASE				:	List[str]):
  											return EncodecFeatureExtractor.from_pretrained(self.checkpoint  ,  **lowerCamelCase__)
  
  
  						def       SCREAMING_SNAKE_CASE__     (self				:	Union[str, Any]):
  											shutil.rmtree(self.tmpdirname)
  
  
  						def       SCREAMING_SNAKE_CASE__     (self				:	Any):
  											A    =      self.get_tokenizer()
  											A    =      self.get_feature_extractor()
  
  											A    =      MusicgenProcessor(tokenizer=lowerCamelCase__  ,  feature_extractor=lowerCamelCase__)
  
  											processor.save_pretrained(self.tmpdirname)
  											A    =      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       SCREAMING_SNAKE_CASE__     (self				:	Tuple):
  											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=lowerCamelCase__  ,  padding_value=1.0)
  
  											A    =      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       SCREAMING_SNAKE_CASE__     (self				:	Dict):
  											A    =      self.get_feature_extractor()
  											A    =      self.get_tokenizer()
  
  											A    =      MusicgenProcessor(tokenizer=lowerCamelCase__  ,  feature_extractor=lowerCamelCase__)
  
  											A    =      floats_list((3, 1_0_0_0))
  
  											A    =      feature_extractor(lowerCamelCase__  ,  return_tensors="np")
  											A    =      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       SCREAMING_SNAKE_CASE__     (self				:	Tuple):
  											A    =      self.get_feature_extractor()
  											A    =      self.get_tokenizer()
  
  											A    =      MusicgenProcessor(tokenizer=lowerCamelCase__  ,  feature_extractor=lowerCamelCase__)
  
  											A    =      "This is a test string"
  
  											A    =      processor(text=lowerCamelCase__)
  
  											A    =      tokenizer(lowerCamelCase__)
  
  											for key in encoded_tok.keys():
  																self.assertListEqual(encoded_tok[key]  ,  encoded_processor[key])
  
  
  						def       SCREAMING_SNAKE_CASE__     (self				:	str):
  											A    =      self.get_feature_extractor()
  											A    =      self.get_tokenizer()
  
  											A    =      MusicgenProcessor(tokenizer=lowerCamelCase__  ,  feature_extractor=lowerCamelCase__)
  
  											A    =      [[1, 4, 5, 8, 1, 0, 8], [3, 4, 3, 1, 1, 8, 9]]
  
  											A    =      processor.batch_decode(sequences=lowerCamelCase__)
  											A    =      tokenizer.batch_decode(lowerCamelCase__)
  
  											self.assertListEqual(lowerCamelCase__  ,  lowerCamelCase__)
  
  
  						def       SCREAMING_SNAKE_CASE__     (self				:	Dict):
  											A    =      self.get_feature_extractor()
  											A    =      self.get_tokenizer()
  
  											A    =      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       SCREAMING_SNAKE_CASE__     (self				:	List[Any]):
  											A    =      self.get_feature_extractor(padding_side="left")
  											A    =      self.get_tokenizer()
  
  											A    =      MusicgenProcessor(tokenizer=lowerCamelCase__  ,  feature_extractor=lowerCamelCase__)
  
  											A    =      [floats_list((1, x))[0] for x in range(5  ,  2_0  ,  5)]
  											A    =      processor(lowerCamelCase__).padding_mask
  
  											A    =      np.asarray(floats_list((3, 2_0)))[:, None, :]
  											A    =      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))
  
  
  
  
  
  
style_context: 
  
  """simple docstring"""
  
  
  
  
  def      __SCREAMING_SNAKE_CASE		(		lowercase__    ,							lowercase__   ):
  					"""simple docstring"""
  					A    =      1
  					while b > 0:
  										if b & 1:
  															res *= a
  
  										a *= a
  										b >>= 1
  
  					return res
  def      __SCREAMING_SNAKE_CASE		(		lowercase__    ,							lowercase__    ,							lowercase__   ):
  					"""simple docstring"""
  					A    =      1
  					while b > 0:
  										if b & 1:
  															A    =      ((res % c) * (a % c)) % c
  
  										a *= a
  										b >>= 1
  
  					return res
  
  
  
  
  
  