'''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_:     str  =data_utils.TransfoXLCorpus
SCREAMING_SNAKE_CASE_:     List[str]  =data_utils
SCREAMING_SNAKE_CASE_:     Optional[Any]  =data_utils





def 	lowerCAmelCase_				(					snake_case_       : Optional[int]					,    snake_case_       : List[Any]					,    snake_case_       : Union[str, Any]					,    snake_case_       : int			)    ->      Optional[Any]:


     '''simple docstring'''




     if transfo_xl_dataset_file:
          # Convert a pre-processed corpus (see original TensorFlow repo)
          with open(snake_case_					,    "rb"			) as fp:
               UpperCAmelCase_           =   pickle.load(snake_case_					,    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(snake_case_					,    snake_case_			)

          UpperCAmelCase_           =   corpus.__dict__
          corpus_dict_no_vocab.pop("vocab"					,    snake_case_			)
          UpperCAmelCase_           =   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
          UpperCAmelCase_           =   os.path.abspath(snake_case_			)
          UpperCAmelCase_           =   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 == "":
               UpperCAmelCase_           =   TransfoXLConfig()
          else:
               UpperCAmelCase_           =   TransfoXLConfig.from_json_file(snake_case_			)
          print(f"""Building PyTorch model from configuration: {config}"""			)
          UpperCAmelCase_           =   TransfoXLLMHeadModel(snake_case_			)

          UpperCAmelCase_           =   load_tf_weights_in_transfo_xl(snake_case_					,    snake_case_					,    snake_case_			)
          # Save pytorch-model
          UpperCAmelCase_           =   os.path.join(snake_case_					,    snake_case_			)
          UpperCAmelCase_           =   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__":
    SCREAMING_SNAKE_CASE_:     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_:     Dict  =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'''





def 	lowerCAmelCase_				(					snake_case_       : int					,    snake_case_       : int			)    ->      str:


     '''simple docstring'''




     if a < 0 or b < 0:
          raise ValueError("the value of both inputs must be positive"			)
     UpperCAmelCase_           =   str(bin(snake_case_			)			)[2:]  # remove the leading "0b"
     UpperCAmelCase_           =   str(bin(snake_case_			)			)[2:]
     UpperCAmelCase_           =   max(len(snake_case_			)					,    len(snake_case_			)			)
     return "0b" + "".join(
         str(int("1" in (char_a, char_b)			)			)
         for char_a, char_b in zip(a_binary.zfill(snake_case_			)					,    b_binary.zfill(snake_case_			)			)			)


if __name__ == "__main__":
    import doctest

    doctest.testmod()




