


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
lowercase_	   =     data_utils.TransfoXLTokenizer
lowercase_	   =     data_utils.TransfoXLCorpus
lowercase_	   =     data_utils
lowercase_	   =     data_utils
def 				UpperCamelCase__					(  SCREAMING_SNAKE_CASE__      ,	SCREAMING_SNAKE_CASE__      ,	SCREAMING_SNAKE_CASE__      ,	SCREAMING_SNAKE_CASE__						):
 if transfo_xl_dataset_file:
  # Convert a pre-processed corpus (see original TensorFlow repo)
  with open(snake_case__      ,	'rb'						) as fp:
   __lowerCamelCase		:							int		 =						pickle.load(snake_case__      ,	encoding='latin1'						)
  # Save vocabulary and dataset cache as Dictionaries (should be better than pickles for the long-term)
  __lowerCamelCase		:							List[Any]		 =						pytorch_dump_folder_path + '/' + VOCAB_FILES_NAMES['pretrained_vocab_file']
  print(f'Save vocabulary to {pytorch_vocab_dump_path}'						)
  __lowerCamelCase		:							Union[str, Any]		 =						corpus.vocab.__dict__
  torch.save(snake_case__      ,	snake_case__						)

  __lowerCamelCase		:							List[Any]		 =						corpus.__dict__
  corpus_dict_no_vocab.pop('vocab'      ,	snake_case__						)
  __lowerCamelCase		:							Optional[Any]		 =						pytorch_dump_folder_path + '/' + CORPUS_NAME
  print(f'Save dataset to {pytorch_dataset_dump_path}'						)
  torch.save(snake_case__      ,	snake_case__						)

 if tf_checkpoint_path:
  # Convert a pre-trained TensorFlow model
  __lowerCamelCase		:							Optional[int]		 =						os.path.abspath(snake_case__						)
  __lowerCamelCase		:							Dict		 =						os.path.abspath(snake_case__						)

  print(f'Converting Transformer XL checkpoint from {tf_path} with config at {config_path}.'						)
  # Initialise PyTorch model
  if transfo_xl_config_file == "":
   __lowerCamelCase		:							Dict		 =						TransfoXLConfig()
  else:
   __lowerCamelCase		:							Union[str, Any]		 =						TransfoXLConfig.from_json_file(snake_case__						)
  print(f'Building PyTorch model from configuration: {config}'						)
  __lowerCamelCase		:							List[str]		 =						TransfoXLLMHeadModel(snake_case__						)

  __lowerCamelCase		:							Optional[int]		 =						load_tf_weights_in_transfo_xl(snake_case__      ,	snake_case__      ,	snake_case__						)
  # Save pytorch-model
  __lowerCamelCase		:							Optional[Any]		 =						os.path.join(snake_case__      ,	snake_case__						)
  __lowerCamelCase		:							Any		 =						os.path.join(snake_case__      ,	snake_case__						)
  print(f'Save PyTorch model to {os.path.abspath(snake_case__						)}'						)
  torch.save(model.state_dict()      ,	snake_case__						)
  print(f'Save configuration file to {os.path.abspath(snake_case__						)}'						)
  with open(snake_case__      ,	'w'      ,	encoding='utf-8'						) as f:
   f.write(config.to_json_string()						)


if __name__ == "__main__":
       lowercase_	   =     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.',
       )
       lowercase_	   =     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 math import pow
def 				UpperCamelCase__					(  SCREAMING_SNAKE_CASE__      ,	SCREAMING_SNAKE_CASE__      ,	SCREAMING_SNAKE_CASE__      ,	SCREAMING_SNAKE_CASE__      ,	SCREAMING_SNAKE_CASE__      ,	):
 if current_sum == needed_sum:
  # If the sum of the powers is equal to needed_sum, then we have a solution.
  solutions_count += 1
  return current_sum, solutions_count

 __lowerCamelCase		:							Optional[Any]		 =						int(pow(SCREAMING_SNAKE_CASE__      ,	SCREAMING_SNAKE_CASE__						)						)
 if current_sum + i_to_n <= needed_sum:
  # If the sum of the powers is less than needed_sum, then continue adding powers.
  current_sum += i_to_n
  __lowerCamelCase ,					__lowerCamelCase		:							Optional[Any]		 =						backtrack(
      SCREAMING_SNAKE_CASE__      ,	SCREAMING_SNAKE_CASE__      ,	current_number + 1      ,	SCREAMING_SNAKE_CASE__      ,	SCREAMING_SNAKE_CASE__						)
  current_sum -= i_to_n
 if i_to_n < needed_sum:
  # If the power of i is less than needed_sum, then try with the next power.
  __lowerCamelCase ,					__lowerCamelCase		:							Dict		 =						backtrack(
      SCREAMING_SNAKE_CASE__      ,	SCREAMING_SNAKE_CASE__      ,	current_number + 1      ,	SCREAMING_SNAKE_CASE__      ,	SCREAMING_SNAKE_CASE__						)
 return current_sum, solutions_count
def 				UpperCamelCase__					(  SCREAMING_SNAKE_CASE__      ,	SCREAMING_SNAKE_CASE__						):
 if not (1 <= needed_sum <= 1_000 and 2 <= power <= 10):
  raise ValueError(
      'Invalid input\n'
      'needed_sum must be between 1 and 1000, power between 2 and 10.'						)

 return backtrack(SCREAMING_SNAKE_CASE__      ,	SCREAMING_SNAKE_CASE__      ,	1      ,	0      ,	0						)[1]  # Return the solutions_count


if __name__ == "__main__":
       import doctest

       doctest.testmod()

