
import json
import os
from functools import lru_cache
from typing import TYPE_CHECKING, List, Optional, Tuple

import regex as re

from ...tokenization_utils import AddedToken, PreTrainedTokenizer
from ...utils import logging


if TYPE_CHECKING:
	from transformers.pipelines.conversational import Conversation

snake_case_      :					Optional[int]				      =     logging.get_logger(__name__)

snake_case_      :					int				      =     {
    'vocab_file': 'vocab.json',
    'merges_file': 'merges.txt',
}

snake_case_      :					int				      =     {
    'vocab_file': {
        'gpt2': 'https://huggingface.co/gpt2/resolve/main/vocab.json',
        'gpt2-medium': 'https://huggingface.co/gpt2-medium/resolve/main/vocab.json',
        'gpt2-large': 'https://huggingface.co/gpt2-large/resolve/main/vocab.json',
        'gpt2-xl': 'https://huggingface.co/gpt2-xl/resolve/main/vocab.json',
        'distilgpt2': 'https://huggingface.co/distilgpt2/resolve/main/vocab.json',
    },
    'merges_file': {
        'gpt2': 'https://huggingface.co/gpt2/resolve/main/merges.txt',
        'gpt2-medium': 'https://huggingface.co/gpt2-medium/resolve/main/merges.txt',
        'gpt2-large': 'https://huggingface.co/gpt2-large/resolve/main/merges.txt',
        'gpt2-xl': 'https://huggingface.co/gpt2-xl/resolve/main/merges.txt',
        'distilgpt2': 'https://huggingface.co/distilgpt2/resolve/main/merges.txt',
    },
}

snake_case_      :					Any				      =     {
    'gpt2': 1_0_2_4,
    'gpt2-medium': 1_0_2_4,
    'gpt2-large': 1_0_2_4,
    'gpt2-xl': 1_0_2_4,
    'distilgpt2': 1_0_2_4,
}



@lru_cache()
def      __UpperCAmelCase    (  ):



	'''simple docstring'''



	UpperCAmelCase:					Optional[int] 						=     (
	    list(range(ord("!"				)				,					ord("~"				) + 1				)				) + list(range(ord("¡"				)				,					ord("¬"				) + 1				)				) + list(range(ord("®"				)				,					ord("ÿ"				) + 1				)				)
	)
	UpperCAmelCase:					List[Any] 						=     bs[:]
	UpperCAmelCase:					Optional[Any] 						=     0
	for b in range(2**8				):
		if b not in bs:
			bs.append(snake_case_				)
			cs.append(2**8 + n				)
			n += 1
	UpperCAmelCase:					Optional[Any] 						=     [chr(snake_case_				) for n in cs]
	return dict(zip(snake_case_				,					snake_case_				)				)



def      __UpperCAmelCase    (  snake_case_							:		Dict				):



	'''simple docstring'''



	UpperCAmelCase:					List[str] 						=     set()
	UpperCAmelCase:					List[Any] 						=     word[0]
	for char in word[1:]:
		pairs.add((prev_char, char)				)
		UpperCAmelCase:					Any 						=     char
	return pairs





class 		__lowerCamelCase     (   lowercase		):
							lowerCamelCase__:				Optional[int]      =							VOCAB_FILES_NAMES
							lowerCamelCase__:				List[Any]      =							PRETRAINED_VOCAB_FILES_MAP
							lowerCamelCase__:				List[Any]      =							PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
							lowerCamelCase__:				Union[str, Any]      =							['''input_ids''', '''attention_mask''']



							def __init__(     self	,				__snake_case	,				__snake_case	,				__snake_case="replace"	,				__snake_case="<|endoftext|>"	,				__snake_case="<|endoftext|>"	,				__snake_case="<|endoftext|>"	,				__snake_case=None	,				__snake_case=False	,				__snake_case=False	,				**__snake_case	,				)						->     List[str]:






								"""simple docstring"""



								UpperCAmelCase:					str 						=     AddedToken(__snake_case	,				lstrip=__snake_case	,				rstrip=__snake_case							) if isinstance(__snake_case	,				__snake_case							) else bos_token
								UpperCAmelCase:					Union[str, Any] 						=     AddedToken(__snake_case	,				lstrip=__snake_case	,				rstrip=__snake_case							) if isinstance(__snake_case	,				__snake_case							) else eos_token
								UpperCAmelCase:					Any 						=     AddedToken(__snake_case	,				lstrip=__snake_case	,				rstrip=__snake_case							) if isinstance(__snake_case	,				__snake_case							) else unk_token
								UpperCAmelCase:					Union[str, Any] 						=     AddedToken(__snake_case	,				lstrip=__snake_case	,				rstrip=__snake_case							) if isinstance(__snake_case	,				__snake_case							) else pad_token
								super().__init__(
								    errors=__snake_case	,				unk_token=__snake_case	,				bos_token=__snake_case	,				eos_token=__snake_case	,				pad_token=__snake_case	,				add_prefix_space=__snake_case	,				add_bos_token=__snake_case	,				**__snake_case	,				)
								UpperCAmelCase:					Union[str, Any] 						=     add_bos_token

								with open(__snake_case	,				encoding="utf-8"							) as vocab_handle:
									UpperCAmelCase:					Optional[int] 						=     json.load(__snake_case							)
								UpperCAmelCase:					List[str] 						=     {v: k for k, v in self.encoder.items()}
								UpperCAmelCase:					Dict 						=     errors  # how to handle errors in decoding
								UpperCAmelCase:					Any 						=     bytes_to_unicode()
								UpperCAmelCase:					Union[str, Any] 						=     {v: k for k, v in self.byte_encoder.items()}
								with open(__snake_case	,				encoding="utf-8"							) as merges_handle:
									UpperCAmelCase:					Any 						=     merges_handle.read().split("\n"							)[1:-1]
								UpperCAmelCase:					Any 						=     [tuple(merge.split()							) for merge in bpe_merges]
								UpperCAmelCase:					Optional[Any] 						=     dict(zip(__snake_case	,				range(len(__snake_case							)							)							)							)
								UpperCAmelCase:					Any 						=     {}
								UpperCAmelCase:					Any 						=     add_prefix_space

								# Should have added re.IGNORECASE so BPE merges can happen for capitalized versions of contractions
								UpperCAmelCase:					Optional[int] 						=     re.compile(R"'s|'t|'re|'ve|'m|'ll|'d| ?\p{L}+| ?\p{N}+| ?[^\s\p{L}\p{N}]+|\s+(?!\S)|\s+"							)



							@property
							def     A__ (     self							)						->     Dict:






								"""simple docstring"""



								return len(self.encoder							)



							def     A__ (     self							)						->     Optional[Any]:






								"""simple docstring"""



								return dict(self.encoder	,				**self.added_tokens_encoder							)



							def     A__ (     self	,				__snake_case							)						->     str:






								"""simple docstring"""



								if token in self.cache:
									return self.cache[token]
								UpperCAmelCase:					Tuple 						=     tuple(__snake_case							)
								UpperCAmelCase:					Optional[int] 						=     get_pairs(__snake_case							)

								if not pairs:
									return token

								while True:
									UpperCAmelCase:					Optional[int] 						=     min(__snake_case	,				key=lambda __snake_case							: self.bpe_ranks.get(__snake_case	,				float("inf"							)							)							)
									if bigram not in self.bpe_ranks:
										break
									UpperCAmelCase						,   UpperCAmelCase:					Tuple 						=     bigram
									UpperCAmelCase:					str 						=     []
									UpperCAmelCase:					Optional[Any] 						=     0
									while i < len(__snake_case							):
										try:
											UpperCAmelCase:					Tuple 						=     word.index(__snake_case	,				__snake_case							)
										except ValueError:
											new_word.extend(word[i:]							)
											break
										else:
											new_word.extend(word[i:j]							)
											UpperCAmelCase:					Any 						=     j

										if word[i] == first and i < len(__snake_case							) - 1 and word[i + 1] == second:
											new_word.append(first + second							)
											i += 2
										else:
											new_word.append(word[i]							)
											i += 1
									UpperCAmelCase:					Optional[Any] 						=     tuple(__snake_case							)
									UpperCAmelCase:					Any 						=     new_word
									if len(__snake_case							) == 1:
										break
									else:
										UpperCAmelCase:					List[str] 						=     get_pairs(__snake_case							)
								UpperCAmelCase:					Optional[int] 						=     " ".join(__snake_case							)
								UpperCAmelCase:					int 						=     word
								return word



							def     A__ (     self	,				__snake_case	,				__snake_case=None							)						->     str:






								"""simple docstring"""



								if self.add_bos_token:
									UpperCAmelCase:					List[Any] 						=     [self.bos_token_id]
								else:
									UpperCAmelCase:					List[Any] 						=     []

								UpperCAmelCase:					Tuple 						=     bos_token_ids + token_ids_a

								if token_ids_a is None:
									return output

								return output + bos_token_ids + token_ids_a



							def     A__ (     self	,				__snake_case	,				__snake_case = None	,				__snake_case = False							)						->     List[int]:






								"""simple docstring"""



								if already_has_special_tokens:
									return super().get_special_tokens_mask(
									    token_ids_a=__snake_case	,				token_ids_a=__snake_case	,				already_has_special_tokens=__snake_case							)

								if not self.add_bos_token:
									return super().get_special_tokens_mask(
									    token_ids_a=__snake_case	,				token_ids_a=__snake_case	,				already_has_special_tokens=__snake_case							)

								if token_ids_a is None:
									return [1] + ([0] * len(__snake_case							))
								return [1] + ([0] * len(__snake_case							)) + [1] + ([0] * len(__snake_case							))



							def     A__ (     self	,				__snake_case							)						->     Any:






								"""simple docstring"""



								UpperCAmelCase:					Union[str, Any] 						=     []
								for token in re.findall(self.pat	,				__snake_case							):
									UpperCAmelCase:					int 						=     "".join(
									    self.byte_encoder[b] for b in token.encode("utf-8"							)							)  # Maps all our bytes to unicode strings, avoiding control tokens of the BPE (spaces in our case)
									bpe_tokens.extend(bpe_token for bpe_token in self.bpe(__snake_case							).split(" "							)							)
								return bpe_tokens



							def     A__ (     self	,				__snake_case							)						->     Dict:






								"""simple docstring"""



								return self.encoder.get(__snake_case	,				self.encoder.get(self.unk_token							)							)



							def     A__ (     self	,				__snake_case							)						->     List[str]:






								"""simple docstring"""



								return self.decoder.get(__snake_case							)



							def     A__ (     self	,				__snake_case							)						->     Union[str, Any]:






								"""simple docstring"""



								UpperCAmelCase:					int 						=     "".join(__snake_case							)
								UpperCAmelCase:					Dict 						=     bytearray([self.byte_decoder[c] for c in text]							).decode("utf-8"	,				errors=self.errors							)
								return text



							def     A__ (     self	,				__snake_case	,				__snake_case = None							)						->     Tuple[str]:






								"""simple docstring"""



								if not os.path.isdir(__snake_case							):
									logger.error(F'Vocabulary path ({save_directory}) should be a directory'							)
									return
								UpperCAmelCase:					Union[str, Any] 						=     os.path.join(
								    __snake_case	,				(filename_prefix + "-" if filename_prefix else "") + VOCAB_FILES_NAMES["vocab_file"]							)
								UpperCAmelCase:					Union[str, Any] 						=     os.path.join(
								    __snake_case	,				(filename_prefix + "-" if filename_prefix else "") + VOCAB_FILES_NAMES["merges_file"]							)

								with open(__snake_case	,				"w"	,				encoding="utf-8"							) as f:
									f.write(json.dumps(self.encoder	,				indent=2	,				sort_keys=__snake_case	,				ensure_ascii=__snake_case							) + "\n"							)

								UpperCAmelCase:					Union[str, Any] 						=     0
								with open(__snake_case	,				"w"	,				encoding="utf-8"							) as writer:
									writer.write("#version: 0.2\n"							)
									for bpe_tokens, token_index in sorted(self.bpe_ranks.items()	,				key=lambda __snake_case							: kv[1]							):
										if index != token_index:
											logger.warning(
											    F'Saving vocabulary to {merge_file}: BPE merge indices are not consecutive.'
											    " Please check that the tokenizer is not corrupted!"							)
											UpperCAmelCase:					Union[str, Any] 						=     token_index
										writer.write(" ".join(__snake_case							) + "\n"							)
										index += 1

								return vocab_file, merge_file



							def     A__ (     self	,				__snake_case	,				__snake_case=False	,				**__snake_case							)						->     List[Any]:






								"""simple docstring"""



								UpperCAmelCase:					int 						=     kwargs.pop("add_prefix_space"	,				self.add_prefix_space							)
								if is_split_into_words or add_prefix_space:
									UpperCAmelCase:					List[str] 						=     " " + text
								return (text, kwargs)




							def     A__ (     self	,				__snake_case							)						->     List[int]:






								"""simple docstring"""



								UpperCAmelCase:					str 						=     []
								for is_user, text in conversation.iter_texts():
									input_ids.extend(self.encode(__snake_case	,				add_special_tokens=__snake_case							) + [self.eos_token_id]							)
								if len(__snake_case							) > self.model_max_length:
									UpperCAmelCase:					str 						=     input_ids[-self.model_max_length :]
								return input_ids


import argparse

# utilities to import the model weights and config file
import os
import pickle as pkl

# PyTorch + new model classes
import torch
from torch import nn

from transformers import AutoTokenizer, MegaConfig, MegaForMaskedLM


# import the EncoderLayer class used to pretrain
# !! NOTE !! this requires the version of fairseq that is built when you install the Mega source
try:
	from fairseq.modules.mega_layer import MegaEncoderLayer
except ImportError:
	raise ImportError('You need to install the version of fairseq from the Mega repo!')





class 		__lowerCamelCase     (   nn.Module		):



							def __init__(     self	,				__snake_case	,				__snake_case	,				__snake_case							)						->     Dict:






								"""simple docstring"""



								super().__init__()
								UpperCAmelCase:					int 						=     mega_args
								UpperCAmelCase:					Union[str, Any] 						=     nn.Embedding(__snake_case	,				self.mega_args.encoder_embed_dim							)
								UpperCAmelCase:					List[str] 						=     nn.ModuleList([MegaEncoderLayer(self.mega_args							) for _ in range(__snake_case							)]							)
								UpperCAmelCase:					List[str] 						=     depth




							def     A__ (     self	,				__snake_case	,				__snake_case	,				__snake_case=True	,				__snake_case=0							)						->     List[str]:






								"""simple docstring"""



								if batch_first:
									UpperCAmelCase:					int 						=     input_ids.T

								# to make things more confusing, Mega expects the attention mask to
								# be (batch, time), but with values of 0 (normal token) and 1 (ignore token)
								# which is the opposite of what HF returns
								if ignore_mask_value == 0:
									UpperCAmelCase:					Union[str, Any] 						=     1 - attention_mask

								# get token embeddings from IDs
								UpperCAmelCase:					Dict 						=     self.embedding_layer(__snake_case							)

								# pass through the Mega layers
								# input is (time, batch, encoder dim) and output is the same
								for encoder in self.encoders:
									UpperCAmelCase:					Any 						=     encoder(__snake_case	,				__snake_case							)

								# return according to the shape specified
								if batch_first:
									# (T, B, H) --> (B, T, H)
									return torch.transpose(__snake_case	,				0	,				1							)
								else:
									return embeds





class 		__lowerCamelCase     (   nn.Module		):



							def __init__(     self	,				__snake_case	,				__snake_case	,				__snake_case							)						->     Any:






								"""simple docstring"""



								super().__init__()
								UpperCAmelCase:					int 						=     MegaLM(__snake_case	,				__snake_case	,				__snake_case							)
								UpperCAmelCase:					Tuple 						=     nn.Linear(mega_args.encoder_embed_dim	,				__snake_case							)
								UpperCAmelCase:					List[str] 						=     nn.Dropout(p=0.1							)




							def     A__ (     self	,				__snake_case	,				__snake_case	,				__snake_case=True	,				__snake_case=0							)						->     Optional[Any]:






								"""simple docstring"""



								UpperCAmelCase:					str 						=     self.mega(__snake_case	,				__snake_case	,				__snake_case	,				__snake_case							)
								return self.mlm_head(self.dropout(__snake_case							)							)



def      __UpperCAmelCase    (  snake_case_							:		Optional[Any]				,					snake_case_							:		Dict				,					snake_case_							:		Tuple				):



	'''simple docstring'''



	with open(os.path.join(snake_case_				,					"model_args.pkl"				)				,					"rb"				) as f:
		UpperCAmelCase:					Union[str, Any] 						=     pkl.load(snake_case_				)

	# load the original encoder
	UpperCAmelCase:					Tuple 						=     OriginalMegaForMaskedLM(**snake_case_				).eval()

	# load its weights
	print(
	    "Original Mega encoder:"				,					original_mlm.mega.load_state_dict(
	        torch.load(os.path.join(snake_case_				,					"encoder_weights.pt"				)				,					map_location="cpu"				)				)				,					)
	print(
	    "Original Mega MLM layer:"				,					original_mlm.mlm_head.load_state_dict(
	        torch.load(os.path.join(snake_case_				,					"mlm_head_weights.pt"				)				,					map_location="cpu"				)				)				,					)

	# create a new config from the old one
	UpperCAmelCase:					int 						=     MegaConfig(
	    num_hidden_layers=mega_original_args["depth"]				,					vocab_size=mega_original_args["vocab_size"]				,					hidden_size=mega_original_args["mega_args"].encoder_embed_dim				,					shared_representation_size=mega_original_args["mega_args"].encoder_z_dim				,					intermediate_size=mega_original_args["mega_args"].encoder_hidden_dim				,					ema_projection_size=mega_original_args["mega_args"].encoder_n_dim				,					dropout_prob=mega_original_args["mega_args"].dropout				,					attention_probs_dropout_prob=mega_original_args["mega_args"].attention_dropout				,					hidden_dropout_prob=mega_original_args["mega_args"].hidden_dropout				,					activation=mega_original_args["mega_args"].activation_fn				,					attention_activation=mega_original_args["mega_args"].attention_activation_fn				,					bidirectional=mega_original_args["mega_args"].bidirectional				,					use_chunking=mega_original_args["mega_args"].encoder_chunk_size > 0				,					chunk_size=mega_original_args["mega_args"].encoder_chunk_size				,					truncation=mega_original_args["mega_args"].truncation_length				,					normalization_type=mega_original_args["mega_args"].normalization_type				,					normalize_before_mega=snake_case_				,					norm_affine=snake_case_				,					use_feature_dropout=mega_original_args["mega_args"].feature_dropout				,					relative_positional_bias=mega_original_args["mega_args"].rel_pos_bias				,					max_positions=mega_original_args["mega_args"].max_source_positions				,					nffn_hidden_size=mega_original_args["mega_args"].encoder_ffn_embed_dim				,					normalize_before_ffn=mega_original_args["mega_args"].normalize_before				,					nffn_activation_dropout_prob=0.0				,					add_token_type_embeddings=snake_case_				,					add_lm_hidden_dense_layer=snake_case_				,					)

	UpperCAmelCase:					Union[str, Any] 						=     MegaForMaskedLM(snake_case_				).eval()

	# the originl checkpoint just uses nn.Embedding for the word embeddings
	# we use a wrapper module for embeddings to add support for positional embeddings
	UpperCAmelCase:					str 						=     original_mlm.mega.embedding_layer.weight

	# modify the state dictionary of the original checkpoint to account for naming issues in the Hugging Face
	# ecosystem -- any names containing "beta" or "gamma" aren't safe to use and are renamed upon _load_pretrained,
	# also renaming previously confusing parameter names
	UpperCAmelCase:					List[str] 						=     original_mlm.mega.encoders.state_dict()
	UpperCAmelCase:					Optional[Any] 						=     {}
	for module_name in original_state_dict.keys():
		UpperCAmelCase:					Optional[Any] 						=     None
		# have to handle gamma, beta, and alpha differently due to their use
		# in multiple modules within the original repository;
		# beta is used in EMA, MovingAverageGatedAttention, and RotaryRelativePositionalBias, and must be renamed due to flax/tf weights
		# the EMA sublayer was renamed from "move" to "ema_gate" for readability, so that is also done here
		if "beta" in module_name:
			# EMA sub-layers were always called "move" in the original repo
			if "move.beta" in module_name:
				UpperCAmelCase:					Any 						=     module_name.replace("move.beta"				,					"ema_gate.ema_expansion_matrix"				)
			elif "mega_layer.beta" in module_name:
				UpperCAmelCase:					Optional[int] 						=     module_name.replace("beta"				,					"qk_bias"				)
			else:
				UpperCAmelCase:					List[str] 						=     module_name.replace("beta"				,					"b_param"				)
        # beta is used in EMA and MovingAverageGatedAttention, and must be renamed due to flax/tf weights
		elif "gamma" in module_name:
			if "move.gamma" in module_name:
				UpperCAmelCase:					Union[str, Any] 						=     module_name.replace("move.gamma"				,					"ema_gate.kernel_projection_matrix"				)
			elif "mega_layer.gamma" in module_name:
				UpperCAmelCase:					Any 						=     module_name.replace("gamma"				,					"qk_weight"				)
			else:
				UpperCAmelCase:					List[Any] 						=     module_name.replace("gamma"				,					"g_param"				)
        # alpha is used in EMA and positional bias; renaming to improve readability
		elif "move.alpha" in module_name:
			UpperCAmelCase:					Tuple 						=     module_name.replace("move.alpha"				,					"ema_gate.decay_factor"				)
		# delta is only used in EMA; renaming to improve readability
		elif "move.delta" in module_name:
			UpperCAmelCase:					Any 						=     module_name.replace("move.delta"				,					"ema_gate.damping_factor"				)
		# omega is only used in EMA; renaming to improve readability
		elif "omega" in module_name:
			UpperCAmelCase:					Optional[int] 						=     module_name.replace("move.omega"				,					"ema_gate.residual_weight"				)

		if new_module_name:
			UpperCAmelCase:					List[Any] 						=     new_module_name

	if len(snake_case_				) != 0:
		print(F'Renaming these keys: {updated_keys.keys()}'				)
	else:
		print("No need to rename state dict entries"				)
	for old, new in updated_keys.items():
		UpperCAmelCase:					str 						=     original_state_dict.pop(snake_case_				)

	# now attempt to load the state dictionary with updated names
	# note that we now call it `mega.layers` instead of `mega.encoders` due to hugging face style
	print("HF Mega encoder:"				,					hf_mlm.mega.layers.load_state_dict(snake_case_				)				)

	# load the MLM head weights directly
	print(
	    "HF Mega MLM layer:"				,					hf_mlm.mlm_head.load_state_dict(
	        torch.load(os.path.join(snake_case_				,					"mlm_head_weights.pt"				)				,					map_location="cpu"				)				)				,					)

	# test on a randomly generated input sequence
	UpperCAmelCase:					Optional[int] 						=     torch.randint(0				,					hf_config.vocab_size				,					size=(4, 2_5_6)				)
	UpperCAmelCase:					int 						=     torch.ones_like(snake_case_				)
	# mask a few tokens to make sure masking is applied appropriately :)
	UpperCAmelCase:					int 						=     0

	# run forward passes
	UpperCAmelCase:					Optional[int] 						=     original_mlm(snake_case_				,					snake_case_				,					batch_first=snake_case_				,					ignore_mask_value=0				)
	UpperCAmelCase:					Optional[int] 						=     hf_mlm(snake_case_				,					snake_case_				)[0]

	# print shapes and diff
	print(F'original output {original_output.shape}'				)
	print(F'hf output {hf_output.shape}'				)
	print(F'max diff: {(original_output - hf_output).max()}'				)  # 0.0
	UpperCAmelCase:					Tuple 						=     torch.allclose(snake_case_				,					snake_case_				,					atol=1e-3				)

	if success:
		print("Yay!"				)
		hf_mlm.save_pretrained(snake_case_				)
	else:
		raise RuntimeError(F'Something\'s broken :(\nOriginal:\n{original_output}\n\nHF\n{hf_output}\n{hf_mlm}'				)

	if includes_tokenizer:
		print("Transferring tokenizer"				)
		UpperCAmelCase:					List[str] 						=     AutoTokenizer.from_pretrained(snake_case_				)
		tokenizer.save_pretrained(snake_case_				)


if __name__ == "__main__":
	snake_case_      :					str				      =     argparse.ArgumentParser()

	parser.add_argument(
	    '--pretrained_checkpoint_path',
	    default=None,
	    type=str,
	    required=True,
	    help='Point to the directory containing your model weights using the official Mega repo',
	)

	parser.add_argument(
	    '--output_path', default=None, type=str, required=True, help='Location to save the Hugging Face version'
	)

	parser.add_argument(
	    '--includes_tokenizer',
	    action='store_true',
	    help='Use this flag if there is a Hugging Face tokenizer in the original checkpoint repo',
	)

	snake_case_      :					str				      =     parser.parse_args()

	convert_checkpoint_to_huggingface(args.pretrained_checkpoint_path, args.output_path, args.includes_tokenizer)
