


"""simple docstring"""
import os
from dataclasses import dataclass, field
from io import BytesIO
from typing import TYPE_CHECKING, Any, ClassVar, Dict, Optional, Union

import numpy as np
import pyarrow as pa

from .. import config
from ..download.streaming_download_manager import xopen, xsplitext
from ..table import array_cast
from ..utils.py_utils import no_op_if_value_is_null, string_to_dict


if TYPE_CHECKING:
				from .features import FeatureType


__SCREAMING_SNAKE_CASE		,			__SCREAMING_SNAKE_CASE		,			__SCREAMING_SNAKE_CASE							:    List[str]		=    False, False, False





@dataclass
class      __A     :





							'''simple docstring'''

							__lowercase:		Optional[int]							      =    None
							__lowercase:		bool							      =    True
							__lowercase:		bool							      =    True
							__lowercase:		Optional[str]							      =    None
							# Automatically constructed
							__lowercase:		ClassVar[str]							      =    "dict"
							__lowercase:		ClassVar[Any]							      =    pa.struct({"""bytes""": pa.binary(), """path""": pa.string()})
							__lowercase:		str							      =    field(default="""Audio"""						,		init=__SCREAMING_SNAKE_CASE						,		repr=__SCREAMING_SNAKE_CASE)



							def __call__(				self							:      str       )					->Optional[int]:



														"""simple docstring"""



														return self.pa_type



							def 		lowerCAmelCase       (				self							:      Dict		,       UpperCAmelCase_							:      int       )					->int:



														"""simple docstring"""



														try:
																					import soundfile as sf  # soundfile is a dependency of librosa, needed to decode audio files.
														except ImportError as err:
																					raise ImportError("""To support encoding audio data, please install \'soundfile\'."""       ) from err
														if isinstance(_a		,       _a       ):
																					return {"bytes": None, "path": value}
														elif isinstance(_a		,       _a       ):
																					return {"bytes": value, "path": None}
														elif "array" in value:
																					# convert the audio array to wav bytes
																					snake_case_           =		BytesIO()
																					sf.write(_a		,       value["""array"""]		,       value["""sampling_rate"""]		,       format="""wav"""       )
																					return {"bytes": buffer.getvalue(), "path": None}
														elif value.get("""path"""       ) is not None and os.path.isfile(value["""path"""]       ):
																					# we set "bytes": None to not duplicate the data if they're already available locally
																					if value["path"].endswith("""pcm"""       ):
																												# "PCM" only has raw audio bytes
																												if value.get("""sampling_rate"""       ) is None:
																																			# At least, If you want to convert "PCM-byte" to "WAV-byte", you have to know sampling rate
																																			raise KeyError("""To use PCM files, please specify a \'sampling_rate\' in Audio object"""       )
																												if value.get("""bytes"""       ):
																																			# If we already had PCM-byte, we don`t have to make "read file, make bytes" (just use it!)
																																			snake_case_           =		np.frombuffer(value["""bytes"""]		,       dtype=np.intaa       ).astype(np.floataa       ) / 32_767
																												else:
																																			snake_case_           =		np.memmap(value["""path"""]		,       dtype="""h"""		,       mode="""r"""       ).astype(np.floataa       ) / 32_767

																												snake_case_           =		BytesIO(bytes()       )
																												sf.write(_a		,       _a		,       value["""sampling_rate"""]		,       format="""wav"""       )
																												return {"bytes": buffer.getvalue(), "path": None}
																					else:
																												return {"bytes": None, "path": value.get("""path"""       )}
														elif value.get("""bytes"""       ) is not None or value.get("""path"""       ) is not None:
																					# store the audio bytes, and path is used to infer the audio format using the file extension
																					return {"bytes": value.get("""bytes"""       ), "path": value.get("""path"""       )}
														else:
																					raise ValueError(
																					    F"""An audio sample should have one of \'path\' or \'bytes\' but they are missing or None in {value}."""       )



							def 		lowerCAmelCase       (				self							:      Dict		,       UpperCAmelCase_							:      List[Any]		,       UpperCAmelCase_							:      Any = None       )					->Dict:



														"""simple docstring"""



														if not self.decode:
																					raise RuntimeError("""Decoding is disabled for this feature. Please use Audio(decode=True) instead."""       )

														snake_case_       ,						snake_case_           =		(value["""path"""], BytesIO(value["""bytes"""]       )) if value["""bytes"""] is not None else (value["""path"""], None)
														if path is None and file is None:
																					raise ValueError(F"""An audio sample should have one of \'path\' or \'bytes\' but both are None in {value}."""       )

														try:
																					import librosa
																					import soundfile as sf
														except ImportError as err:
																					raise ImportError("""To support decoding audio files, please install \'librosa\' and \'soundfile\'."""       ) from err

														snake_case_           =		xsplitext(_a       )[1][1:].lower() if path is not None else None
														if not config.IS_OPUS_SUPPORTED and audio_format == "opus":
																					raise RuntimeError(
																					    """Decoding \'opus\' files requires system library \'libsndfile\'>=1.0.31, """
																					    """You can try to update `soundfile` python library: `pip install \"soundfile>=0.12.1\"`. """       )
														elif not config.IS_MP3_SUPPORTED and audio_format == "mp3":
																					raise RuntimeError(
																					    """Decoding \'mp3\' files requires system library \'libsndfile\'>=1.1.0, """
																					    """You can try to update `soundfile` python library: `pip install \"soundfile>=0.12.1\"`. """       )

														if file is None:
																					snake_case_           =		token_per_repo_id or {}
																					snake_case_           =		path.split("""::"""       )[-1]
																					try:
																												snake_case_           =		string_to_dict(_a		,       config.HUB_DATASETS_URL       )["""repo_id"""]
																												snake_case_           =		token_per_repo_id[repo_id]
																					except (ValueError, KeyError):
																												snake_case_           =		None

																					with xopen(_a		,       """rb"""		,       use_auth_token=_a       ) as f:
																												snake_case_       ,						snake_case_           =		sf.read(_a       )

														else:
																					snake_case_       ,						snake_case_           =		sf.read(_a       )

														snake_case_           =		array.T
														if self.mono:
																					snake_case_           =		librosa.to_mono(_a       )
														if self.sampling_rate and self.sampling_rate != sampling_rate:
																					snake_case_           =		librosa.resample(_a		,       orig_sr=_a		,       target_sr=self.sampling_rate       )
																					snake_case_           =		self.sampling_rate

														return {"path": path, "array": array, "sampling_rate": sampling_rate}



							def 		lowerCAmelCase       (				self							:      Dict       )					->str:



														"""simple docstring"""



														from .features import Value

														if self.decode:
																					raise ValueError("""Cannot flatten a decoded Audio feature."""       )
														return {
														    "bytes": Value("""binary"""       ),
														    "path": Value("""string"""       ),
														}



							def 		lowerCAmelCase       (				self							:      Optional[Any]		,       UpperCAmelCase_							:      List[Any]       )					->int:



														"""simple docstring"""



														if pa.types.is_string(storage.type       ):
																					snake_case_           =		pa.array([None] * len(_a       )		,       type=pa.binary()       )
																					snake_case_           =		pa.StructArray.from_arrays([bytes_array, storage]		,       ["""bytes""", """path"""]		,       mask=storage.is_null()       )
														elif pa.types.is_binary(storage.type       ):
																					snake_case_           =		pa.array([None] * len(_a       )		,       type=pa.string()       )
																					snake_case_           =		pa.StructArray.from_arrays([storage, path_array]		,       ["""bytes""", """path"""]		,       mask=storage.is_null()       )
														elif pa.types.is_struct(storage.type       ) and storage.type.get_all_field_indices("""array"""       ):
																					snake_case_           =		pa.array([Audio().encode_example(_a       ) if x is not None else None for x in storage.to_pylist()]       )
														elif pa.types.is_struct(storage.type       ):
																					if storage.type.get_field_index("""bytes"""       ) >= 0:
																												snake_case_           =		storage.field("""bytes"""       )
																					else:
																												snake_case_           =		pa.array([None] * len(_a       )		,       type=pa.binary()       )
																					if storage.type.get_field_index("""path"""       ) >= 0:
																												snake_case_           =		storage.field("""path"""       )
																					else:
																												snake_case_           =		pa.array([None] * len(_a       )		,       type=pa.string()       )
																					snake_case_           =		pa.StructArray.from_arrays([bytes_array, path_array]		,       ["""bytes""", """path"""]		,       mask=storage.is_null()       )
														return array_cast(_a		,       self.pa_type       )



							def 		lowerCAmelCase       (				self							:      Optional[int]		,       UpperCAmelCase_							:      Tuple       )					->Any:



														"""simple docstring"""



														@no_op_if_value_is_null
														def path_to_bytes(UpperCAmelCase_							:      str       ):
																					with xopen(_a		,       """rb"""       ) as f:
																												snake_case_           =		f.read()
																					return bytes_

														snake_case_           =		pa.array(
														    [
														        (path_to_bytes(x["""path"""]       ) if x["""bytes"""] is None else x["""bytes"""]) if x is not None else None
														        for x in storage.to_pylist()
														    ]		,       type=pa.binary()		,       )
														snake_case_           =		pa.array(
														    [os.path.basename(_a       ) if path is not None else None for path in storage.field("""path"""       ).to_pylist()]		,       type=pa.string()		,       )
														snake_case_           =		pa.StructArray.from_arrays([bytes_array, path_array]		,       ["""bytes""", """path"""]		,       mask=bytes_array.is_null()       )
														return array_cast(_a		,       self.pa_type       )







"""simple docstring"""
import argparse
import json
import os
from pathlib import Path

import requests
import torch

from transformers import JukeboxConfig, JukeboxModel
from transformers.utils import logging


logging.set_verbosity_info()
__SCREAMING_SNAKE_CASE							:    str		=    logging.get_logger(__name__)


__SCREAMING_SNAKE_CASE							:    Optional[int]		=    'https://openaipublic.azureedge.net/jukebox/models/'
__SCREAMING_SNAKE_CASE							:    List[Any]		=    {
    'jukebox-1b-lyrics': [
        '5b/vqvae.pth.tar',
        '5b/prior_level_0.pth.tar',
        '5b/prior_level_1.pth.tar',
        '1b_lyrics/prior_level_2.pth.tar',
    ],
    'jukebox-5b-lyrics': [
        '5b/vqvae.pth.tar',
        '5b/prior_level_0.pth.tar',
        '5b/prior_level_1.pth.tar',
        '5b_lyrics/prior_level_2.pth.tar',
    ],
}







def 						_a				(      _SCREAMING_SNAKE_CASE				)    ->				int:
							if key.endswith(""".model.1.bias"""				) and len(key.split("""."""				)				) > 10:
														snake_case_           =		key.replace(""".model.1.bias"""				, """.conv1d_1.bias"""				)
							elif key.endswith(""".model.1.weight"""				) and len(key.split("""."""				)				) > 10:
														snake_case_           =		key.replace(""".model.1.weight"""				, """.conv1d_1.weight"""				)
							elif key.endswith(""".model.3.bias"""				) and len(key.split("""."""				)				) > 10:
														snake_case_           =		key.replace(""".model.3.bias"""				, """.conv1d_2.bias"""				)
							elif key.endswith(""".model.3.weight"""				) and len(key.split("""."""				)				) > 10:
														snake_case_           =		key.replace(""".model.3.weight"""				, """.conv1d_2.weight"""				)

							if "conditioner_blocks.0." in key:
														snake_case_           =		key.replace("""conditioner_blocks.0"""				, """conditioner_blocks"""				)

							if "prime_prior" in key:
														snake_case_           =		key.replace("""prime_prior"""				, """encoder"""				)

							if ".emb." in key and "total" not in key and "absolute" not in key and "relative" not in key:
														snake_case_           =		key.replace(""".emb."""				, """."""				)

							if key.endswith("""k"""				):  # replace vqvae.X.k with vqvae.X.codebook
														return key.replace(""".k"""				, """.codebook"""				)
							if "y_emb." in key:
														return key.replace("""y_emb."""				, """metadata_embedding."""				)

							if "x_emb.emb." in key:
														snake_case_           =		key.replace("""0.x_emb.emb"""				, """embed_tokens"""				)

							if "prime_state_ln" in key:
														return key.replace("""prime_state_ln"""				, """encoder.final_layer_norm"""				)
							if ".ln" in key:
														return key.replace(""".ln"""				, """.layer_norm"""				)
							if "_ln" in key:
														return key.replace("""_ln"""				, """_layer_norm"""				)

							if "prime_state_proj" in key:
														return key.replace("""prime_state_proj"""				, """encoder.proj_in"""				)
							if "prime_x_out" in key:
														return key.replace("""prime_x_out"""				, """encoder.lm_head"""				)
							if "prior.x_out" in key:
														return key.replace("""x_out"""				, """fc_proj_out"""				)
							if "x_emb" in key:
														return key.replace("""x_emb"""				, """embed_tokens"""				)

							return key







def 						_a				(      _SCREAMING_SNAKE_CASE				, _SCREAMING_SNAKE_CASE				, _SCREAMING_SNAKE_CASE				, _SCREAMING_SNAKE_CASE				)    ->				Union[str, Any]:
							snake_case_           =		{}
							import re

							snake_case_           =		re.compile(r"""encoders.(\d*).level_blocks.(\d*).model.(\d*).(\d).(bias|weight)"""				)
							snake_case_           =		re.compile(
							    r"""encoders.(\d*).level_blocks.(\d*).model.(\d*).(\d).model.(\d*).model.(\d*).(bias|weight)"""				)
							snake_case_           =		re.compile(r"""encoders.(\d*).level_blocks.(\d*).model.(\d*).(bias|weight)"""				)

							snake_case_           =		re.compile(r"""decoders.(\d*).level_blocks.(\d*).model.(\d*).(\d).(bias|weight)"""				)
							snake_case_           =		re.compile(
							    r"""decoders.(\d*).level_blocks.(\d*).model.(\d*).(\d).model.(\d*).model.(\d*).(bias|weight)"""				)
							snake_case_           =		re.compile(r"""decoders.(\d*).level_blocks.(\d*).model.(\d*).(bias|weight)"""				)

							snake_case_           =		re.compile(r"""conditioner_blocks.(\d*).cond.model.(\d*).(\d).(bias|weight)"""				)
							snake_case_           =		re.compile(
							    r"""conditioner_blocks.(\d*).cond.model.(\d*).(\d).model.(\d*).model.(\d*).(bias|weight)"""				)
							snake_case_           =		re.compile(r"""conditioner_blocks.(\d*).cond.model.(\d*).(bias|weight)"""				)

							for original_key, value in state_dict.items():
														# rename vqvae.encoder keys
														if re_encoder_block_conv_in.fullmatch(_SCREAMING_SNAKE_CASE				):
																					snake_case_           =		re_encoder_block_conv_in.match(_SCREAMING_SNAKE_CASE				)
																					snake_case_           =		regex_match.groups()
																					snake_case_           =		int(groups[2]				) * 2 + int(groups[3]				)
																					snake_case_           =		f"""encoders.{groups[0]}.level_blocks.{groups[1]}.downsample_block.{block_index}.{groups[-1]}"""
																					snake_case_           =		re_encoder_block_conv_in.sub(_SCREAMING_SNAKE_CASE				, _SCREAMING_SNAKE_CASE				)

														elif re_encoder_block_resnet.fullmatch(_SCREAMING_SNAKE_CASE				):
																					snake_case_           =		re_encoder_block_resnet.match(_SCREAMING_SNAKE_CASE				)
																					snake_case_           =		regex_match.groups()
																					snake_case_           =		int(groups[2]				) * 2 + int(groups[3]				)
																					snake_case_           =		{"""1""": 1, """3""": 2}[groups[-2]]
																					snake_case_           =		f"""encoders.{groups[0]}.level_blocks.{groups[1]}.downsample_block.{block_index}."""
																					snake_case_           =		f"""resnet_block.{groups[-3]}.conv1d_{conv_index}.{groups[-1]}"""
																					snake_case_           =		prefix + resnet_block
																					snake_case_           =		re_encoder_block_resnet.sub(_SCREAMING_SNAKE_CASE				, _SCREAMING_SNAKE_CASE				)

														elif re_encoder_block_proj_out.fullmatch(_SCREAMING_SNAKE_CASE				):
																					snake_case_           =		re_encoder_block_proj_out.match(_SCREAMING_SNAKE_CASE				)
																					snake_case_           =		regex_match.groups()
																					snake_case_           =		f"""encoders.{groups[0]}.level_blocks.{groups[1]}.proj_out.{groups[-1]}"""
																					snake_case_           =		re_encoder_block_proj_out.sub(_SCREAMING_SNAKE_CASE				, _SCREAMING_SNAKE_CASE				)

														# rename vqvae.decoder keys
														elif re_decoder_block_conv_out.fullmatch(_SCREAMING_SNAKE_CASE				):
																					snake_case_           =		re_decoder_block_conv_out.match(_SCREAMING_SNAKE_CASE				)
																					snake_case_           =		regex_match.groups()
																					snake_case_           =		int(groups[2]				) * 2 + int(groups[3]				) - 2
																					snake_case_           =		f"""decoders.{groups[0]}.level_blocks.{groups[1]}.upsample_block.{block_index}.{groups[-1]}"""
																					snake_case_           =		re_decoder_block_conv_out.sub(_SCREAMING_SNAKE_CASE				, _SCREAMING_SNAKE_CASE				)

														elif re_decoder_block_resnet.fullmatch(_SCREAMING_SNAKE_CASE				):
																					snake_case_           =		re_decoder_block_resnet.match(_SCREAMING_SNAKE_CASE				)
																					snake_case_           =		regex_match.groups()
																					snake_case_           =		int(groups[2]				) * 2 + int(groups[3]				) - 2
																					snake_case_           =		{"""1""": 1, """3""": 2}[groups[-2]]
																					snake_case_           =		f"""decoders.{groups[0]}.level_blocks.{groups[1]}.upsample_block.{block_index}."""
																					snake_case_           =		f"""resnet_block.{groups[-3]}.conv1d_{conv_index}.{groups[-1]}"""
																					snake_case_           =		prefix + resnet_block
																					snake_case_           =		re_decoder_block_resnet.sub(_SCREAMING_SNAKE_CASE				, _SCREAMING_SNAKE_CASE				)

														elif re_decoder_block_proj_in.fullmatch(_SCREAMING_SNAKE_CASE				):
																					snake_case_           =		re_decoder_block_proj_in.match(_SCREAMING_SNAKE_CASE				)
																					snake_case_           =		regex_match.groups()
																					snake_case_           =		f"""decoders.{groups[0]}.level_blocks.{groups[1]}.proj_in.{groups[-1]}"""
																					snake_case_           =		re_decoder_block_proj_in.sub(_SCREAMING_SNAKE_CASE				, _SCREAMING_SNAKE_CASE				)

														# rename prior cond.model to upsampler.upsample_block and resnet
														elif re_prior_cond_conv_out.fullmatch(_SCREAMING_SNAKE_CASE				):
																					snake_case_           =		re_prior_cond_conv_out.match(_SCREAMING_SNAKE_CASE				)
																					snake_case_           =		regex_match.groups()
																					snake_case_           =		int(groups[1]				) * 2 + int(groups[2]				) - 2
																					snake_case_           =		f"""conditioner_blocks.upsampler.upsample_block.{block_index}.{groups[-1]}"""
																					snake_case_           =		re_prior_cond_conv_out.sub(_SCREAMING_SNAKE_CASE				, _SCREAMING_SNAKE_CASE				)

														elif re_prior_cond_resnet.fullmatch(_SCREAMING_SNAKE_CASE				):
																					snake_case_           =		re_prior_cond_resnet.match(_SCREAMING_SNAKE_CASE				)
																					snake_case_           =		regex_match.groups()
																					snake_case_           =		int(groups[1]				) * 2 + int(groups[2]				) - 2
																					snake_case_           =		{"""1""": 1, """3""": 2}[groups[-2]]
																					snake_case_           =		f"""conditioner_blocks.upsampler.upsample_block.{block_index}."""
																					snake_case_           =		f"""resnet_block.{groups[-3]}.conv1d_{conv_index}.{groups[-1]}"""
																					snake_case_           =		prefix + resnet_block
																					snake_case_           =		re_prior_cond_resnet.sub(_SCREAMING_SNAKE_CASE				, _SCREAMING_SNAKE_CASE				)

														elif re_prior_cond_proj_in.fullmatch(_SCREAMING_SNAKE_CASE				):
																					snake_case_           =		re_prior_cond_proj_in.match(_SCREAMING_SNAKE_CASE				)
																					snake_case_           =		regex_match.groups()
																					snake_case_           =		f"""conditioner_blocks.upsampler.proj_in.{groups[-1]}"""
																					snake_case_           =		re_prior_cond_proj_in.sub(_SCREAMING_SNAKE_CASE				, _SCREAMING_SNAKE_CASE				)

														# keep original key
														else:
																					snake_case_           =		original_key

														snake_case_           =		replace_key(_SCREAMING_SNAKE_CASE				)

														if f"""{key_prefix}.{key}""" not in model_state_dict or key is None:
																					print(f"""failed converting {original_key} to {key}, does not match"""				)

														# handle missmatched shape
														elif value.shape != model_state_dict[f"""{key_prefix}.{key}"""].shape:
																					snake_case_           =		model_state_dict[f"""{key_prefix}.{key}"""]
																					print(f"""{original_key}-> {key} : \nshape {val.shape} and { value.shape}, do not match"""				)
																					snake_case_           =		original_key

														snake_case_           =		original_key
														snake_case_           =		value

							return new_dict







@torch.no_grad()
def 						_a				(      _SCREAMING_SNAKE_CASE=None				, _SCREAMING_SNAKE_CASE=None				)    ->				Optional[int]:
							for file in MODEL_MAPPING[model_name]:
														if not os.path.isfile(f"""{pytorch_dump_folder_path}/{file.split("/"				)[-1]}"""				):
																					snake_case_           =		requests.get(f"""{PREFIX}{file}"""				, allow_redirects=_SCREAMING_SNAKE_CASE				)
																					os.makedirs(f"""{pytorch_dump_folder_path}/"""				, exist_ok=_SCREAMING_SNAKE_CASE				)
																					open(f"""{pytorch_dump_folder_path}/{file.split("/"				)[-1]}"""				, """wb"""				).write(r.content				)

							snake_case_           =		MODEL_MAPPING[model_name.split("""/"""				)[-1]]

							snake_case_           =		JukeboxConfig.from_pretrained(_SCREAMING_SNAKE_CASE				)
							snake_case_           =		JukeboxModel(_SCREAMING_SNAKE_CASE				)

							snake_case_           =		[]
							snake_case_           =		{}
							for i, dict_name in enumerate(_SCREAMING_SNAKE_CASE				):
														snake_case_           =		torch.load(f"""{pytorch_dump_folder_path}/{dict_name.split("/"				)[-1]}"""				)["""model"""]

														snake_case_           =		{}
														for k in old_dic.keys():
																					if k.endswith(""".b"""				):
																												snake_case_           =		old_dic[k]
																					elif k.endswith(""".w"""				):
																												snake_case_           =		old_dic[k]
																					elif "level_2" not in dict_name and "cond.model." in k:
																												snake_case_           =		old_dic[k]
																					else:
																												snake_case_           =		old_dic[k]

														snake_case_           =		"""vqvae""" if i == 0 else f"""priors.{3 - i}"""
														snake_case_           =		fix_jukebox_keys(_SCREAMING_SNAKE_CASE				, model.state_dict()				, _SCREAMING_SNAKE_CASE				, _SCREAMING_SNAKE_CASE				)
														weight_dict.append(_SCREAMING_SNAKE_CASE				)

							snake_case_           =		weight_dict.pop(0				)
							model.vqvae.load_state_dict(_SCREAMING_SNAKE_CASE				)
							for i in range(len(_SCREAMING_SNAKE_CASE				)				):
														model.priors[i].load_state_dict(weight_dict[2 - i]				)

							Path(_SCREAMING_SNAKE_CASE				).mkdir(exist_ok=_SCREAMING_SNAKE_CASE				)
							with open(f"""{pytorch_dump_folder_path}/mapping.json"""				, """w"""				) as txtfile:
														json.dump(_SCREAMING_SNAKE_CASE				, _SCREAMING_SNAKE_CASE				)

							print(f"""Saving model {model_name} to {pytorch_dump_folder_path}"""				)
							model.save_pretrained(_SCREAMING_SNAKE_CASE				)

							return weight_dict


if __name__ == "__main__":
				__SCREAMING_SNAKE_CASE							:    Union[str, Any]		=    argparse.ArgumentParser()
				# Required parameters
				parser.add_argument(
				    '--model_name',
				    default='jukebox-5b-lyrics',
				    type=str,
				    help='Name of the model you\'d like to convert.',
				)
				parser.add_argument(
				    '--pytorch_dump_folder_path',
				    default='jukebox-5b-lyrics-converted',
				    type=str,
				    help='Path to the output PyTorch model directory.',
				)
				__SCREAMING_SNAKE_CASE							:    str		=    parser.parse_args()
				convert_openai_checkpoint(args.model_name, args.pytorch_dump_folder_path)



