



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






def  lowerCamelCase_	(      lowerCAmelCase__	:	Optional[int]			,	lowerCAmelCase__	:	Optional[int]			,	lowerCAmelCase__	:	Tuple			,	lowerCAmelCase__	:	Any				)       ->							Tuple:

							'''simple docstring'''






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

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

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

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

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


if __name__ == "__main__":
				__snake_case     :Tuple			       =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.',
				)
				__snake_case     :Optional[int]			       =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,
				)







from collections.abc import Callable




class       snake_case__ :

       '''simple docstring'''



       def __init__(				self      ,    a__ = None     )			->   None:






            '''simple docstring'''





            __snake_case      :list 							=    []
            # Stores indexes of each item for supporting updates and deletion.
            __snake_case      :dict 							=    {}
            # Stores current size of heap.
            __snake_case      :List[Any] 							=    0
            # Stores function used to evaluate the score of an item on which basis ordering
            # will be done.
            __snake_case      :Optional[Any] 							=    key or (lambda a__     : x)



       def        __lowercase    (				self      ,    a__     )			->   int | None:






            '''simple docstring'''





            return int((i - 1) / 2     ) if i > 0 else None



       def        __lowercase    (				self      ,    a__     )			->   int | None:






            '''simple docstring'''





            __snake_case      :int 							=    int(2 * i + 1     )
            return left if 0 < left < self.size else None



       def        __lowercase    (				self      ,    a__     )			->   int | None:






            '''simple docstring'''





            __snake_case      :Optional[int] 							=    int(2 * i + 2     )
            return right if 0 < right < self.size else None



       def        __lowercase    (				self      ,    a__      ,    a__     )			->   None:






            '''simple docstring'''





            __snake_case							,			__snake_case      :Dict 							=    (
                self.pos_map[self.arr[j][0]],
                self.pos_map[self.arr[i][0]],
            )
            # Then swap the items in the list.
            __snake_case							,			__snake_case      :Tuple 							=    self.arr[j], self.arr[i]



       def        __lowercase    (				self      ,    a__      ,    a__     )			->   bool:






            '''simple docstring'''





            return self.arr[i][1] < self.arr[j][1]



       def        __lowercase    (				self      ,    a__     )			->   int:






            '''simple docstring'''





            __snake_case      :int 							=    self._left(a__     )
            __snake_case      :Optional[int] 							=    self._right(a__     )
            __snake_case      :List[Any] 							=    i

            if left is not None and not self._cmp(a__      ,    a__     ):
                 __snake_case      :int 							=    left
            if right is not None and not self._cmp(a__      ,    a__     ):
                 __snake_case      :Tuple 							=    right

            return valid_parent



       def        __lowercase    (				self      ,    a__     )			->   None:






            '''simple docstring'''





            __snake_case      :int 							=    self._parent(a__     )
            while parent is not None and not self._cmp(a__      ,    a__     ):
                 self._swap(a__      ,    a__     )
                 __snake_case							,			__snake_case      :str 							=    parent, self._parent(a__     )



       def        __lowercase    (				self      ,    a__     )			->   None:






            '''simple docstring'''





            __snake_case      :List[Any] 							=    self._get_valid_parent(a__     )
            while valid_parent != index:
                 self._swap(a__      ,    a__     )
                 __snake_case							,			__snake_case      :Optional[int] 							=    valid_parent, self._get_valid_parent(a__     )



       def        __lowercase    (				self      ,    a__      ,    a__     )			->   None:






            '''simple docstring'''





            if item not in self.pos_map:
                 return
            __snake_case      :List[Any] 							=    self.pos_map[item]
            __snake_case      :Optional[Any] 							=    [item, self.key(a__     )]
            # Make sure heap is right in both up and down direction.
            # Ideally only one of them will make any change.
            self._heapify_up(a__     )
            self._heapify_down(a__     )



       def        __lowercase    (				self      ,    a__     )			->   None:






            '''simple docstring'''





            if item not in self.pos_map:
                 return
            __snake_case      :Dict 							=    self.pos_map[item]
            del self.pos_map[item]
            __snake_case      :Dict 							=    self.arr[self.size - 1]
            __snake_case      :List[str] 							=    index
            self.size -= 1
            # Make sure heap is right in both up and down direction. Ideally only one
            # of them will make any change- so no performance loss in calling both.
            if self.size > index:
                 self._heapify_up(a__     )
                 self._heapify_down(a__     )



       def        __lowercase    (				self      ,    a__      ,    a__     )			->   None:






            '''simple docstring'''





            __snake_case      :Optional[int] 							=    len(self.arr     )
            if arr_len == self.size:
                 self.arr.append([item, self.key(a__     )]     )
            else:
                 __snake_case      :Optional[Any] 							=    [item, self.key(a__     )]
            __snake_case      :str 							=    self.size
            self.size += 1
            self._heapify_up(self.size - 1     )



       def        __lowercase    (				self     )			->   tuple | None:






            '''simple docstring'''





            return self.arr[0] if self.size else None



       def        __lowercase    (				self     )			->   tuple | None:






            '''simple docstring'''





            __snake_case      :Optional[Any] 							=    self.get_top()
            if top_item_tuple:
                 self.delete_item(top_item_tuple[0]     )
            return top_item_tuple






def 	UpperCamelCase	(							):




     '''simple docstring'''








if __name__ == "__main__":
     import doctest

     doctest.testmod()


