


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
snake_case							: Optional[Any]      =   data_utils.TransfoXLTokenizer
snake_case							: Dict      =   data_utils.TransfoXLCorpus
snake_case							: Optional[Any]      =   data_utils
snake_case							: str      =   data_utils






def 							__lowercase     (				__lowerCAmelCase							:       Any      ,					__lowerCAmelCase							:       str      ,					__lowerCAmelCase							:       Any      ,					__lowerCAmelCase							:       List[Any]     ):
							if transfo_xl_dataset_file:
														# Convert a pre-processed corpus (see original TensorFlow repo)
														with open(__lowerCAmelCase      ,					'rb'     ) as fp:
																					a__    =  pickle.load(__lowerCAmelCase      ,					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(__lowerCAmelCase      ,					__lowerCAmelCase     )

														a__    =  corpus.__dict__
														corpus_dict_no_vocab.pop('vocab'      ,					__lowerCAmelCase     )
														a__    =  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
														a__    =  os.path.abspath(__lowerCAmelCase     )
														a__    =  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 == "":
																					a__    =  TransfoXLConfig()
														else:
																					a__    =  TransfoXLConfig.from_json_file(__lowerCAmelCase     )
														print(F'Building PyTorch model from configuration: {config}'     )
														a__    =  TransfoXLLMHeadModel(__lowerCAmelCase     )

														a__    =  load_tf_weights_in_transfo_xl(__lowerCAmelCase      ,					__lowerCAmelCase      ,					__lowerCAmelCase     )
														# Save pytorch-model
														a__    =  os.path.join(__lowerCAmelCase      ,					__lowerCAmelCase     )
														a__    =  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__":
						snake_case							: 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.''',
						)
						snake_case							: 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,
						)








def 							__lowercase     (				__lowerCAmelCase							:       int = 2_0_0     ):
							a__    =  [1, 2, 5, 1_0, 2_0, 5_0, 1_0_0, 2_0_0]
							a__    =  [0] * (pence + 1)
							a__    =  1  # base case: 1 way to make 0 pence

							for coin in coins:
														for i in range(__lowerCAmelCase      ,					pence + 1      ,					1     ):
																					number_of_ways[i] += number_of_ways[i - coin]
							return number_of_ways[pence]


if __name__ == "__main__":
						assert solution(2_00) == 7_36_82




