





"""simple docstring"""




import functools
import logging
import os
import sys
import threading
from logging import (
    CRITICAL,  # NOQA
    DEBUG,  # NOQA
    ERROR,  # NOQA
    FATAL,  # NOQA
    INFO,  # NOQA
    NOTSET,  # NOQA
    WARN,  # NOQA
    WARNING,  # NOQA
)
from typing import Optional

import huggingface_hub.utils as hf_hub_utils
from tqdm import auto as tqdm_lib


lowercase				:	Dict      						=  threading.Lock()
lowercase				:	Optional[logging.Handler]      						=  None

lowercase				:	Tuple      						=  {
    """debug""": logging.DEBUG,
    """info""": logging.INFO,
    """warning""": logging.WARNING,
    """error""": logging.ERROR,
    """critical""": logging.CRITICAL,
}

lowercase				:	List[Any]      						=  logging.WARNING

lowercase				:	Optional[int]      						=  True



def A_     (		)  ->		Optional[Any]:
       a__						:     Dict			=    os.getenv('TRANSFORMERS_VERBOSITY'		,				A__    )
       if env_level_str:
              if env_level_str in log_levels:
                     return log_levels[env_level_str]
              else:
                     logging.getLogger().warning(
                         F'Unknown option TRANSFORMERS_VERBOSITY={env_level_str}, '
                         F'has to be one of: { ", ".join(log_levels.keys()    ) }'    )
       return _default_log_level



def A_     (		)  ->		str:
       return __name__.split('.'    )[0]



def A_     (		)  ->		logging.Logger:
       return logging.getLogger(_get_library_name()    )



def A_     (		)  ->		None:
       global _default_handler

       with _lock:
              if _default_handler:
                     # This library has already configured the library root logger.
                     return
              a__						:     Tuple			=    logging.StreamHandler()  # Set sys.stderr as stream.
              a__						:     Union[str, Any]			=    sys.stderr.flush

              # Apply our default configuration to the library root logger.
              a__						:     Any			=    _get_library_root_logger()
              library_root_logger.addHandler(_default_handler    )
              library_root_logger.setLevel(_get_default_logging_level()    )
              a__						:     List[Any]			=    False



def A_     (		)  ->		None:
       global _default_handler

       with _lock:
              if not _default_handler:
                     return

              a__						:     Tuple			=    _get_library_root_logger()
              library_root_logger.removeHandler(_default_handler    )
              library_root_logger.setLevel(logging.NOTSET    )
              a__						:     List[Any]			=    None



def A_     (		)  ->		int:
       return log_levels



def A_     (		A__ = None    )  ->		logging.Logger:

       if name is None:
              a__						:     Tuple			=    _get_library_name()

       _configure_library_root_logger()
       return logging.getLogger(A__    )



def A_     (		)  ->		int:
       _configure_library_root_logger()
       return _get_library_root_logger().getEffectiveLevel()



def A_     (		A__    )  ->		None:
       _configure_library_root_logger()
       _get_library_root_logger().setLevel(A__    )



def A_     (		)  ->		List[str]:
       return set_verbosity(A__    )



def A_     (		)  ->		Tuple:
       return set_verbosity(A__    )



def A_     (		)  ->		List[str]:
       return set_verbosity(A__    )



def A_     (		)  ->		List[Any]:
       return set_verbosity(A__    )



def A_     (		)  ->		None:
       _configure_library_root_logger()

       assert _default_handler is not None
       _get_library_root_logger().removeHandler(_default_handler    )



def A_     (		)  ->		None:
       _configure_library_root_logger()

       assert _default_handler is not None
       _get_library_root_logger().addHandler(_default_handler    )



def A_     (		A__    )  ->		None:
       _configure_library_root_logger()

       assert handler is not None
       _get_library_root_logger().addHandler(A__    )



def A_     (		A__    )  ->		None:
       _configure_library_root_logger()

       assert handler is not None and handler not in _get_library_root_logger().handlers
       _get_library_root_logger().removeHandler(A__    )



def A_     (		)  ->		None:
       _configure_library_root_logger()
       a__						:     Dict			=    False



def A_     (		)  ->		None:
       _configure_library_root_logger()
       a__						:     List[str]			=    True



def A_     (		)  ->		None:
       a__						:     List[str]			=    _get_library_root_logger().handlers

       for handler in handlers:
              a__						:     int			=    logging.Formatter('[%(levelname)s|%(filename)s:%(lineno)s] %(asctime)s >> %(message)s'    )
              handler.setFormatter(A__    )



def A_     (		)  ->		None:
       a__						:     Dict			=    _get_library_root_logger().handlers

       for handler in handlers:
              handler.setFormatter(A__    )



def A_     (		self		,				*A__		,				**A__    )  ->		str:
       a__						:     Optional[Any]			=    os.getenv('TRANSFORMERS_NO_ADVISORY_WARNINGS'		,				A__    )
       if no_advisory_warnings:
              return
       self.warning(*A__		,				**A__    )


lowercase				:	List[str]      						=  warning_advice



@functools.lru_cache(A__    )
def A_     (		self		,				*A__		,				**A__    )  ->		Dict:
       self.warning(*A__		,				**A__    )


lowercase				:	List[str]      						=  warning_once





class 			A__   :




   """simple docstring"""



   def __init__( self ,  *lowercase ,  **lowercase)      ->						Dict:  # pylint: disable=unused-argument







          '''simple docstring'''

          a__						:     List[str]			=    args[0] if args else None

   def __iter__( self)      ->						Optional[int]:







          '''simple docstring'''

          return iter(self._iterator)

   def __getattr__( self ,  lowercase)      ->						str:







          '''simple docstring'''

          def empty_fn(*lowercase ,  **lowercase):  # pylint: disable=unused-argument
                 return

          return empty_fn

   def __enter__( self)      ->						Any:







          '''simple docstring'''

          return self

   def __exit__( self ,  lowercase ,  lowercase ,  lowercase)      ->						List[str]:







          '''simple docstring'''

          return





class 			A__   :




   """simple docstring"""



   def __call__( self ,  *lowercase ,  **lowercase)      ->						List[str]:







          '''simple docstring'''

          if _tqdm_active:
                 return tqdm_lib.tqdm(*lowercase ,  **lowercase)
          else:
                 return EmptyTqdm(*lowercase ,  **lowercase)

   def 							__lowercase		( self ,  *lowercase ,  **lowercase)      ->						List[str]:







          '''simple docstring'''

          a__						:     Tuple			=    None
          if _tqdm_active:
                 return tqdm_lib.tqdm.set_lock(*lowercase ,  **lowercase)

   def 							__lowercase		( self)      ->						int:







          '''simple docstring'''

          if _tqdm_active:
                 return tqdm_lib.tqdm.get_lock()

lowercase				:	Optional[Any]      						=  _tqdm_cls()



def A_     (		)  ->		bool:
       global _tqdm_active
       return bool(_tqdm_active    )



def A_     (		)  ->		Union[str, Any]:
       global _tqdm_active
       a__						:     int			=    True
       hf_hub_utils.enable_progress_bars()



def A_     (		)  ->		Union[str, Any]:
       global _tqdm_active
       a__						:     List[Any]			=    False
       hf_hub_utils.disable_progress_bars()









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				:	Union[str, Any]      						=  data_utils.TransfoXLTokenizer
lowercase				:	Optional[int]      						=  data_utils.TransfoXLCorpus
lowercase				:	List[Any]      						=  data_utils
lowercase				:	Tuple      						=  data_utils



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

              a__						:     Dict			=    corpus.__dict__
              corpus_dict_no_vocab.pop('vocab'		,				A__    )
              a__						:     Optional[int]			=    pytorch_dump_folder_path + '/' + CORPUS_NAME
              print(F'Save dataset to {pytorch_dataset_dump_path}'    )
              torch.save(A__		,				A__    )

       if tf_checkpoint_path:
              # Convert a pre-trained TensorFlow model
              a__						:     Union[str, Any]			=    os.path.abspath(A__    )
              a__						:     Optional[Any]			=    os.path.abspath(A__    )

              print(F'Converting Transformer XL checkpoint from {tf_path} with config at {config_path}.'    )
              # Initialise PyTorch model
              if transfo_xl_config_file == "":
                     a__						:     Dict			=    TransfoXLConfig()
              else:
                     a__						:     Dict			=    TransfoXLConfig.from_json_file(A__    )
              print(F'Building PyTorch model from configuration: {config}'    )
              a__						:     Optional[int]			=    TransfoXLLMHeadModel(A__    )

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


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


