





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
_SCREAMING_SNAKE_CASE					=    data_utils.TransfoXLTokenizer
_SCREAMING_SNAKE_CASE					=    data_utils.TransfoXLCorpus
_SCREAMING_SNAKE_CASE					=    data_utils
_SCREAMING_SNAKE_CASE					=    data_utils




def    _lowerCAmelCase						(				lowerCamelCase_			:  int		,       lowerCamelCase_			:  str		,       lowerCamelCase_			:  Dict		,       lowerCamelCase_			:  Tuple				):





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

						__lowercase										=							corpus.__dict__
						corpus_dict_no_vocab.pop('''vocab'''		,       _lowerCamelCase				)
						__lowercase										=							pytorch_dump_folder_path + "/" + CORPUS_NAME
						print(f"Save dataset to {pytorch_dataset_dump_path}"				)
						torch.save(_lowerCamelCase		,       _lowerCamelCase				)

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

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

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


if __name__ == "__main__":
	_SCREAMING_SNAKE_CASE					=    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.''',
	)
	_SCREAMING_SNAKE_CASE					=    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,
	)












'''simple docstring'''



import math




def    _lowerCAmelCase						(				lowerCamelCase_			:  int				):
			assert isinstance(lowerCamelCase_		,       lowerCamelCase_				) and (
			    number >= 0
			), "'number' must been an int and positive"

			if 1 < number < 4:
						# 2 and 3 are primes
						return True
			elif number < 2 or not number % 2:
						# Negatives, 0, 1 and all even numbers are not primes
						return False

			__lowercase										=							range(3		,       int(math.sqrt(lowerCamelCase_				) + 1				)		,       2				)
			return not any(not number % i for i in odd_numbers				)




def    _lowerCAmelCase						(				lowerCamelCase_			:  Dict		,       lowerCamelCase_			:  Any=1		,       **lowerCamelCase_			:  Tuple				):
			__lowercase										=							factor * value
			__lowercase										=							value

			while not is_prime(lowerCamelCase_				):
						value += 1 if not ("desc" in kwargs and kwargs["desc"] is True) else -1

			if value == first_value_val:
						return next_prime(value + 1		,       **lowerCamelCase_				)
			return value





