

'''simple docstring'''





import importlib.metadata
import operator
import re
import sys
from typing import Optional

from packaging import version


lowerCamelCase      				=     {
    '''<''': operator.lt,
    '''<=''': operator.le,
    '''==''': operator.eq,
    '''!=''': operator.ne,
    '''>=''': operator.ge,
    '''>''': operator.gt,
}


def        __lowercase    (  UpperCAmelCase__		,					UpperCAmelCase__		,					UpperCAmelCase__		,					UpperCAmelCase__		,					UpperCAmelCase__		,					UpperCAmelCase__      ):

					"""simple docstring"""






					if got_ver is None or want_ver is None:
										raise ValueError(
										    F"""Unable to compare versions for {requirement}: need={want_ver} found={got_ver}. This is unusual. Consider"""
										    F""" reinstalling {pkg}."""      )
					if not ops[op](version.parse(UpperCAmelCase__      )		,					version.parse(UpperCAmelCase__      )      ):
										raise ImportError(
										    F"""{requirement} is required for a normal functioning of this module, but found {pkg}=={got_ver}.{hint}"""      )


def        __lowercase    (  UpperCAmelCase__		,					UpperCAmelCase__ = None      ):

					"""simple docstring"""






					__lowerCAmelCase					=							F"""\n{hint}""" if hint is not None else ''

					# non-versioned check
					if re.match(R'^[\w_\-\d]+$'		,					UpperCAmelCase__      ):
										__lowerCAmelCase,	__lowerCAmelCase,	__lowerCAmelCase					=							requirement, None, None
					else:
										__lowerCAmelCase					=							re.findall(R'^([^!=<>\s]+)([\s!=<>]{1,2}.+)'		,					UpperCAmelCase__      )
										if not match:
															raise ValueError(
															    'requirement needs to be in the pip package format, .e.g., package_a==1.23, or package_b>=1.23, but'
															    F""" got {requirement}"""      )
										__lowerCAmelCase,	__lowerCAmelCase					=							match[0]
										__lowerCAmelCase					=							want_full.split(','      )  # there could be multiple requirements
										__lowerCAmelCase					=							{}
										for w in want_range:
															__lowerCAmelCase					=							re.findall(R'^([\s!=<>]{1,2})(.+)'		,					UpperCAmelCase__      )
															if not match:
																				raise ValueError(
																				    'requirement needs to be in the pip package format, .e.g., package_a==1.23, or package_b>=1.23,'
																				    F""" but got {requirement}"""      )
															__lowerCAmelCase,	__lowerCAmelCase					=							match[0]
															__lowerCAmelCase					=							want_ver
															if op not in ops:
																				raise ValueError(F"""{requirement}: need one of {list(ops.keys()      )}, but got {op}"""      )

    # special case
					if pkg == "python":
										__lowerCAmelCase					=							'.'.join([str(UpperCAmelCase__      ) for x in sys.version_info[:3]]      )
										for op, want_ver in wanted.items():
															_compare_versions(UpperCAmelCase__		,					UpperCAmelCase__		,					UpperCAmelCase__		,					UpperCAmelCase__		,					UpperCAmelCase__		,					UpperCAmelCase__      )
										return

					# check if any version is installed
					try:
										__lowerCAmelCase					=							importlib.metadata.version(UpperCAmelCase__      )
					except importlib.metadata.PackageNotFoundError:
										raise importlib.metadata.PackageNotFoundError(
										    F"""The '{requirement}' distribution was not found and is required by this application. {hint}"""      )

					# check that the right version is installed if version number or a range was provided
					if want_ver is not None:
										for op, want_ver in wanted.items():
															_compare_versions(UpperCAmelCase__		,					UpperCAmelCase__		,					UpperCAmelCase__		,					UpperCAmelCase__		,					UpperCAmelCase__		,					UpperCAmelCase__      )


def        __lowercase    (  UpperCAmelCase__      ):

					"""simple docstring"""






					__lowerCAmelCase					=							'Try: pip install transformers -U or pip install -e \'.[dev]\' if you\'re working with git main'
					return require_version(UpperCAmelCase__		,					UpperCAmelCase__      )









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


def        __lowercase    (  UpperCAmelCase__		,					UpperCAmelCase__		,					UpperCAmelCase__		,					UpperCAmelCase__      ):

					"""simple docstring"""






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

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

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

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

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


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






