


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        _lowerCamelCase(	lowercase__   , lowercase__   , lowercase__   , lowercase__	)						->	Tuple:

		'''simple docstring'''







		if transfo_xl_dataset_file:
				# Convert a pre-processed corpus (see original TensorFlow repo)
				with open(lowercase__   , 'rb'	) as fp:
						__lowercase=			pickle.load(lowercase__   , 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(lowercase__   , lowercase__	)

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

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

				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(lowercase__	)
				print(F'Building PyTorch model from configuration: {config}'	)
				__lowercase=			TransfoXLLMHeadModel(lowercase__	)

				__lowercase=			load_tf_weights_in_transfo_xl(lowercase__   , lowercase__   , lowercase__	)
				# Save pytorch-model
				__lowercase=			os.path.join(lowercase__   , lowercase__	)
				__lowercase=			os.path.join(lowercase__   , lowercase__	)
				print(F'Save PyTorch model to {os.path.abspath(lowercase__	)}'	)
				torch.save(model.state_dict()   , lowercase__	)
				print(F'Save configuration file to {os.path.abspath(lowercase__	)}'	)
				with open(lowercase__   , '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,
	)










from collections.abc import Sequence







def        _lowerCamelCase(	lowercase__   , lowercase__ = False	)						->	float:

		'''simple docstring'''







		if not arr:
				return 0

		__lowercase=			0 if allow_empty_subarrays else float('-inf'	)
		__lowercase=			0.0
		for num in arr:
				__lowercase=			max(0 if allow_empty_subarrays else num   , curr_sum + num	)
				__lowercase=			max(lowercase__   , lowercase__	)

		return max_sum


if __name__ == "__main__":
	from doctest import testmod

	testmod()

	lowerCAmelCase           =		[-2, 1, -3, 4, -1, 2, 1, -5, 4]
	print(F'{max_subarray_sum(nums) = }')






