


import argparse
import json

import numpy
import torch

from transformers.models.xlm.tokenization_xlm import VOCAB_FILES_NAMES
from transformers.utils import CONFIG_NAME, WEIGHTS_NAME, logging


logging.set_verbosity_info()






def 			UpperCamelCase (     __magic_name__					:							Optional[Any]   ,   __magic_name__					:							int					)       ->  Tuple:
		"""simple docstring"""




		lowercase__					      =		torch.load(__magic_name__   ,   map_location="""cpu"""					)

		lowercase__					      =		chkpt["""model"""]

		# We have the base model one level deeper than the original XLM repository
		lowercase__					      =		{}
		for k, v in state_dict.items():
				if "pred_layer" in k:
						lowercase__					      =		v
				else:
						lowercase__					      =		v

		lowercase__					      =		chkpt["""params"""]
		lowercase__					      =		{n: v for n, v in config.items() if not isinstance(__magic_name__   ,   (torch.FloatTensor, numpy.ndarray)					)}

		lowercase__					      =		chkpt["""dico_word2id"""]
		lowercase__					      =		{s + """</w>""" if s.find("""@@"""					) == -1 and i > 13 else s.replace("""@@"""   ,   """"""					): i for s, i in vocab.items()}

		# Save pytorch-model
		lowercase__					      =		pytorch_dump_folder_path + """/""" + WEIGHTS_NAME
		lowercase__					      =		pytorch_dump_folder_path + """/""" + CONFIG_NAME
		lowercase__					      =		pytorch_dump_folder_path + """/""" + VOCAB_FILES_NAMES["""vocab_file"""]

		print(f'''Save PyTorch model to {pytorch_weights_dump_path}'''					)
		torch.save(__magic_name__   ,   __magic_name__					)

		print(f'''Save configuration file to {pytorch_config_dump_path}'''					)
		with open(__magic_name__   ,   """w"""   ,   encoding="""utf-8"""					) as f:
				f.write(json.dumps(__magic_name__   ,   indent=2					) + """\n"""					)

		print(f'''Save vocab file to {pytorch_config_dump_path}'''					)
		with open(__magic_name__   ,   """w"""   ,   encoding="""utf-8"""					) as f:
				f.write(json.dumps(__magic_name__   ,   indent=2					) + """\n"""					)


if __name__ == "__main__":
	A	:		str    =       argparse.ArgumentParser()
	# Required parameters
	parser.add_argument(
	    '--xlm_checkpoint_path', default=None, type=str, required=True, help='Path the official PyTorch dump.'
	)
	parser.add_argument(
	    '--pytorch_dump_folder_path', default=None, type=str, required=True, help='Path to the output PyTorch model.'
	)
	A	:		List[Any]    =       parser.parse_args()
	convert_xlm_checkpoint_to_pytorch(args.xlm_checkpoint_path, args.pytorch_dump_folder_path)





import json
import os
import unittest

from transformers import OpenAIGPTTokenizer, OpenAIGPTTokenizerFast
from transformers.models.openai.tokenization_openai import VOCAB_FILES_NAMES
from transformers.testing_utils import require_ftfy, require_spacy, require_tokenizers

from ...test_tokenization_common import TokenizerTesterMixin



@require_tokenizers
class 							A   (	UpperCAmelCase__			,  unittest.TestCase							):
					'''simple docstring'''






					A__      =			OpenAIGPTTokenizer
					A__      =			OpenAIGPTTokenizerFast
					A__      =			True
					A__      =			False

					def   lowerCamelCase__					(self   :						List[str]		)						->       int:




							"""simple docstring"""


							super().setUp()

							# Adapted from Sennrich et al. 2015 and https://github.com/rsennrich/subword-nmt
							lowercase__					      =		[
							    """l""",
							    """o""",
							    """w""",
							    """e""",
							    """r""",
							    """s""",
							    """t""",
							    """i""",
							    """d""",
							    """n""",
							    """w</w>""",
							    """r</w>""",
							    """t</w>""",
							    """lo""",
							    """low""",
							    """er</w>""",
							    """low</w>""",
							    """lowest</w>""",
							    """newer</w>""",
							    """wider</w>""",
							    """<unk>""",
							]
							lowercase__					      =		dict(zip(_UpperCAmelCase				, range(len(_UpperCAmelCase		)		)		)		)
							lowercase__					      =		["""#version: 0.2""", """l o""", """lo w""", """e r</w>""", """"""]

							lowercase__					      =		os.path.join(self.tmpdirname				, VOCAB_FILES_NAMES["""vocab_file"""]		)
							lowercase__					      =		os.path.join(self.tmpdirname				, VOCAB_FILES_NAMES["""merges_file"""]		)
							with open(self.vocab_file				, """w"""		) as fp:
									fp.write(json.dumps(_UpperCAmelCase		)		)
							with open(self.merges_file				, """w"""		) as fp:
									fp.write("""\n""".join(_UpperCAmelCase		)		)

					def   lowerCamelCase__					(self   :						Dict				, _UpperCAmelCase   :						List[Any]		)						->       Any:




							"""simple docstring"""


							return "lower newer", "lower newer"

					def   lowerCamelCase__					(self   :						Dict		)						->       Tuple:




							"""simple docstring"""


							lowercase__					      =		OpenAIGPTTokenizer(self.vocab_file				, self.merges_file		)

							lowercase__					      =		"""lower"""
							lowercase__					      =		["""low""", """er</w>"""]
							lowercase__					      =		tokenizer.tokenize(_UpperCAmelCase		)
							self.assertListEqual(_UpperCAmelCase				, _UpperCAmelCase		)

							lowercase__					      =		tokens + ["""<unk>"""]
							lowercase__					      =		[14, 15, 20]
							self.assertListEqual(tokenizer.convert_tokens_to_ids(_UpperCAmelCase		)				, _UpperCAmelCase		)

					def   lowerCamelCase__					(self   :						Optional[int]				, _UpperCAmelCase   :						Union[str, Any]=15		)						->       Optional[int]:




							"""simple docstring"""


							for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
									with self.subTest(f'''{tokenizer.__class__.__name__} ({pretrained_name})'''		):
											lowercase__					      =		self.rust_tokenizer_class.from_pretrained(_UpperCAmelCase				, **_UpperCAmelCase		)

											# Simple input
											lowercase__					      =		"""This is a simple input"""
											lowercase__					      =		["""This is a simple input 1""", """This is a simple input 2"""]
											lowercase__					      =		("""This is a simple input""", """This is a pair""")
											lowercase__					      =		[
											    ("""This is a simple input 1""", """This is a simple input 2"""),
											    ("""This is a simple pair 1""", """This is a simple pair 2"""),
											]

											# Simple input tests
											self.assertRaises(_UpperCAmelCase				, tokenizer_r.encode				, _UpperCAmelCase				, max_length=_UpperCAmelCase				, padding="""max_length"""		)

											# Simple input
											self.assertRaises(_UpperCAmelCase				, tokenizer_r.encode_plus				, _UpperCAmelCase				, max_length=_UpperCAmelCase				, padding="""max_length"""		)

											# Simple input
											self.assertRaises(
											    _UpperCAmelCase				, tokenizer_r.batch_encode_plus				, _UpperCAmelCase				, max_length=_UpperCAmelCase				, padding="""max_length"""				, )

											# Pair input
											self.assertRaises(_UpperCAmelCase				, tokenizer_r.encode				, _UpperCAmelCase				, max_length=_UpperCAmelCase				, padding="""max_length"""		)

											# Pair input
											self.assertRaises(_UpperCAmelCase				, tokenizer_r.encode_plus				, _UpperCAmelCase				, max_length=_UpperCAmelCase				, padding="""max_length"""		)

											# Pair input
											self.assertRaises(
											    _UpperCAmelCase				, tokenizer_r.batch_encode_plus				, _UpperCAmelCase				, max_length=_UpperCAmelCase				, padding="""max_length"""				, )


					def   lowerCamelCase__					(self   :						Tuple		)						->       Any:




							"""simple docstring"""


							pass






@require_ftfy
@require_spacy
@require_tokenizers
class 							A   (	UpperCAmelCase__							):
					'''simple docstring'''






					pass

