






"""simple docstring"""



import argparse

import torch

from transformers import (
    EncodecConfig,
    EncodecFeatureExtractor,
    EncodecModel,
    logging,
)


# checkpoints downloaded from:
# https://dl.fbaipublicfiles.com/encodec/v0/encodec_24khz-d7cc33bc.th
# https://huggingface.co/facebook/musicgen-small/resolve/main/compression_state_dict.bin
# https://dl.fbaipublicfiles.com/encodec/v0/encodec_48khz-7e698e3e.th


logging.set_verbosity_info()
__A		:       Union[str, Any]  				=		logging.get_logger('''transformers.models.encodec''')

__A		:       Dict  				=		{
    '''quantizer.vq.layers.*._codebook.inited''': '''quantizer.layers.*.codebook.inited''',
    '''quantizer.vq.layers.*._codebook.cluster_size''': '''quantizer.layers.*.codebook.cluster_size''',
    '''quantizer.vq.layers.*._codebook.embed''': '''quantizer.layers.*.codebook.embed''',
    '''quantizer.vq.layers.*._codebook.embed_avg''': '''quantizer.layers.*.codebook.embed_avg''',
}
__A		:       str  				=		{
    '''encoder.model.0.conv.conv''': '''encoder.layers.0.conv''',
    '''encoder.model.1.block.1.conv.conv''': '''encoder.layers.1.block.1.conv''',
    '''encoder.model.1.block.3.conv.conv''': '''encoder.layers.1.block.3.conv''',
    '''encoder.model.1.shortcut.conv.conv''': '''encoder.layers.1.shortcut.conv''',
    '''encoder.model.3.conv.conv''': '''encoder.layers.3.conv''',
    '''encoder.model.4.block.1.conv.conv''': '''encoder.layers.4.block.1.conv''',
    '''encoder.model.4.block.3.conv.conv''': '''encoder.layers.4.block.3.conv''',
    '''encoder.model.4.shortcut.conv.conv''': '''encoder.layers.4.shortcut.conv''',
    '''encoder.model.6.conv.conv''': '''encoder.layers.6.conv''',
    '''encoder.model.7.block.1.conv.conv''': '''encoder.layers.7.block.1.conv''',
    '''encoder.model.7.block.3.conv.conv''': '''encoder.layers.7.block.3.conv''',
    '''encoder.model.7.shortcut.conv.conv''': '''encoder.layers.7.shortcut.conv''',
    '''encoder.model.9.conv.conv''': '''encoder.layers.9.conv''',
    '''encoder.model.10.block.1.conv.conv''': '''encoder.layers.10.block.1.conv''',
    '''encoder.model.10.block.3.conv.conv''': '''encoder.layers.10.block.3.conv''',
    '''encoder.model.10.shortcut.conv.conv''': '''encoder.layers.10.shortcut.conv''',
    '''encoder.model.12.conv.conv''': '''encoder.layers.12.conv''',
    '''encoder.model.13.lstm''': '''encoder.layers.13.lstm''',
    '''encoder.model.15.conv.conv''': '''encoder.layers.15.conv''',
}
__A		:       Dict  				=		{
    '''encoder.model.0.conv.norm''': '''encoder.layers.0.norm''',
    '''encoder.model.1.block.1.conv.norm''': '''encoder.layers.1.block.1.norm''',
    '''encoder.model.1.block.3.conv.norm''': '''encoder.layers.1.block.3.norm''',
    '''encoder.model.1.shortcut.conv.norm''': '''encoder.layers.1.shortcut.norm''',
    '''encoder.model.3.conv.norm''': '''encoder.layers.3.norm''',
    '''encoder.model.4.block.1.conv.norm''': '''encoder.layers.4.block.1.norm''',
    '''encoder.model.4.block.3.conv.norm''': '''encoder.layers.4.block.3.norm''',
    '''encoder.model.4.shortcut.conv.norm''': '''encoder.layers.4.shortcut.norm''',
    '''encoder.model.6.conv.norm''': '''encoder.layers.6.norm''',
    '''encoder.model.7.block.1.conv.norm''': '''encoder.layers.7.block.1.norm''',
    '''encoder.model.7.block.3.conv.norm''': '''encoder.layers.7.block.3.norm''',
    '''encoder.model.7.shortcut.conv.norm''': '''encoder.layers.7.shortcut.norm''',
    '''encoder.model.9.conv.norm''': '''encoder.layers.9.norm''',
    '''encoder.model.10.block.1.conv.norm''': '''encoder.layers.10.block.1.norm''',
    '''encoder.model.10.block.3.conv.norm''': '''encoder.layers.10.block.3.norm''',
    '''encoder.model.10.shortcut.conv.norm''': '''encoder.layers.10.shortcut.norm''',
    '''encoder.model.12.conv.norm''': '''encoder.layers.12.norm''',
    '''encoder.model.15.conv.norm''': '''encoder.layers.15.norm''',
}
__A		:       int  				=		{
    '''decoder.model.0.conv.conv''': '''decoder.layers.0.conv''',
    '''decoder.model.1.lstm''': '''decoder.layers.1.lstm''',
    '''decoder.model.3.convtr.convtr''': '''decoder.layers.3.conv''',
    '''decoder.model.4.block.1.conv.conv''': '''decoder.layers.4.block.1.conv''',
    '''decoder.model.4.block.3.conv.conv''': '''decoder.layers.4.block.3.conv''',
    '''decoder.model.4.shortcut.conv.conv''': '''decoder.layers.4.shortcut.conv''',
    '''decoder.model.6.convtr.convtr''': '''decoder.layers.6.conv''',
    '''decoder.model.7.block.1.conv.conv''': '''decoder.layers.7.block.1.conv''',
    '''decoder.model.7.block.3.conv.conv''': '''decoder.layers.7.block.3.conv''',
    '''decoder.model.7.shortcut.conv.conv''': '''decoder.layers.7.shortcut.conv''',
    '''decoder.model.9.convtr.convtr''': '''decoder.layers.9.conv''',
    '''decoder.model.10.block.1.conv.conv''': '''decoder.layers.10.block.1.conv''',
    '''decoder.model.10.block.3.conv.conv''': '''decoder.layers.10.block.3.conv''',
    '''decoder.model.10.shortcut.conv.conv''': '''decoder.layers.10.shortcut.conv''',
    '''decoder.model.12.convtr.convtr''': '''decoder.layers.12.conv''',
    '''decoder.model.13.block.1.conv.conv''': '''decoder.layers.13.block.1.conv''',
    '''decoder.model.13.block.3.conv.conv''': '''decoder.layers.13.block.3.conv''',
    '''decoder.model.13.shortcut.conv.conv''': '''decoder.layers.13.shortcut.conv''',
    '''decoder.model.15.conv.conv''': '''decoder.layers.15.conv''',
}
__A		:       Optional[Any]  				=		{
    '''decoder.model.0.conv.norm''': '''decoder.layers.0.norm''',
    '''decoder.model.3.convtr.norm''': '''decoder.layers.3.norm''',
    '''decoder.model.4.block.1.conv.norm''': '''decoder.layers.4.block.1.norm''',
    '''decoder.model.4.block.3.conv.norm''': '''decoder.layers.4.block.3.norm''',
    '''decoder.model.4.shortcut.conv.norm''': '''decoder.layers.4.shortcut.norm''',
    '''decoder.model.6.convtr.norm''': '''decoder.layers.6.norm''',
    '''decoder.model.7.block.1.conv.norm''': '''decoder.layers.7.block.1.norm''',
    '''decoder.model.7.block.3.conv.norm''': '''decoder.layers.7.block.3.norm''',
    '''decoder.model.7.shortcut.conv.norm''': '''decoder.layers.7.shortcut.norm''',
    '''decoder.model.9.convtr.norm''': '''decoder.layers.9.norm''',
    '''decoder.model.10.block.1.conv.norm''': '''decoder.layers.10.block.1.norm''',
    '''decoder.model.10.block.3.conv.norm''': '''decoder.layers.10.block.3.norm''',
    '''decoder.model.10.shortcut.conv.norm''': '''decoder.layers.10.shortcut.norm''',
    '''decoder.model.12.convtr.norm''': '''decoder.layers.12.norm''',
    '''decoder.model.13.block.1.conv.norm''': '''decoder.layers.13.block.1.norm''',
    '''decoder.model.13.block.3.conv.norm''': '''decoder.layers.13.block.3.norm''',
    '''decoder.model.13.shortcut.conv.norm''': '''decoder.layers.13.shortcut.norm''',
    '''decoder.model.15.conv.norm''': '''decoder.layers.15.norm''',
}
__A		:       Tuple  				=		{
    **MAPPING_QUANTIZER,
    **MAPPING_ENCODER,
    **MAPPING_DECODER,
}
__A		:       Optional[int]  				=		{
    **MAPPING_QUANTIZER,
    **MAPPING_ENCODER,
    **MAPPING_ENCODER_48K,
    **MAPPING_DECODER,
    **MAPPING_DECODER_48K,
}
__A		:       Optional[int]  				=		[]
__A		:       Dict  				=		[]



def 						lowercase    (				__snake_case				: Union[str, Any]		,					__snake_case				: Optional[int]		,					__snake_case				: List[Any]		,					__snake_case				: str		,					__snake_case				: Tuple	):
		for attribute in key.split('''.'''	):
				lowercase_ : Union[str, Any]							       =   getattr(__snake_case		,					__snake_case	)

		if weight_type is not None:
				lowercase_ : Any							       =   getattr(__snake_case		,					__snake_case	).shape
		else:
				lowercase_ : Union[str, Any]							       =   hf_pointer.shape

		if hf_shape != value.shape:
				raise ValueError(
				    F'''Shape of hf {key + '.' + weight_type if weight_type is not None else ''} is {hf_shape}, but should be'''
				    F''' {value.shape} for {full_name}'''	)

		if weight_type == "weight":
				lowercase_ : Tuple							       =   value
		elif weight_type == "weight_g":
				lowercase_ : Optional[Any]							       =   value
		elif weight_type == "weight_v":
				lowercase_ : Tuple							       =   value
		elif weight_type == "bias":
				lowercase_ : Optional[int]							       =   value
		elif weight_type == "running_mean":
				lowercase_ : Any							       =   value
		elif weight_type == "running_var":
				lowercase_ : Optional[int]							       =   value
		elif weight_type == "num_batches_tracked":
				lowercase_ : Dict							       =   value
		elif weight_type == "weight_ih_l0":
				lowercase_ : Optional[int]							       =   value
		elif weight_type == "weight_hh_l0":
				lowercase_ : Tuple							       =   value
		elif weight_type == "bias_ih_l0":
				lowercase_ : Optional[int]							       =   value
		elif weight_type == "bias_hh_l0":
				lowercase_ : Any							       =   value
		elif weight_type == "weight_ih_l1":
				lowercase_ : Optional[int]							       =   value
		elif weight_type == "weight_hh_l1":
				lowercase_ : str							       =   value
		elif weight_type == "bias_ih_l1":
				lowercase_ : Optional[int]							       =   value
		elif weight_type == "bias_hh_l1":
				lowercase_ : str							       =   value
		else:
				lowercase_ : List[str]							       =   value

		logger.info(F'''{key + ('.' + weight_type if weight_type is not None else '')} was initialized from {full_name}.'''	)



def 						lowercase    (				__snake_case				: int		,					__snake_case				: Dict	):
		for key in ignore_keys:
				if key.endswith('''.*'''	):
						if name.startswith(key[:-1]	):
								return True
				elif ".*." in key:
						lowercase_       ,					lowercase_ : Union[str, Any]							       =   key.split('''.*.'''	)
						if prefix in name and suffix in name:
								return True
				elif key in name:
						return True
		return False



def 						lowercase    (				__snake_case				: Dict		,					__snake_case				: Union[str, Any]		,					__snake_case				: Tuple	):
		lowercase_ : Dict							       =   []

		if model_name == "encodec_24khz" or "encodec_32khz":
				lowercase_ : Dict							       =   MAPPING_24K
		elif model_name == "encodec_48khz":
				lowercase_ : Union[str, Any]							       =   MAPPING_48K
		else:
				raise ValueError(F'''Unsupported model: {model_name}'''	)

		for name, value in orig_dict.items():
				if should_ignore(__snake_case		,					__snake_case	):
						logger.info(F'''{name} was ignored'''	)
						continue

				lowercase_ : List[str]							       =   False
				for key, mapped_key in MAPPING.items():
						if "*" in key:
								lowercase_       ,					lowercase_ : Dict							       =   key.split('''.*.'''	)
								if prefix in name and suffix in name:
										lowercase_ : List[str]							       =   suffix

						if key in name:
								# HACK otherwise .embed gets initialized with .embed_avg too
								if key.endswith('''embed'''	) and name.endswith('''embed_avg'''	):
										continue

								lowercase_ : Union[str, Any]							       =   True
								if "*" in mapped_key:
										lowercase_ : str							       =   name.split(__snake_case	)[0].split('''.'''	)[-2]
										lowercase_ : Any							       =   mapped_key.replace('''*'''		,					__snake_case	)
								if "weight_g" in name:
										lowercase_ : Any							       =   '''weight_g'''
								elif "weight_v" in name:
										lowercase_ : Optional[int]							       =   '''weight_v'''
								elif "weight_ih_l0" in name:
										lowercase_ : int							       =   '''weight_ih_l0'''
								elif "weight_hh_l0" in name:
										lowercase_ : int							       =   '''weight_hh_l0'''
								elif "bias_ih_l0" in name:
										lowercase_ : Tuple							       =   '''bias_ih_l0'''
								elif "bias_hh_l0" in name:
										lowercase_ : Union[str, Any]							       =   '''bias_hh_l0'''
								elif "weight_ih_l1" in name:
										lowercase_ : List[str]							       =   '''weight_ih_l1'''
								elif "weight_hh_l1" in name:
										lowercase_ : int							       =   '''weight_hh_l1'''
								elif "bias_ih_l1" in name:
										lowercase_ : Tuple							       =   '''bias_ih_l1'''
								elif "bias_hh_l1" in name:
										lowercase_ : Optional[Any]							       =   '''bias_hh_l1'''
								elif "bias" in name:
										lowercase_ : List[Any]							       =   '''bias'''
								elif "weight" in name:
										lowercase_ : Dict							       =   '''weight'''
								elif "running_mean" in name:
										lowercase_ : List[str]							       =   '''running_mean'''
								elif "running_var" in name:
										lowercase_ : Tuple							       =   '''running_var'''
								elif "num_batches_tracked" in name:
										lowercase_ : str							       =   '''num_batches_tracked'''
								else:
										lowercase_ : int							       =   None
								set_recursively(__snake_case		,					__snake_case		,					__snake_case		,					__snake_case		,					__snake_case	)
						continue
				if not is_used:
						unused_weights.append(__snake_case	)

		logger.warning(F'''Unused weights: {unused_weights}'''	)



@torch.no_grad()
def 						lowercase    (				__snake_case				: List[str]		,					__snake_case				: Dict		,					__snake_case				: List[Any]		,					__snake_case				: Union[str, Any]=None		,					__snake_case				: Optional[int]=None		,					):
		if config_path is not None:
				lowercase_ : List[Any]							       =   EncodecConfig.from_pretrained(__snake_case	)
		else:
				lowercase_ : Optional[Any]							       =   EncodecConfig()

		if model_name == "encodec_24khz":
				pass  # config is already correct
		elif model_name == "encodec_32khz":
				lowercase_ : Any							       =   [8, 5, 4, 4]
				lowercase_ : List[str]							       =   [2.2]
				lowercase_ : Optional[Any]							       =   6_4
				lowercase_ : int							       =   3_2_0_0_0
				lowercase_ : Union[str, Any]							       =   2_0_4_8
				lowercase_ : Union[str, Any]							       =   False
				lowercase_ : int							       =   False
				lowercase_ : str							       =   False
		elif model_name == "encodec_48khz":
				lowercase_ : str							       =   [8, 5, 4, 2]
				lowercase_ : str							       =   [3.0, 6.0, 12.0, 24.0]
				lowercase_ : str							       =   4_8_0_0_0
				lowercase_ : Optional[Any]							       =   2
				lowercase_ : List[str]							       =   False
				lowercase_ : int							       =   '''time_group_norm'''
				lowercase_ : List[str]							       =   True
				lowercase_ : Dict							       =   1.0
				lowercase_ : Union[str, Any]							       =   0.01
		else:
				raise ValueError(F'''Unknown model name: {model_name}'''	)

		lowercase_ : Optional[Any]							       =   EncodecModel(__snake_case	)

		lowercase_ : Dict							       =   EncodecFeatureExtractor(
		    feature_size=config.audio_channels		,					sampling_rate=config.sampling_rate		,					chunk_length_s=config.chunk_length_s		,					overlap=config.overlap		,					)
		feature_extractor.save_pretrained(__snake_case	)

		lowercase_ : str							       =   torch.load(__snake_case	)
		if "best_state" in original_checkpoint:
				# we might have a training state saved, in which case discard the yaml results and just retain the weights
				lowercase_ : List[str]							       =   original_checkpoint['''best_state''']
		recursively_load_weights(__snake_case		,					__snake_case		,					__snake_case	)
		model.save_pretrained(__snake_case	)

		if repo_id:
				print('''Pushing to the hub...'''	)
				feature_extractor.push_to_hub(__snake_case	)
				model.push_to_hub(__snake_case	)


if __name__ == "__main__":
						__A		:       Tuple  				=		argparse.ArgumentParser()
						parser.add_argument(
						    '''--model''',
						    default='''encodec_24khz''',
						    type=str,
						    help='''The model to convert. Should be one of \'encodec_24khz\', \'encodec_32khz\', \'encodec_48khz\'.''',
						)
						parser.add_argument('''--checkpoint_path''', required=True, default=None, type=str, help='''Path to original checkpoint''')
						parser.add_argument('''--config_path''', default=None, type=str, help='''Path to hf config.json of model to convert''')
						parser.add_argument(
						    '''--pytorch_dump_folder_path''', required=True, default=None, type=str, help='''Path to the output PyTorch model.'''
						)
						parser.add_argument(
						    '''--push_to_hub''', default=None, type=str, help='''Where to upload the converted model on the 🤗 hub.'''
						)

						__A		:       Optional[int]  				=		parser.parse_args()
						convert_checkpoint(
						    args.model,
						    args.checkpoint_path,
						    args.pytorch_dump_folder_path,
						    args.config_path,
						    args.push_to_hub,
						)











"""simple docstring"""



def 						lowercase    (				__snake_case				: int	):
		if not isinstance(__snake_case		,					__snake_case	):
				raise ValueError('''Input must be an integer'''	)
		if input_num <= 0:
				raise ValueError('''Input must be positive'''	)
		return sum(
		    divisor for divisor in range(1		,					input_num // 2 + 1	) if input_num % divisor == 0	)


if __name__ == "__main__":
						import doctest

						doctest.testmod()



