




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()
_snake_case            = logging.get_logger(__name__)







def        lowerCAmelCase_			(  snake_case_,snake_case_,snake_case_  ):
      _A							:  List[str]    =		os.path.abspath(snake_case_  )
      logger.info(f'''Converting TensorFlow checkpoint from {tf_path}'''  )
      # Load weights from TF model
      _A							:  List[str]    =		tf.train.list_variables(snake_case_  )
      _A							:  List[Any]    =		[]
      _A							:  Optional[Any]    =		[]
      _A							:  Union[str, Any]    =		[]
      for full_name, shape in init_vars:
            # logger.info(f"Loading TF weight {name} with shape {shape}")
            _A							:  Tuple    =		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'
                  _A							:  int    =		name[1:]
            # figure out how many levels deep the name is
            _A							:  Any    =		0
            for _name in name:
                  if _name.startswith("""layer_with_weights"""  ):
                        depth += 1
                  else:
                        break
            layer_depth.append(snake_case_  )
            # read data
            _A							:  List[str]    =		tf.train.load_variable(snake_case_,snake_case_  )
            names.append("""/""".join(snake_case_  )  )
            arrays.append(snake_case_  )
      logger.info(f'''Read a total of {len(snake_case_  ):,} layers'''  )

      # Sanity check
      if len(set(snake_case_  )  ) != 1:
            raise ValueError(f'''Found layer names with different depths (layer depth {list(set(snake_case_  )  )})'''  )
      _A							:  List[str]    =		list(set(snake_case_  )  )[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(snake_case_,snake_case_  ):
            _A							:  Optional[Any]    =		full_name.split("""/"""  )
            _A							:  Any    =		model
            _A							:  Any    =		[]
            for i, m_name in enumerate(snake_case_  ):
                  if m_name == ".ATTRIBUTES":
                        # variable names end with .ATTRIBUTES/VARIABLE_VALUE
                        break
                  if m_name.startswith("""layer_with_weights"""  ):
                        _A							:  Optional[Any]    =		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"""]  )
                              _A							:  int    =		getattr(snake_case_,"""embeddings"""  )
                              _A							:  Dict    =		getattr(snake_case_,"""LayerNorm"""  )
                        elif layer_num > 3 and layer_num < config.num_hidden_layers + 4:
                              # encoder layers
                              trace.extend(["""encoder""", """layer""", str(layer_num - 4  )]  )
                              _A							:  Any    =		getattr(snake_case_,"""encoder"""  )
                              _A							:  Tuple    =		getattr(snake_case_,"""layer"""  )
                              _A							:  str    =		pointer[layer_num - 4]
                        elif layer_num == config.num_hidden_layers + 4:
                              # pooler layer
                              trace.extend(["""pooler""", """dense"""]  )
                              _A							:  str    =		getattr(snake_case_,"""pooler"""  )
                              _A							:  Union[str, Any]    =		getattr(snake_case_,"""dense"""  )
                  elif m_name == "embeddings":
                        trace.append("""embeddings"""  )
                        _A							:  List[str]    =		getattr(snake_case_,"""embeddings"""  )
                        if layer_num == 0:
                              trace.append("""word_embeddings"""  )
                              _A							:  Optional[Any]    =		getattr(snake_case_,"""word_embeddings"""  )
                        elif layer_num == 1:
                              trace.append("""position_embeddings"""  )
                              _A							:  Optional[Any]    =		getattr(snake_case_,"""position_embeddings"""  )
                        elif layer_num == 2:
                              trace.append("""token_type_embeddings"""  )
                              _A							:  Optional[Any]    =		getattr(snake_case_,"""token_type_embeddings"""  )
                        else:
                              raise ValueError(f'''Unknown embedding layer with name {full_name}'''  )
                        trace.append("""weight"""  )
                        _A							:  Any    =		getattr(snake_case_,"""weight"""  )
                  elif m_name == "_attention_layer":
                        # self-attention layer
                        trace.extend(["""attention""", """self"""]  )
                        _A							:  Optional[int]    =		getattr(snake_case_,"""attention"""  )
                        _A							:  List[Any]    =		getattr(snake_case_,"""self"""  )
                  elif m_name == "_attention_layer_norm":
                        # output attention norm
                        trace.extend(["""attention""", """output""", """LayerNorm"""]  )
                        _A							:  Optional[int]    =		getattr(snake_case_,"""attention"""  )
                        _A							:  Tuple    =		getattr(snake_case_,"""output"""  )
                        _A							:  int    =		getattr(snake_case_,"""LayerNorm"""  )
                  elif m_name == "_attention_output_dense":
                        # output attention dense
                        trace.extend(["""attention""", """output""", """dense"""]  )
                        _A							:  Optional[Any]    =		getattr(snake_case_,"""attention"""  )
                        _A							:  Any    =		getattr(snake_case_,"""output"""  )
                        _A							:  Optional[int]    =		getattr(snake_case_,"""dense"""  )
                  elif m_name == "_output_dense":
                        # output dense
                        trace.extend(["""output""", """dense"""]  )
                        _A							:  Any    =		getattr(snake_case_,"""output"""  )
                        _A							:  Union[str, Any]    =		getattr(snake_case_,"""dense"""  )
                  elif m_name == "_output_layer_norm":
                        # output dense
                        trace.extend(["""output""", """LayerNorm"""]  )
                        _A							:  str    =		getattr(snake_case_,"""output"""  )
                        _A							:  Union[str, Any]    =		getattr(snake_case_,"""LayerNorm"""  )
                  elif m_name == "_key_dense":
                        # attention key
                        trace.append("""key"""  )
                        _A							:  Optional[int]    =		getattr(snake_case_,"""key"""  )
                  elif m_name == "_query_dense":
                        # attention query
                        trace.append("""query"""  )
                        _A							:  Optional[int]    =		getattr(snake_case_,"""query"""  )
                  elif m_name == "_value_dense":
                        # attention value
                        trace.append("""value"""  )
                        _A							:  Optional[Any]    =		getattr(snake_case_,"""value"""  )
                  elif m_name == "_intermediate_dense":
                        # attention intermediate dense
                        trace.extend(["""intermediate""", """dense"""]  )
                        _A							:  Dict    =		getattr(snake_case_,"""intermediate"""  )
                        _A							:  Union[str, Any]    =		getattr(snake_case_,"""dense"""  )
                  elif m_name == "_output_layer_norm":
                        # output layer norm
                        trace.append("""output"""  )
                        _A							:  int    =		getattr(snake_case_,"""output"""  )
                  # weights & biases
                  elif m_name in ["bias", "beta"]:
                        trace.append("""bias"""  )
                        _A							:  List[str]    =		getattr(snake_case_,"""bias"""  )
                  elif m_name in ["kernel", "gamma"]:
                        trace.append("""weight"""  )
                        _A							:  Optional[Any]    =		getattr(snake_case_,"""weight"""  )
                  else:
                        logger.warning(f'''Ignored {m_name}'''  )
        # for certain layers reshape is necessary
            _A							:  List[str]    =		""".""".join(snake_case_  )
            if re.match(r"""(\S+)\.attention\.self\.(key|value|query)\.(bias|weight)""",snake_case_  ) or re.match(
                r"""(\S+)\.attention\.output\.dense\.weight""",snake_case_  ):
                  _A							:  str    =		array.reshape(pointer.data.shape  )
            if "kernel" in full_name:
                  _A							:  Tuple    =		array.transpose()
            if pointer.shape == array.shape:
                  _A							:  Union[str, Any]    =		torch.from_numpy(snake_case_  )
            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        lowerCAmelCase_			(  snake_case_,snake_case_,snake_case_  ):
      # Instantiate model
      logger.info(f'''Loading model based on config from {config_path}...'''  )
      _A							:  Tuple    =		BertConfig.from_json_file(snake_case_  )
      _A							:  Union[str, Any]    =		BertModel(snake_case_  )

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

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


if __name__ == "__main__":
  _snake_case            = 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).",
  )
  _snake_case            = parser.parse_args()
  convert_tfa_checkpoint_to_pytorch(args.tf_checkpoint_path, args.bert_config_file, args.pytorch_dump_path)







def        lowerCAmelCase_			(  snake_case_,snake_case_  ):
      _A							:  Union[str, Any]    =		""""""
      for i in table:
            res += inp[i - 1]
      return res







def        lowerCAmelCase_			(  snake_case_  ):
      return data[1:] + data[0]







def        lowerCAmelCase_			(  snake_case_,snake_case_  ):
      _A							:  Dict    =		""""""
      for i in range(len(snake_case_  )  ):
            if a[i] == b[i]:
                  res += "0"
            else:
                  res += "1"
      return res







def        lowerCAmelCase_			(  snake_case_,snake_case_  ):
      _A							:  int    =		int("""0b""" + data[0] + data[-1],2  )
      _A							:  Any    =		int("""0b""" + data[1:3],2  )
      return bin(s[row][col]  )[2:]







def        lowerCAmelCase_			(  snake_case_,snake_case_,snake_case_,snake_case_,snake_case_  ):
      _A							:  List[str]    =		message[:4]
      _A							:  List[Any]    =		message[4:]
      _A							:  Union[str, Any]    =		apply_table(snake_case_,snake_case_  )
      _A							:  List[Any]    =		xor(snake_case_,snake_case_  )
      _A							:  Optional[Any]    =		apply_sbox(snake_case_,temp[:4]  )  # noqa: E741
      _A							:  List[Any]    =		apply_sbox(snake_case_,temp[4:]  )
      _A							:  int    =		"""0""" * (2 - len(snake_case_  )) + l  # noqa: E741
      _A							:  Union[str, Any]    =		"""0""" * (2 - len(snake_case_  )) + r
      _A							:  List[Any]    =		apply_table(l + r,snake_case_  )
      _A							:  Any    =		xor(snake_case_,snake_case_  )
      return temp + right


if __name__ == "__main__":
  _snake_case            = input("Enter 10 bit key: ")
  _snake_case            = input("Enter 8 bit message: ")

  _snake_case            = [6, 3, 7, 4, 8, 5, 10, 9]
  _snake_case            = [3, 5, 2, 7, 4, 10, 1, 9, 8, 6]
  _snake_case            = [2, 4, 3, 1]
  _snake_case            = [2, 6, 3, 1, 4, 8, 5, 7]
  _snake_case            = [4, 1, 3, 5, 7, 2, 8, 6]
  _snake_case            = [4, 1, 2, 3, 2, 3, 4, 1]
  _snake_case            = [[1, 0, 3, 2], [3, 2, 1, 0], [0, 2, 1, 3], [3, 1, 3, 2]]
  _snake_case            = [[0, 1, 2, 3], [2, 0, 1, 3], [3, 0, 1, 0], [2, 1, 0, 3]]

  # key generation
  _snake_case            = apply_table(key, paa_table)
  _snake_case            = temp[:5]
  _snake_case            = temp[5:]
  _snake_case            = left_shift(left)
  _snake_case            = left_shift(right)
  _snake_case            = apply_table(left + right, pa_table)
  _snake_case            = left_shift(left)
  _snake_case            = left_shift(right)
  _snake_case            = left_shift(left)
  _snake_case            = left_shift(right)
  _snake_case            = apply_table(left + right, pa_table)

  # encryption
  _snake_case            = apply_table(message, IP)
  _snake_case            = function(expansion, sa, sa, keya, temp)
  _snake_case            = temp[4:] + temp[:4]
  _snake_case            = function(expansion, sa, sa, keya, temp)
  _snake_case            = apply_table(temp, IP_inv)
  print("Cipher text is:", CT)

  # decryption
  _snake_case            = apply_table(CT, IP)
  _snake_case            = function(expansion, sa, sa, keya, temp)
  _snake_case            = temp[4:] + temp[:4]
  _snake_case            = function(expansion, sa, sa, keya, temp)
  _snake_case            = apply_table(temp, IP_inv)
  print("Plain text after decypting is:", PT)

