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






def 			__UpperCAmelCase    (	lowercase      ,lowercase      ,lowercase      ,lowercase						):







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

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

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

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

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


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


UpperCAmelCase__     						=  {
    """meter""": """m""",
    """kilometer""": """km""",
    """megametre""": """Mm""",
    """gigametre""": """Gm""",
    """terametre""": """Tm""",
    """petametre""": """Pm""",
    """exametre""": """Em""",
    """zettametre""": """Zm""",
    """yottametre""": """Ym""",
}
# Exponent of the factor(meter)
UpperCAmelCase__     						=  {
    """m""": 0,
    """km""": 3,
    """Mm""": 6,
    """Gm""": 9,
    """Tm""": 1_2,
    """Pm""": 1_5,
    """Em""": 1_8,
    """Zm""": 2_1,
    """Ym""": 2_4,
}






def 			__UpperCAmelCase    (	lowercase      ,lowercase      ,lowercase						):







  """simple docstring"""
  _UpperCAmelCase         =					from_type.lower().strip("""s"""						)
  _UpperCAmelCase         =					to_type.lower().strip("""s"""						)

  _UpperCAmelCase         =					UNIT_SYMBOL.get(lowercase      ,lowercase						)
  _UpperCAmelCase         =					UNIT_SYMBOL.get(lowercase      ,lowercase						)

  if from_sanitized not in METRIC_CONVERSION:
    _UpperCAmelCase         =					(
        f'''Invalid \'from_type\' value: {from_type!r}.\n'''
        f'''Conversion abbreviations are: {", ".join(lowercase						)}'''
    )
    raise ValueError(lowercase						)
  if to_sanitized not in METRIC_CONVERSION:
    _UpperCAmelCase         =					(
        f'''Invalid \'to_type\' value: {to_type!r}.\n'''
        f'''Conversion abbreviations are: {", ".join(lowercase						)}'''
    )
    raise ValueError(lowercase						)
  _UpperCAmelCase         =					METRIC_CONVERSION[from_sanitized]
  _UpperCAmelCase         =					METRIC_CONVERSION[to_sanitized]
  _UpperCAmelCase         =					1

  if from_exponent > to_exponent:
    _UpperCAmelCase         =					from_exponent - to_exponent
  else:
    _UpperCAmelCase         =					-(to_exponent - from_exponent)

  return value * pow(10      ,lowercase						)


if __name__ == "__main__":
    from doctest import testmod

    testmod()
