
"""simple docstring"""






import argparse
import os
import re

import tensorflow as tf
import torch

from transformers import BertConfig, BertModel
from transformers.utils import logging


logging.set_verbosity_info()
__UpperCAmelCase       =  logging.get_logger(__name__)






def 						_snake_case       (	lowercase__		:  Union[str, Any]      ,     lowercase__		:  Optional[int]      ,     lowercase__		:  Optional[Any]		)  ->				Optional[int]:


			'''simple docstring'''





			lowerCAmelCase_    :Dict			     =  os.path.abspath(lowercase__		)
			logger.info(f"""Converting TensorFlow checkpoint from {tf_path}"""		)
			# Load weights from TF model
			lowerCAmelCase_    :Any			     =  tf.train.list_variables(lowercase__		)
			lowerCAmelCase_    :List[str]			     =  []
			lowerCAmelCase_    :str			     =  []
			lowerCAmelCase_    :int			     =  []
			for full_name, shape in init_vars:
						# logger.info(f"Loading TF weight {name} with shape {shape}")
						lowerCAmelCase_    :Union[str, Any]			     =  full_name.split("""/"""		)
						if full_name == "_CHECKPOINTABLE_OBJECT_GRAPH" or name[0] in ["global_step", "save_counter"]:
									logger.info(f"""Skipping non-model layer {full_name}"""		)
									continue
						if "optimizer" in full_name:
									logger.info(f"""Skipping optimization layer {full_name}"""		)
									continue
						if name[0] == "model":
									# ignore initial 'model'
									lowerCAmelCase_    :Dict			     =  name[1:]
						# figure out how many levels deep the name is
						lowerCAmelCase_    :Tuple			     =  0
						for _name in name:
									if _name.startswith("""layer_with_weights"""		):
												depth += 1
									else:
												break
						layer_depth.append(lowercase__		)
						# read data
						lowerCAmelCase_    :Optional[Any]			     =  tf.train.load_variable(lowercase__      ,     lowercase__		)
						names.append("""/""".join(lowercase__		)		)
						arrays.append(lowercase__		)
			logger.info(f"""Read a total of {len(lowercase__		):,} layers"""		)

			# Sanity check
			if len(set(lowercase__		)		) != 1:
						raise ValueError(f"""Found layer names with different depths (layer depth {list(set(lowercase__		)		)})"""		)
			lowerCAmelCase_    :Dict			     =  list(set(lowercase__		)		)[0]
			if layer_depth != 1:
						raise ValueError(
						    """The model contains more than just the embedding/encoder layers. This script does not handle MLM/NSP"""
						    """ heads."""		)

			# convert layers
			logger.info("""Converting weights..."""		)
			for full_name, array in zip(lowercase__      ,     lowercase__		):
						lowerCAmelCase_    :str			     =  full_name.split("""/"""		)
						lowerCAmelCase_    :Union[str, Any]			     =  model
						lowerCAmelCase_    :Tuple			     =  []
						for i, m_name in enumerate(lowercase__		):
									if m_name == ".ATTRIBUTES":
												# variable names end with .ATTRIBUTES/VARIABLE_VALUE
												break
									if m_name.startswith("""layer_with_weights"""		):
												lowerCAmelCase_    :Dict			     =  int(m_name.split("""-"""		)[-1]		)
												if layer_num <= 2:
															# embedding layers
															# layer_num 0: word_embeddings
															# layer_num 1: position_embeddings
															# layer_num 2: token_type_embeddings
															continue
												elif layer_num == 3:
															# embedding LayerNorm
															trace.extend(["""embeddings""", """LayerNorm"""]		)
															lowerCAmelCase_    :Dict			     =  getattr(lowercase__      ,     """embeddings"""		)
															lowerCAmelCase_    :List[str]			     =  getattr(lowercase__      ,     """LayerNorm"""		)
												elif layer_num > 3 and layer_num < config.num_hidden_layers + 4:
															# encoder layers
															trace.extend(["""encoder""", """layer""", str(layer_num - 4		)]		)
															lowerCAmelCase_    :Optional[Any]			     =  getattr(lowercase__      ,     """encoder"""		)
															lowerCAmelCase_    :List[str]			     =  getattr(lowercase__      ,     """layer"""		)
															lowerCAmelCase_    :Tuple			     =  pointer[layer_num - 4]
												elif layer_num == config.num_hidden_layers + 4:
															# pooler layer
															trace.extend(["""pooler""", """dense"""]		)
															lowerCAmelCase_    :Tuple			     =  getattr(lowercase__      ,     """pooler"""		)
															lowerCAmelCase_    :List[Any]			     =  getattr(lowercase__      ,     """dense"""		)
									elif m_name == "embeddings":
												trace.append("""embeddings"""		)
												lowerCAmelCase_    :Dict			     =  getattr(lowercase__      ,     """embeddings"""		)
												if layer_num == 0:
															trace.append("""word_embeddings"""		)
															lowerCAmelCase_    :Any			     =  getattr(lowercase__      ,     """word_embeddings"""		)
												elif layer_num == 1:
															trace.append("""position_embeddings"""		)
															lowerCAmelCase_    :int			     =  getattr(lowercase__      ,     """position_embeddings"""		)
												elif layer_num == 2:
															trace.append("""token_type_embeddings"""		)
															lowerCAmelCase_    :str			     =  getattr(lowercase__      ,     """token_type_embeddings"""		)
												else:
															raise ValueError(f"""Unknown embedding layer with name {full_name}"""		)
												trace.append("""weight"""		)
												lowerCAmelCase_    :Tuple			     =  getattr(lowercase__      ,     """weight"""		)
									elif m_name == "_attention_layer":
												# self-attention layer
												trace.extend(["""attention""", """self"""]		)
												lowerCAmelCase_    :str			     =  getattr(lowercase__      ,     """attention"""		)
												lowerCAmelCase_    :Optional[int]			     =  getattr(lowercase__      ,     """self"""		)
									elif m_name == "_attention_layer_norm":
												# output attention norm
												trace.extend(["""attention""", """output""", """LayerNorm"""]		)
												lowerCAmelCase_    :str			     =  getattr(lowercase__      ,     """attention"""		)
												lowerCAmelCase_    :Any			     =  getattr(lowercase__      ,     """output"""		)
												lowerCAmelCase_    :str			     =  getattr(lowercase__      ,     """LayerNorm"""		)
									elif m_name == "_attention_output_dense":
												# output attention dense
												trace.extend(["""attention""", """output""", """dense"""]		)
												lowerCAmelCase_    :Any			     =  getattr(lowercase__      ,     """attention"""		)
												lowerCAmelCase_    :List[Any]			     =  getattr(lowercase__      ,     """output"""		)
												lowerCAmelCase_    :List[Any]			     =  getattr(lowercase__      ,     """dense"""		)
									elif m_name == "_output_dense":
												# output dense
												trace.extend(["""output""", """dense"""]		)
												lowerCAmelCase_    :Any			     =  getattr(lowercase__      ,     """output"""		)
												lowerCAmelCase_    :Optional[int]			     =  getattr(lowercase__      ,     """dense"""		)
									elif m_name == "_output_layer_norm":
												# output dense
												trace.extend(["""output""", """LayerNorm"""]		)
												lowerCAmelCase_    :Optional[int]			     =  getattr(lowercase__      ,     """output"""		)
												lowerCAmelCase_    :Any			     =  getattr(lowercase__      ,     """LayerNorm"""		)
									elif m_name == "_key_dense":
												# attention key
												trace.append("""key"""		)
												lowerCAmelCase_    :Union[str, Any]			     =  getattr(lowercase__      ,     """key"""		)
									elif m_name == "_query_dense":
												# attention query
												trace.append("""query"""		)
												lowerCAmelCase_    :Union[str, Any]			     =  getattr(lowercase__      ,     """query"""		)
									elif m_name == "_value_dense":
												# attention value
												trace.append("""value"""		)
												lowerCAmelCase_    :List[str]			     =  getattr(lowercase__      ,     """value"""		)
									elif m_name == "_intermediate_dense":
												# attention intermediate dense
												trace.extend(["""intermediate""", """dense"""]		)
												lowerCAmelCase_    :Optional[Any]			     =  getattr(lowercase__      ,     """intermediate"""		)
												lowerCAmelCase_    :Optional[int]			     =  getattr(lowercase__      ,     """dense"""		)
									elif m_name == "_output_layer_norm":
												# output layer norm
												trace.append("""output"""		)
												lowerCAmelCase_    :str			     =  getattr(lowercase__      ,     """output"""		)
									# weights & biases
									elif m_name in ["bias", "beta"]:
												trace.append("""bias"""		)
												lowerCAmelCase_    :Union[str, Any]			     =  getattr(lowercase__      ,     """bias"""		)
									elif m_name in ["kernel", "gamma"]:
												trace.append("""weight"""		)
												lowerCAmelCase_    :str			     =  getattr(lowercase__      ,     """weight"""		)
									else:
												logger.warning(f"""Ignored {m_name}"""		)
        # for certain layers reshape is necessary
						lowerCAmelCase_    :Dict			     =  """.""".join(lowercase__		)
						if re.match(r"""(\S+)\.attention\.self\.(key|value|query)\.(bias|weight)"""      ,     lowercase__		) or re.match(
						    r"""(\S+)\.attention\.output\.dense\.weight"""      ,     lowercase__		):
									lowerCAmelCase_    :Tuple			     =  array.reshape(pointer.data.shape		)
						if "kernel" in full_name:
									lowerCAmelCase_    :Optional[Any]			     =  array.transpose()
						if pointer.shape == array.shape:
									lowerCAmelCase_    :List[str]			     =  torch.from_numpy(lowercase__		)
						else:
									raise ValueError(
									    f"""Shape mismatch in layer {full_name}: Model expects shape {pointer.shape} but layer contains shape:"""
									    f""" {array.shape}"""		)
						logger.info(f"""Successfully set variable {full_name} to PyTorch layer {trace}"""		)
			return model






def 						_snake_case       (	lowercase__		:  str      ,     lowercase__		:  Optional[Any]      ,     lowercase__		:  Union[str, Any]		)  ->				List[str]:


			'''simple docstring'''





			logger.info(f"""Loading model based on config from {config_path}..."""		)
			lowerCAmelCase_    :Optional[int]			     =  BertConfig.from_json_file(lowercase__		)
			lowerCAmelCase_    :Optional[Any]			     =  BertModel(lowercase__		)

			# Load weights from checkpoint
			logger.info(f"""Loading weights from checkpoint {tf_checkpoint_path}..."""		)
			load_tfa_weights_in_bert(lowercase__      ,     lowercase__      ,     lowercase__		)

			# Save pytorch-model
			logger.info(f"""Saving PyTorch model to {pytorch_dump_path}..."""		)
			torch.save(model.state_dict()      ,     lowercase__		)


if __name__ == "__main__":
				__UpperCAmelCase       =  argparse.ArgumentParser()
				parser.add_argument(
				    '--tf_checkpoint_path', type=str, required=True, help='Path to the TensorFlow 2.x checkpoint path.'
				)
				parser.add_argument(
				    '--bert_config_file',
				    type=str,
				    required=True,
				    help='The config json file corresponding to the BERT model. This specifies the model architecture.',
				)
				parser.add_argument(
				    '--pytorch_dump_path',
				    type=str,
				    required=True,
				    help='Path to the output PyTorch model (must include filename).',
				)
				__UpperCAmelCase       =  parser.parse_args()
				convert_tfa_checkpoint_to_pytorch(args.tf_checkpoint_path, args.bert_config_file, args.pytorch_dump_path)










"""simple docstring"""







from __future__ import annotations






class 						_A  :







    """simple docstring"""




    def __init__(					self				:    List[str]				, __UpperCAmelCase				:    int = 0):
      a						:		Tuple      							=			key






    def 	__snake_case							(					self				:    List[str]				, __UpperCAmelCase				:    str				, __UpperCAmelCase				:    int):
      assert isinstance(__UpperCAmelCase				, __UpperCAmelCase) and isinstance(__UpperCAmelCase				, __UpperCAmelCase)

      a						:		Dict      							=			key or self.__key or 1

      # make sure key is an appropriate size
      key %= 255

      return [chr(ord(__UpperCAmelCase) ^ key) for ch in content]






    def 	__snake_case							(					self				:    int				, __UpperCAmelCase				:    str				, __UpperCAmelCase				:    int):
      assert isinstance(__UpperCAmelCase				, __UpperCAmelCase) and isinstance(__UpperCAmelCase				, __UpperCAmelCase)

      a						:		Optional[Any]      							=			key or self.__key or 1

      # make sure key is an appropriate size
      key %= 255

      return [chr(ord(__UpperCAmelCase) ^ key) for ch in content]






    def 	__snake_case							(					self				:    Optional[Any]				, __UpperCAmelCase				:    str				, __UpperCAmelCase				:    int = 0):
      assert isinstance(__UpperCAmelCase				, __UpperCAmelCase) and isinstance(__UpperCAmelCase				, __UpperCAmelCase)

      a						:		List[Any]      							=			key or self.__key or 1

      # make sure key can be any size
      while key > 255:
        key -= 255

      # This will be returned
      a						:		Any      							=			""

      for ch in content:
        ans += chr(ord(__UpperCAmelCase) ^ key)

      return ans






    def 	__snake_case							(					self				:    List[str]				, __UpperCAmelCase				:    str				, __UpperCAmelCase				:    int = 0):
      assert isinstance(__UpperCAmelCase				, __UpperCAmelCase) and isinstance(__UpperCAmelCase				, __UpperCAmelCase)

      a						:		Dict      							=			key or self.__key or 1

      # make sure key can be any size
      while key > 255:
        key -= 255

      # This will be returned
      a						:		str      							=			""

      for ch in content:
        ans += chr(ord(__UpperCAmelCase) ^ key)

      return ans






    def 	__snake_case							(					self				:    int				, __UpperCAmelCase				:    str				, __UpperCAmelCase				:    int = 0):
      assert isinstance(__UpperCAmelCase				, __UpperCAmelCase) and isinstance(__UpperCAmelCase				, __UpperCAmelCase)

      try:
        with open(__UpperCAmelCase) as fin, open("encrypt.out"				, "w+") as fout:
          # actual encrypt-process
          for line in fin:
            fout.write(self.encrypt_string(__UpperCAmelCase				, __UpperCAmelCase))

      except OSError:
        return False

      return True






    def 	__snake_case							(					self				:    Any				, __UpperCAmelCase				:    str				, __UpperCAmelCase				:    int):
      assert isinstance(__UpperCAmelCase				, __UpperCAmelCase) and isinstance(__UpperCAmelCase				, __UpperCAmelCase)

      try:
        with open(__UpperCAmelCase) as fin, open("decrypt.out"				, "w+") as fout:
          # actual encrypt-process
          for line in fin:
            fout.write(self.decrypt_string(__UpperCAmelCase				, __UpperCAmelCase))

      except OSError:
        return False

      return True


# Tests
# crypt = XORCipher()
# key = 67

# # test encrypt
# print(crypt.encrypt("hallo welt",key))
# # test decrypt
# print(crypt.decrypt(crypt.encrypt("hallo welt",key), key))

# # test encrypt_string
# print(crypt.encrypt_string("hallo welt",key))

# # test decrypt_string
# print(crypt.decrypt_string(crypt.encrypt_string("hallo welt",key),key))

# if (crypt.encrypt_file("test.txt",key)):
#       print("encrypt successful")
# else:
#       print("encrypt unsuccessful")

# if (crypt.decrypt_file("encrypt.out",key)):
#       print("decrypt successful")
# else:
#       print("decrypt unsuccessful")






