'''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       :     Dict     =  data_utils.TransfoXLTokenizer
__SCREAMING_SNAKE_CASE       :     List[str]     =  data_utils.TransfoXLCorpus
__SCREAMING_SNAKE_CASE       :     str     =  data_utils
__SCREAMING_SNAKE_CASE       :     Union[str, Any]     =  data_utils

def 	UpperCamelCase_							(					_UpperCAmelCase  :      str			,	_UpperCAmelCase  :      Optional[Any]			,	_UpperCAmelCase  :      int			,	_UpperCAmelCase  :      Tuple    )    ->    Any:


       """simple docstring"""







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

              _UpperCAmelCase     :  str							      =    corpus.__dict__
              corpus_dict_no_vocab.pop("vocab"			,	_UpperCAmelCase    )
              _UpperCAmelCase     :  int							      =    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
              _UpperCAmelCase     :  Tuple							      =    os.path.abspath(_UpperCAmelCase    )
              _UpperCAmelCase     :  Union[str, Any]							      =    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 == "":
                     _UpperCAmelCase     :  Tuple							      =    TransfoXLConfig()
              else:
                     _UpperCAmelCase     :  Union[str, Any]							      =    TransfoXLConfig.from_json_file(_UpperCAmelCase    )
              print(F"""Building PyTorch model from configuration: {config}"""    )
              _UpperCAmelCase     :  Any							      =    TransfoXLLMHeadModel(_UpperCAmelCase    )

              _UpperCAmelCase     :  Tuple							      =    load_tf_weights_in_transfo_xl(_UpperCAmelCase			,	_UpperCAmelCase			,	_UpperCAmelCase    )
              # Save pytorch-model
              _UpperCAmelCase     :  Any							      =    os.path.join(_UpperCAmelCase			,	_UpperCAmelCase    )
              _UpperCAmelCase     :  List[Any]							      =    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__":
  __SCREAMING_SNAKE_CASE       :     Union[str, 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.""",
  )
  __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 functools import lru_cache




@lru_cache
def __lowercase			(							_a    ):
    if num < 0:
        raise ValueError('''Number should not be negative.'''    )

    return 1 if num in (0, 1) else num * factorial(num - 1    )


if __name__ == "__main__":
     import doctest

     doctest.testmod()





