

import argparse
import os
import pickle
import sys

import torch

from transformers import TransfoXLConfig, TransfoXLLMHeadModel, load_tf_weights_in_transfo_xl
from transformers.models.transfo_xl import tokenization_transfo_xl as data_utils
from transformers.models.transfo_xl.tokenization_transfo_xl import CORPUS_NAME, VOCAB_FILES_NAMES
from transformers.utils import CONFIG_NAME, WEIGHTS_NAME, logging


logging.set_verbosity_info()

# We do this to be able to load python 2 datasets pickles
# See e.g. https://stackoverflow.com/questions/2121874/python-pickling-after-changing-a-modules-directory/2121918#2121918
_lowerCAmelCase					:			Union[str, Any]  				=			data_utils.TransfoXLTokenizer
_lowerCAmelCase					:			Any  				=			data_utils.TransfoXLCorpus
_lowerCAmelCase					:			List[str]  				=			data_utils
_lowerCAmelCase					:			Dict  				=			data_utils






def        UpperCamelCase_(							_snake_case   :  List[str]       ,     _snake_case   :  Any       ,     _snake_case   :  Optional[Any]       ,     _snake_case   :  Tuple	):




			"""simple docstring"""






			if transfo_xl_dataset_file:
						# Convert a pre-processed corpus (see original TensorFlow repo)
						with open(_snake_case       ,     'rb'	) as fp:
									__a        =pickle.load(_snake_case       ,     encoding='latin1'	)
						# Save vocabulary and dataset cache as Dictionaries (should be better than pickles for the long-term)
						__a        =pytorch_dump_folder_path + '/' + VOCAB_FILES_NAMES['pretrained_vocab_file']
						print(F'Save vocabulary to {pytorch_vocab_dump_path}'	)
						__a        =corpus.vocab.__dict__
						torch.save(_snake_case       ,     _snake_case	)

						__a        =corpus.__dict__
						corpus_dict_no_vocab.pop('vocab'       ,     _snake_case	)
						__a        =pytorch_dump_folder_path + '/' + CORPUS_NAME
						print(F'Save dataset to {pytorch_dataset_dump_path}'	)
						torch.save(_snake_case       ,     _snake_case	)

			if tf_checkpoint_path:
						# Convert a pre-trained TensorFlow model
						__a        =os.path.abspath(_snake_case	)
						__a        =os.path.abspath(_snake_case	)

						print(F'Converting Transformer XL checkpoint from {tf_path} with config at {config_path}.'	)
						# Initialise PyTorch model
						if transfo_xl_config_file == "":
									__a        =TransfoXLConfig()
						else:
									__a        =TransfoXLConfig.from_json_file(_snake_case	)
						print(F'Building PyTorch model from configuration: {config}'	)
						__a        =TransfoXLLMHeadModel(_snake_case	)

						__a        =load_tf_weights_in_transfo_xl(_snake_case       ,     _snake_case       ,     _snake_case	)
						# Save pytorch-model
						__a        =os.path.join(_snake_case       ,     _snake_case	)
						__a        =os.path.join(_snake_case       ,     _snake_case	)
						print(F'Save PyTorch model to {os.path.abspath(_snake_case	)}'	)
						torch.save(model.state_dict()       ,     _snake_case	)
						print(F'Save configuration file to {os.path.abspath(_snake_case	)}'	)
						with open(_snake_case       ,     'w'       ,     encoding='utf-8'	) as f:
									f.write(config.to_json_string()	)


if __name__ == "__main__":
						_lowerCAmelCase					:			Optional[int]  				=			argparse.ArgumentParser()
						parser.add_argument(
						    "--pytorch_dump_folder_path",
						    default=None,
						    type=str,
						    required=True,
						    help="Path to the folder to store the PyTorch model or dataset/vocab.",
						)
						parser.add_argument(
						    "--tf_checkpoint_path",
						    default="",
						    type=str,
						    help="An optional path to a TensorFlow checkpoint path to be converted.",
						)
						parser.add_argument(
						    "--transfo_xl_config_file",
						    default="",
						    type=str,
						    help=(
						        "An optional config json file corresponding to the pre-trained BERT model. \n"
						        "This specifies the model architecture."
						    ),
						)
						parser.add_argument(
						    "--transfo_xl_dataset_file",
						    default="",
						    type=str,
						    help="An optional dataset file to be converted in a vocabulary.",
						)
						_lowerCAmelCase					:			List[str]  				=			parser.parse_args()
						convert_transfo_xl_checkpoint_to_pytorch(
						    args.tf_checkpoint_path,
						    args.transfo_xl_config_file,
						    args.pytorch_dump_folder_path,
						    args.transfo_xl_dataset_file,
						)









from __future__ import annotations






def        UpperCamelCase_(							_snake_case   :  int	):




			"""simple docstring"""






			__a        =str(_snake_case	)
			return len(_snake_case	) == 9 and set(_snake_case	) == set('123456789'	)






def        UpperCamelCase_(							):




			"""simple docstring"""






			for base_num in range(9999       ,     4999       ,     -1	):
						__a        =100002 * base_num
						if is_9_pandigital(_snake_case	):
									return candidate

			for base_num in range(333       ,     99       ,     -1	):
						__a        =1002003 * base_num
						if is_9_pandigital(_snake_case	):
									return candidate

			return None


if __name__ == "__main__":
						print(f'''{solution() = }''')






