



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
a_								=       data_utils.TransfoXLTokenizer
a_								=       data_utils.TransfoXLCorpus
a_								=       data_utils
a_								=       data_utils





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

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

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

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

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


if __name__ == "__main__":
  a_								=       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.""",
  )
  a_								=       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,
  )











a_								=       {
    0: """0""",
    1: """1""",
    2: """2""",
    3: """3""",
    4: """4""",
    5: """5""",
    6: """6""",
    7: """7""",
    8: """8""",
    9: """9""",
    10: """a""",
    11: """b""",
    12: """c""",
    13: """d""",
    14: """e""",
    15: """f""",
}





def 		a__      (		_UpperCamelCase      :			float				):
   assert type(_UpperCamelCase				) in (int, float) and decimal == int(_UpperCamelCase				)
   __lowerCamelCase    				=     int(_UpperCamelCase				)
   __lowerCamelCase    				=     ''''''
   __lowerCamelCase    				=     False
   if decimal < 0:
      __lowerCamelCase    				=     True
      decimal *= -1
   while decimal > 0:
      __lowerCamelCase				,__lowerCamelCase    				=     divmod(_UpperCamelCase			,16				)
      __lowerCamelCase    				=     values[remainder] + hexadecimal
   __lowerCamelCase    				=     '''0x''' + hexadecimal
   if negative:
      __lowerCamelCase    				=     '''-''' + hexadecimal
   return hexadecimal


if __name__ == "__main__":
  import doctest

  doctest.testmod()






