

"""simple docstring"""



import os
import tempfile
from functools import partial
from unittest import TestCase
from unittest.mock import patch

import numpy as np
import pytest

from datasets.arrow_dataset import Dataset
from datasets.search import ElasticSearchIndex, FaissIndex, MissingIndex

from .utils import require_elasticsearch, require_faiss


SCREAMING_SNAKE_CASE_					:	Union[str, Any]							  =						pytest.mark.integration



@require_faiss
class 					a						(       _lowerCamelCase				):



				"""simple docstring"""



				def 				UpperCamelCase	(     self: Optional[int]       ):






									"""simple docstring"""


									A__										=  Dataset.from_dict({"""filename""": ["""my_name-train""" + """_""" + str(UpperCamelCase       ) for x in np.arange(30       ).tolist()]}       )
									return dset

				def 				UpperCamelCase	(     self: Union[str, Any]       ):






									"""simple docstring"""


									import faiss

									A__										=  self._create_dummy_dataset()
									A__										=  dset.map(
									    lambda UpperCamelCase    ,						UpperCamelCase       : {"vecs": i * np.ones(5    ,						dtype=np.floataa       )}    ,						with_indices=UpperCamelCase    ,						keep_in_memory=UpperCamelCase       )
									A__										=  dset.add_faiss_index("""vecs"""    ,						batch_size=1_00    ,						metric_type=faiss.METRIC_INNER_PRODUCT       )
									A__			,				A__										=  dset.get_nearest_examples("""vecs"""    ,						np.ones(5    ,						dtype=np.floataa       )       )
									self.assertEqual(examples["""filename"""][0]    ,						"""my_name-train_29"""       )
									dset.drop_index("""vecs"""       )

				def 				UpperCamelCase	(     self: Union[str, Any]       ):






									"""simple docstring"""


									import faiss

									A__										=  self._create_dummy_dataset()
									dset.add_faiss_index_from_external_arrays(
									    external_arrays=np.ones((30, 5)       ) * np.arange(30       ).reshape(-1    ,						1       )    ,						index_name="""vecs"""    ,						batch_size=1_00    ,						metric_type=faiss.METRIC_INNER_PRODUCT    ,						)
									A__			,				A__										=  dset.get_nearest_examples("""vecs"""    ,						np.ones(5    ,						dtype=np.floataa       )       )
									self.assertEqual(examples["""filename"""][0]    ,						"""my_name-train_29"""       )

				def 				UpperCamelCase	(     self: Optional[Any]       ):






									"""simple docstring"""


									import faiss

									A__										=  self._create_dummy_dataset()
									dset.add_faiss_index_from_external_arrays(
									    external_arrays=np.ones((30, 5)       ) * np.arange(30       ).reshape(-1    ,						1       )    ,						index_name="""vecs"""    ,						metric_type=faiss.METRIC_INNER_PRODUCT    ,						)

									# Setting delete=False and unlinking manually is not pretty... but it is required on Windows to
									# ensure somewhat stable behaviour. If we don't, we get PermissionErrors. This is an age-old issue.
									# see https://bugs.python.org/issue14243 and
									# https://stackoverflow.com/questions/23212435/permission-denied-to-write-to-my-temporary-file/23212515
									with tempfile.NamedTemporaryFile(delete=UpperCamelCase       ) as tmp_file:
														dset.save_faiss_index("""vecs"""    ,						tmp_file.name       )
														dset.load_faiss_index("""vecs2"""    ,						tmp_file.name       )
									os.unlink(tmp_file.name       )

									A__			,				A__										=  dset.get_nearest_examples("""vecs2"""    ,						np.ones(5    ,						dtype=np.floataa       )       )
									self.assertEqual(examples["""filename"""][0]    ,						"""my_name-train_29"""       )

				def 				UpperCamelCase	(     self: Dict       ):






									"""simple docstring"""


									A__										=  self._create_dummy_dataset()
									dset.add_faiss_index_from_external_arrays(
									    external_arrays=np.ones((30, 5)       ) * np.arange(30       ).reshape(-1    ,						1       )    ,						index_name="""vecs"""       )
									dset.drop_index("""vecs"""       )
									self.assertRaises(UpperCamelCase    ,						partial(dset.get_nearest_examples    ,						"""vecs2"""    ,						np.ones(5    ,						dtype=np.floataa       )       )       )





				def 				UpperCamelCase	(     self: Optional[Any]       ):






									"""simple docstring"""


									from elasticsearch import Elasticsearch

									A__										=  self._create_dummy_dataset()
									with patch("""elasticsearch.Elasticsearch.search"""       ) as mocked_search, patch(
									    """elasticsearch.client.IndicesClient.create"""       ) as mocked_index_create, patch("""elasticsearch.helpers.streaming_bulk"""       ) as mocked_bulk:
														A__										=  {"""acknowledged""": True}
														mocked_bulk.return_value([(True, None)] * 30       )
														A__										=  {"""hits""": {"""hits""": [{"""_score""": 1, """_id""": 29}]}}
														A__										=  Elasticsearch()

														dset.add_elasticsearch_index("""filename"""    ,						es_client=UpperCamelCase       )
														A__			,				A__										=  dset.get_nearest_examples("""filename"""    ,						"""my_name-train_29"""       )
														self.assertEqual(examples["""filename"""][0]    ,						"""my_name-train_29"""       )



@require_faiss
class 					a						(       _lowerCamelCase				):



				"""simple docstring"""



				def 				UpperCamelCase	(     self: Dict       ):






									"""simple docstring"""


									import faiss

									A__										=  FaissIndex(metric_type=faiss.METRIC_INNER_PRODUCT       )

									# add vectors
									index.add_vectors(np.eye(5    ,						dtype=np.floataa       )       )
									self.assertIsNotNone(index.faiss_index       )
									self.assertEqual(index.faiss_index.ntotal    ,						5       )
									index.add_vectors(np.zeros((5, 5)    ,						dtype=np.floataa       )       )
									self.assertEqual(index.faiss_index.ntotal    ,						10       )

									# single query
									A__										=  np.zeros(5    ,						dtype=np.floataa       )
									A__										=  1
									A__			,				A__										=  index.search(UpperCamelCase       )
									self.assertRaises(UpperCamelCase    ,						index.search    ,						query.reshape(-1    ,						1       )       )
									self.assertGreater(scores[0]    ,						0       )
									self.assertEqual(indices[0]    ,						1       )

									# batched queries
									A__										=  np.eye(5    ,						dtype=np.floataa       )[::-1]
									A__			,				A__										=  index.search_batch(UpperCamelCase       )
									self.assertRaises(UpperCamelCase    ,						index.search_batch    ,						queries[0]       )
									A__										=  [scores[0] for scores in total_scores]
									A__										=  [indices[0] for indices in total_indices]
									self.assertGreater(np.min(UpperCamelCase       )    ,						0       )
									self.assertListEqual([4, 3, 2, 1, 0]    ,						UpperCamelCase       )

				def 				UpperCamelCase	(     self: Optional[Any]       ):






									"""simple docstring"""


									import faiss

									A__										=  FaissIndex(string_factory="""Flat"""       )
									index.add_vectors(np.eye(5    ,						dtype=np.floataa       )       )
									self.assertIsInstance(index.faiss_index    ,						faiss.IndexFlat       )
									A__										=  FaissIndex(string_factory="""LSH"""       )
									index.add_vectors(np.eye(5    ,						dtype=np.floataa       )       )
									self.assertIsInstance(index.faiss_index    ,						faiss.IndexLSH       )
									with self.assertRaises(UpperCamelCase       ):
														A__										=  FaissIndex(string_factory="""Flat"""    ,						custom_index=faiss.IndexFlat(5       )       )

				def 				UpperCamelCase	(     self: Any       ):






									"""simple docstring"""


									import faiss

									A__										=  faiss.IndexFlat(5       )
									A__										=  FaissIndex(custom_index=UpperCamelCase       )
									index.add_vectors(np.eye(5    ,						dtype=np.floataa       )       )
									self.assertIsInstance(index.faiss_index    ,						faiss.IndexFlat       )





				def 				UpperCamelCase	(     self: Optional[Any]       ):






									"""simple docstring"""


									import faiss

									A__										=  FaissIndex(metric_type=faiss.METRIC_INNER_PRODUCT       )
									index.add_vectors(np.eye(5    ,						dtype=np.floataa       )       )

									# Setting delete=False and unlinking manually is not pretty... but it is required on Windows to
									# ensure somewhat stable behaviour. If we don't, we get PermissionErrors. This is an age-old issue.
									# see https://bugs.python.org/issue14243 and
									# https://stackoverflow.com/questions/23212435/permission-denied-to-write-to-my-temporary-file/23212515
									with tempfile.NamedTemporaryFile(delete=UpperCamelCase       ) as tmp_file:
														index.save(tmp_file.name       )
														A__										=  FaissIndex.load(tmp_file.name       )
									os.unlink(tmp_file.name       )

									A__										=  np.zeros(5    ,						dtype=np.floataa       )
									A__										=  1
									A__			,				A__										=  index.search(UpperCamelCase       )
									self.assertGreater(scores[0]    ,						0       )
									self.assertEqual(indices[0]    ,						1       )





@require_faiss
def  _snake_case     (    UpperCAmelCase_  :					str			):
					import faiss

					A__										=  FaissIndex(metric_type=faiss.METRIC_INNER_PRODUCT			)
					index.add_vectors(np.eye(5					,   dtype=np.floataa			)			)

					A__										=  """index.faiss"""
					A__										=  F"""mock://{index_name}"""
					index.save(UpperCAmelCase_					,   storage_options=mockfs.storage_options			)
					A__										=  FaissIndex.load(UpperCAmelCase_					,   storage_options=mockfs.storage_options			)

					A__										=  np.zeros(5					,   dtype=np.floataa			)
					A__										=  1
					A__			,				A__										=  index.search(UpperCAmelCase_			)
					assert scores[0] > 0
					assert indices[0] == 1



@require_elasticsearch
class 					a						(       _lowerCamelCase				):



				"""simple docstring"""



				def 				UpperCamelCase	(     self: Optional[int]       ):






									"""simple docstring"""


									from elasticsearch import Elasticsearch

									with patch("""elasticsearch.Elasticsearch.search"""       ) as mocked_search, patch(
									    """elasticsearch.client.IndicesClient.create"""       ) as mocked_index_create, patch("""elasticsearch.helpers.streaming_bulk"""       ) as mocked_bulk:
														A__										=  Elasticsearch()
														A__										=  {"""acknowledged""": True}
														A__										=  ElasticSearchIndex(es_client=UpperCamelCase       )
														mocked_bulk.return_value([(True, None)] * 3       )
														index.add_documents(["""foo""", """bar""", """foobar"""]       )

														# single query
														A__										=  """foo"""
														A__										=  {"""hits""": {"""hits""": [{"""_score""": 1, """_id""": 0}]}}
														A__			,				A__										=  index.search(UpperCamelCase       )
														self.assertEqual(scores[0]    ,						1       )
														self.assertEqual(indices[0]    ,						0       )

														# single query with timeout
														A__										=  """foo"""
														A__										=  {"""hits""": {"""hits""": [{"""_score""": 1, """_id""": 0}]}}
														A__			,				A__										=  index.search(UpperCamelCase    ,						request_timeout=30       )
														self.assertEqual(scores[0]    ,						1       )
														self.assertEqual(indices[0]    ,						0       )

														# batched queries
														A__										=  ["""foo""", """bar""", """foobar"""]
														A__										=  {"""hits""": {"""hits""": [{"""_score""": 1, """_id""": 1}]}}
														A__			,				A__										=  index.search_batch(UpperCamelCase       )
														A__										=  [scores[0] for scores in total_scores]
														A__										=  [indices[0] for indices in total_indices]
														self.assertGreater(np.min(UpperCamelCase       )    ,						0       )
														self.assertListEqual([1, 1, 1]    ,						UpperCamelCase       )

														# batched queries with timeout
														A__										=  ["""foo""", """bar""", """foobar"""]
														A__										=  {"""hits""": {"""hits""": [{"""_score""": 1, """_id""": 1}]}}
														A__			,				A__										=  index.search_batch(UpperCamelCase    ,						request_timeout=30       )
														A__										=  [scores[0] for scores in total_scores]
														A__										=  [indices[0] for indices in total_indices]
														self.assertGreater(np.min(UpperCamelCase       )    ,						0       )
														self.assertListEqual([1, 1, 1]    ,						UpperCamelCase       )









"""simple docstring"""



import argparse
from pathlib import Path
from typing import Dict, OrderedDict, Tuple

import torch
from audiocraft.models import MusicGen

from transformers import (
    AutoFeatureExtractor,
    AutoTokenizer,
    EncodecModel,
    MusicgenDecoderConfig,
    MusicgenForConditionalGeneration,
    MusicgenProcessor,
    TaEncoderModel,
)
from transformers.models.musicgen.modeling_musicgen import MusicgenForCausalLM
from transformers.utils import logging


logging.set_verbosity_info()
SCREAMING_SNAKE_CASE_					:	Union[str, Any]							  =						logging.get_logger(__name__)


SCREAMING_SNAKE_CASE_					:	Any							  =						['model.decoder.embed_positions.weights']





def  _snake_case     (    UpperCAmelCase_  :					Optional[int]			):
     if "emb" in name:
          A__										=  name.replace("""emb"""					,   """model.decoder.embed_tokens"""			)
     if "transformer" in name:
          A__										=  name.replace("""transformer"""					,   """model.decoder"""			)
     if "cross_attention" in name:
          A__										=  name.replace("""cross_attention"""					,   """encoder_attn"""			)
     if "linear1" in name:
          A__										=  name.replace("""linear1"""					,   """fc1"""			)
     if "linear2" in name:
          A__										=  name.replace("""linear2"""					,   """fc2"""			)
     if "norm1" in name:
          A__										=  name.replace("""norm1"""					,   """self_attn_layer_norm"""			)
     if "norm_cross" in name:
          A__										=  name.replace("""norm_cross"""					,   """encoder_attn_layer_norm"""			)
     if "norm2" in name:
          A__										=  name.replace("""norm2"""					,   """final_layer_norm"""			)
     if "out_norm" in name:
          A__										=  name.replace("""out_norm"""					,   """model.decoder.layer_norm"""			)
     if "linears" in name:
          A__										=  name.replace("""linears"""					,   """lm_heads"""			)
     if "condition_provider.conditioners.description.output_proj" in name:
          A__										=  name.replace("""condition_provider.conditioners.description.output_proj"""					,   """enc_to_dec_proj"""			)
     return name





def  _snake_case     (    UpperCAmelCase_  :					OrderedDict					,   UpperCAmelCase_  :					int			):
     A__										=  list(state_dict.keys()			)
     A__										=  {}
     for key in keys:
          A__										=  state_dict.pop(UpperCAmelCase_			)
          A__										=  rename_keys(UpperCAmelCase_			)
          if "in_proj_weight" in key:
               # split fused qkv proj
               A__										=  val[:hidden_size, :]
               A__										=  val[hidden_size : 2 * hidden_size, :]
               A__										=  val[-hidden_size:, :]
          elif "enc_to_dec_proj" in key:
               A__										=  val
          else:
               A__										=  val
     return state_dict, enc_dec_proj_state_dict





def  _snake_case     (    UpperCAmelCase_  :					str			):
     if checkpoint == "small":
          # default config values
          A__										=  1024
          A__										=  24
          A__										=  16
     elif checkpoint == "medium":
          A__										=  1536
          A__										=  48
          A__										=  24
     elif checkpoint == "large":
          A__										=  2048
          A__										=  48
          A__										=  32
     else:
          raise ValueError(F"""Checkpoint should be one of `['small', 'medium', 'large']`, got {checkpoint}."""			)
     A__										=  MusicgenDecoderConfig(
         hidden_size=UpperCAmelCase_					,   ffn_dim=hidden_size * 4					,   num_hidden_layers=UpperCAmelCase_					,   num_attention_heads=UpperCAmelCase_					,   )
     return config





@torch.no_grad()
def  _snake_case     (    UpperCAmelCase_  :					int					,   UpperCAmelCase_  :					List[Any]=None					,   UpperCAmelCase_  :					Tuple=None					,   UpperCAmelCase_  :					Any="cpu"			):
     A__										=  MusicGen.get_pretrained(UpperCAmelCase_					,   device=UpperCAmelCase_			)
     A__										=  decoder_config_from_checkpoint(UpperCAmelCase_			)

     A__										=  fairseq_model.lm.state_dict()
     A__			,				A__										=  rename_state_dict(
         UpperCAmelCase_					,   hidden_size=decoder_config.hidden_size			)

     A__										=  TaEncoderModel.from_pretrained("""t5-base"""			)
     A__										=  EncodecModel.from_pretrained("""facebook/encodec_32khz"""			)
     A__										=  MusicgenForCausalLM(UpperCAmelCase_			).eval()

     # load all decoder weights - expect that we'll be missing embeddings and enc-dec projection
     A__			,				A__										=  decoder.load_state_dict(UpperCAmelCase_					,   strict=UpperCAmelCase_			)

     for key in missing_keys.copy():
          if key.startswith(("""text_encoder""", """audio_encoder""")			) or key in EXPECTED_MISSING_KEYS:
               missing_keys.remove(UpperCAmelCase_			)

     if len(UpperCAmelCase_			) > 0:
          raise ValueError(F"""Missing key(s) in state_dict: {missing_keys}"""			)

     if len(UpperCAmelCase_			) > 0:
          raise ValueError(F"""Unexpected key(s) in state_dict: {unexpected_keys}"""			)

     # init the composite model
     A__										=  MusicgenForConditionalGeneration(text_encoder=UpperCAmelCase_					,   audio_encoder=UpperCAmelCase_					,   decoder=UpperCAmelCase_			)

     # load the pre-trained enc-dec projection (from the decoder state dict)
     model.enc_to_dec_proj.load_state_dict(UpperCAmelCase_			)

     # check we can do a forward pass
     A__										=  torch.arange(0					,   8					,   dtype=torch.long			).reshape(2					,   -1			)
     A__										=  input_ids.reshape(2 * 4					,   -1			)

     with torch.no_grad():
          A__										=  model(input_ids=UpperCAmelCase_					,   decoder_input_ids=UpperCAmelCase_			).logits

     if logits.shape != (8, 1, 2048):
          raise ValueError("""Incorrect shape for logits"""			)

     # now construct the processor
     A__										=  AutoTokenizer.from_pretrained("""t5-base"""			)
     A__										=  AutoFeatureExtractor.from_pretrained("""facebook/encodec_32khz"""					,   padding_side="""left"""			)

     A__										=  MusicgenProcessor(feature_extractor=UpperCAmelCase_					,   tokenizer=UpperCAmelCase_			)

     # set the appropriate bos/pad token ids
     A__										=  2048
     A__										=  2048

     # set other default generation config params
     A__										=  int(30 * audio_encoder.config.frame_rate			)
     A__										=  True
     A__										=  3.0

     if pytorch_dump_folder is not None:
          Path(UpperCAmelCase_			).mkdir(exist_ok=UpperCAmelCase_			)
          logger.info(F"""Saving model {checkpoint} to {pytorch_dump_folder}"""			)
          model.save_pretrained(UpperCAmelCase_			)
          processor.save_pretrained(UpperCAmelCase_			)

     if repo_id:
          logger.info(F"""Pushing model {checkpoint} to {repo_id}"""			)
          model.push_to_hub(UpperCAmelCase_			)
          processor.push_to_hub(UpperCAmelCase_			)


if __name__ == "__main__":
 SCREAMING_SNAKE_CASE_					:	int							  =						argparse.ArgumentParser()
 # Required parameters
 parser.add_argument(
     '--checkpoint',
     default='small',
     type=str,
     help='Checkpoint size of the MusicGen model you\'d like to convert. Can be one of: `[\'small\', \'medium\', \'large\']`.',
 )
 parser.add_argument(
     '--pytorch_dump_folder',
     required=True,
     default=None,
     type=str,
     help='Path to the output PyTorch model directory.',
 )
 parser.add_argument(
     '--push_to_hub', default=None, type=str, help='Where to upload the converted model on the 🤗 hub.'
 )
 parser.add_argument(
     '--device', default='cpu', type=str, help='Torch device to run the conversion, either cpu or cuda.'
 )

 SCREAMING_SNAKE_CASE_					:	Tuple							  =						parser.parse_args()
 convert_musicgen_checkpoint(args.checkpoint, args.pytorch_dump_folder, args.push_to_hub)






