




'''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
_snake_case   :   int     							=	data_utils.TransfoXLTokenizer
_snake_case   :   str     							=	data_utils.TransfoXLCorpus
_snake_case   :   int     							=	data_utils
_snake_case   :   Union[str, Any]     							=	data_utils
def 	snake_case_					(UpperCamelCase :						Optional[int]				,		UpperCamelCase :						Tuple				,		UpperCamelCase :						Tuple				,		UpperCamelCase :						int   ):





							'''simple docstring'''


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

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

														_a			  =       load_tf_weights_in_transfo_xl(UpperCamelCase				,		UpperCamelCase				,		UpperCamelCase   )
														# Save pytorch-model
														_a			  =       os.path.join(UpperCamelCase				,		UpperCamelCase   )
														_a			  =       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__":
				_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.',
				)
				_snake_case   :   Tuple     							=	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'''


_snake_case   :   Any     							=	tuple[float, float, float]
_snake_case   :   Optional[int]     							=	tuple[float, float, float]
def 	snake_case_					(UpperCamelCase :						Pointad				,		UpperCamelCase :						Pointad   ):





							'''simple docstring'''


							_a			  =       end_pointa[0] - end_pointa[0]
							_a			  =       end_pointa[1] - end_pointa[1]
							_a			  =       end_pointa[2] - end_pointa[2]
							return (x, y, z)
def 	snake_case_					(UpperCamelCase :						Vectorad				,		UpperCamelCase :						Vectorad   ):





							'''simple docstring'''


							_a			  =       ab[1] * ac[2] - ab[2] * ac[1]  # *i
							_a			  =       (ab[0] * ac[2] - ab[2] * ac[0]) * -1  # *j
							_a			  =       ab[0] * ac[1] - ab[1] * ac[0]  # *k
							return (x, y, z)
def 	snake_case_					(UpperCamelCase :						Vectorad				,		UpperCamelCase :						int   ):





							'''simple docstring'''


							return tuple(round(UpperCamelCase				,		UpperCamelCase   ) for x in vector   ) == (0, 0, 0)

def 	snake_case_					(UpperCamelCase :						Pointad				,		UpperCamelCase :						Pointad				,		UpperCamelCase :						Pointad				,		UpperCamelCase :						int = 10   ):





							'''simple docstring'''


							_a			  =       create_vector(UpperCamelCase				,		UpperCamelCase   )
							_a			  =       create_vector(UpperCamelCase				,		UpperCamelCase   )
							return is_zero_vector(get_ad_vectors_cross(UpperCamelCase				,		UpperCamelCase   )				,		UpperCamelCase   )

