


"""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
__SCREAMING_SNAKE_CASE							:    List[str]		=    data_utils.TransfoXLTokenizer
__SCREAMING_SNAKE_CASE							:    Optional[int]		=    data_utils.TransfoXLCorpus
__SCREAMING_SNAKE_CASE							:    Optional[int]		=    data_utils
__SCREAMING_SNAKE_CASE							:    int		=    data_utils







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

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

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

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

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


if __name__ == "__main__":
						__SCREAMING_SNAKE_CASE							:    List[str]		=    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							:    Union[str, 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 math import factorial







def 						_a				(      _SCREAMING_SNAKE_CASE = 20				)    ->				int:
							snake_case_           =		2 * n  # middle entry of odd rows starting at row 3 is the solution for n = 1,
							# 2, 3,...
							snake_case_           =		n // 2

							return int(factorial(_SCREAMING_SNAKE_CASE				) / (factorial(_SCREAMING_SNAKE_CASE				) * factorial(n - k				))				)


if __name__ == "__main__":
				import sys

				if len(sys.argv) == 1:
								print(solution(20))
				else:
								try:
												__SCREAMING_SNAKE_CASE							:    Optional[int]		=    int(sys.argv[1])
												print(solution(n))
								except ValueError:
												print('Invalid entry - please enter a number.')



