




"""simple docstring"""







from typing import List

from .keymap import KEYMAP, get_character





def 				lowercase       (snake_case__ :			Union[str, Any]			)  ->	Union[str, Any]:


				'''simple docstring'''






				def decorator(snake_case__ :			Tuple			):
								lowerCAmelCase						=					getattr(__lowercase   ,							"""handle_key"""   ,							[]			)
								handle += [key]
								setattr(__lowercase   ,							"""handle_key"""   ,							__lowercase			)
								return func

				return decorator





def 				lowercase       (*snake_case__ :			Dict			)  ->	Any:


				'''simple docstring'''






				def decorator(snake_case__ :			Tuple			):
								lowerCAmelCase						=					getattr(__lowercase   ,							"""handle_key"""   ,							[]			)
								handle += keys
								setattr(__lowercase   ,							"""handle_key"""   ,							__lowercase			)
								return func

				return decorator






class    SCREAMING_SNAKE_CASE__       (       UpperCAmelCase__       ):


						def __new__(				cls					:      int    ,    lowerCAmelCase					:      List[str]    ,    lowerCAmelCase					:      List[Any]    ,    lowerCAmelCase					:      List[Any]       ):
										lowerCAmelCase						=					super().__new__(cls    ,    _UpperCAmelCase    ,    _UpperCAmelCase    ,    _UpperCAmelCase       )
										if not hasattr(_UpperCAmelCase    ,    """key_handler"""       ):
														setattr(_UpperCAmelCase    ,    """key_handler"""    ,    {}       )
										setattr(_UpperCAmelCase    ,    """handle_input"""    ,    KeyHandler.handle_input       )

										for value in attrs.values():
														lowerCAmelCase						=					getattr(_UpperCAmelCase    ,    """handle_key"""    ,    []       )
														for key in handled_keys:
																		lowerCAmelCase						=					value
										return new_cls




						@staticmethod
						def 	__lowercase			(				cls					:      Tuple       ):
										lowerCAmelCase						=					get_character()
										if char != KEYMAP["undefined"]:
														lowerCAmelCase						=					ord(_UpperCAmelCase       )
										lowerCAmelCase						=					cls.key_handler.get(_UpperCAmelCase       )
										if handler:
														lowerCAmelCase						=					char
														return handler(cls       )
										else:
														return None





def 				lowercase       (cls :			Optional[Any]			)  ->	Dict:


				'''simple docstring'''






				return KeyHandler(cls.__name__   ,							cls.__bases__   ,							cls.__dict__.copy()			)













import argparse

import torch

from ...utils import logging
from . import AlbertConfig, AlbertForPreTraining, load_tf_weights_in_albert


logging.set_verbosity_info()






def      _snake_case     (__lowercase     ,   __lowercase     ,   __lowercase):
   # Initialise PyTorch model
   UpperCamelCase_						=  AlbertConfig.from_json_file(__lowercase)
   print(f"""Building PyTorch model from configuration: {config}""")
   UpperCamelCase_						=  AlbertForPreTraining(__lowercase)

   # Load weights from tf checkpoint
   load_tf_weights_in_albert(__lowercase     ,   __lowercase     ,   __lowercase)

   # Save pytorch-model
   print(f"""Save PyTorch model to {pytorch_dump_path}""")
   torch.save(model.state_dict()     ,   __lowercase)


if __name__ == "__main__":
 snake_case__   :						Tuple													=   argparse.ArgumentParser()
 # Required parameters
 parser.add_argument(
     """--tf_checkpoint_path""", default=None, type=str, required=True, help="""Path to the TensorFlow checkpoint path."""
 )
 parser.add_argument(
     """--albert_config_file""",
     default=None,
     type=str,
     required=True,
     help=(
         """The config json file corresponding to the pre-trained ALBERT model. \n"""
         """This specifies the model architecture."""
     ),
 )
 parser.add_argument(
     """--pytorch_dump_path""", default=None, type=str, required=True, help="""Path to the output PyTorch model."""
 )
 snake_case__   :						str													=   parser.parse_args()
 convert_tf_checkpoint_to_pytorch(args.tf_checkpoint_path, args.albert_config_file, args.pytorch_dump_path)





