



'''simple docstring'''




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
UpperCamelCase__       :	List[str]    = data_utils.TransfoXLTokenizer
UpperCamelCase__       :	Dict    = data_utils.TransfoXLCorpus
UpperCamelCase__       :	Dict    = data_utils
UpperCamelCase__       :	str    = data_utils


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

				__SCREAMING_SNAKE_CASE       :		List[str]           =		corpus.__dict__
				corpus_dict_no_vocab.pop("""vocab"""       ,      _lowerCamelCase					)
				__SCREAMING_SNAKE_CASE       :		Optional[Any]           =		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
				__SCREAMING_SNAKE_CASE       :		Dict           =		os.path.abspath(_lowerCamelCase					)
				__SCREAMING_SNAKE_CASE       :		Tuple           =		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 == "":
						__SCREAMING_SNAKE_CASE       :		Any           =		TransfoXLConfig()
				else:
						__SCREAMING_SNAKE_CASE       :		str           =		TransfoXLConfig.from_json_file(_lowerCamelCase					)
				print(F"Building PyTorch model from configuration: {config}"					)
				__SCREAMING_SNAKE_CASE       :		Union[str, Any]           =		TransfoXLLMHeadModel(_lowerCamelCase					)

				__SCREAMING_SNAKE_CASE       :		int           =		load_tf_weights_in_transfo_xl(_lowerCamelCase       ,      _lowerCamelCase       ,      _lowerCamelCase					)
				# Save pytorch-model
				__SCREAMING_SNAKE_CASE       :		Optional[int]           =		os.path.join(_lowerCamelCase       ,      _lowerCamelCase					)
				__SCREAMING_SNAKE_CASE       :		Optional[Any]           =		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__":
						UpperCamelCase__       :	List[Any]    = 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.''',
						)
						UpperCamelCase__       :	Optional[Any]    = 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'''




from __future__ import annotations


def 				lowerCAmelCase_   (	_lowerCamelCase:   list[int]					):
		if not nums:
				return 0
		__SCREAMING_SNAKE_CASE       :		Optional[int]           =		nums[0]
		__SCREAMING_SNAKE_CASE       :		Union[str, Any]           =		0
		for num in nums[1:]:
				__SCREAMING_SNAKE_CASE       ,						__SCREAMING_SNAKE_CASE       :		Any           =		(
				    max_excluding + num,
				    max(_lowerCamelCase       ,      _lowerCamelCase					),
				)
		return max(_lowerCamelCase       ,      _lowerCamelCase					)


if __name__ == "__main__":
						import doctest

						doctest.testmod()