





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







def  a__    (    lowercase :					Union[str, Any], lowercase :					Any, lowercase :					List[Any], lowercase :					str				)		->		Dict:





     """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__":
   lowercase__						:      Optional[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__						:      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,
   )










'''simple docstring'''

import math







def  a__    (    lowercase :					float, lowercase :					float				)		->		float:





     """simple docstring"""

     if initial_intensity < 0:
          raise ValueError('''The value of intensity cannot be negative'''				)
          # handling of negative values of initial intensity
     if angle < 0 or angle > 360:
          raise ValueError('''In Malus Law, the angle is in the range 0-360 degrees'''				)
          # handling of values out of allowed range
     return initial_intensity * (math.cos(math.radians(lowercase				)				) ** 2)


if __name__ == "__main__":
   import doctest

   doctest.testmod(name='malus_law')



