





"""simple docstring"""





import enum
import os
from hashlib import shaaaa
from typing import Optional

from .. import config
from .logging import get_logger


__A											=		get_logger(__name__)






class 					_lowerCAmelCase   (     enum.Enum       ):
       """simple docstring"""




       __magic_name__     :Union[str, Any]		  =					"""all_checks"""
       __magic_name__     :Tuple		  =					"""basic_checks"""
       __magic_name__     :int		  =					"""no_checks"""






class 					_lowerCAmelCase   (     a       ):
       """simple docstring"""










class 					_lowerCAmelCase   (     a       ):
       """simple docstring"""










class 					_lowerCAmelCase   (     a       ):
       """simple docstring"""










class 					_lowerCAmelCase   (     a       ):
       """simple docstring"""










def  __A   (_SCREAMING_SNAKE_CASE     ,   _SCREAMING_SNAKE_CASE     ,   _SCREAMING_SNAKE_CASE=None			)					->Optional[Any]:





  """simple docstring"""


  if expected_checksums is None:
    logger.info('Unable to verify checksums.'			)
    return
  if len(set(_SCREAMING_SNAKE_CASE			) - set(_SCREAMING_SNAKE_CASE			)			) > 0:
    raise ExpectedMoreDownloadedFiles(str(set(_SCREAMING_SNAKE_CASE			) - set(_SCREAMING_SNAKE_CASE			)			)			)
  if len(set(_SCREAMING_SNAKE_CASE			) - set(_SCREAMING_SNAKE_CASE			)			) > 0:
    raise UnexpectedDownloadedFile(str(set(_SCREAMING_SNAKE_CASE			) - set(_SCREAMING_SNAKE_CASE			)			)			)
  lowerCAmelCase__			:Union[str, Any]											=							[url for url in expected_checksums if expected_checksums[url] != recorded_checksums[url]]
  lowerCAmelCase__			:int											=							' for ' + verification_name if verification_name is not None else ''
  if len(_SCREAMING_SNAKE_CASE			) > 0:
    raise NonMatchingChecksumError(
        F"Checksums didn't match{for_verification_name}:\n"
        F"{bad_urls}\n"
        'Set `verification_mode=\'no_checks\'` to skip checksums verification and ignore this error'			)
  logger.info('All the checksums matched successfully' + for_verification_name			)






class 					_lowerCAmelCase   (     a       ):
       """simple docstring"""










class 					_lowerCAmelCase   (     a       ):
       """simple docstring"""










class 					_lowerCAmelCase   (     a       ):
       """simple docstring"""










class 					_lowerCAmelCase   (     a       ):
       """simple docstring"""










def  __A   (_SCREAMING_SNAKE_CASE     ,   _SCREAMING_SNAKE_CASE			)					->Dict:





  """simple docstring"""


  if expected_splits is None:
    logger.info('Unable to verify splits sizes.'			)
    return
  if len(set(_SCREAMING_SNAKE_CASE			) - set(_SCREAMING_SNAKE_CASE			)			) > 0:
    raise ExpectedMoreSplits(str(set(_SCREAMING_SNAKE_CASE			) - set(_SCREAMING_SNAKE_CASE			)			)			)
  if len(set(_SCREAMING_SNAKE_CASE			) - set(_SCREAMING_SNAKE_CASE			)			) > 0:
    raise UnexpectedSplits(str(set(_SCREAMING_SNAKE_CASE			) - set(_SCREAMING_SNAKE_CASE			)			)			)
  lowerCAmelCase__			:Optional[Any]											=							[
      {'expected': expected_splits[name], 'recorded': recorded_splits[name]}
      for name in expected_splits
      if expected_splits[name].num_examples != recorded_splits[name].num_examples
  ]
  if len(_SCREAMING_SNAKE_CASE			) > 0:
    raise NonMatchingSplitsSizesError(str(_SCREAMING_SNAKE_CASE			)			)
  logger.info('All the splits matched successfully.'			)
def  __A   (_SCREAMING_SNAKE_CASE     ,   _SCREAMING_SNAKE_CASE = True			)					->dict:





  """simple docstring"""


  if record_checksum:
    lowerCAmelCase__			:Tuple											=							shaaaa()
    with open(_SCREAMING_SNAKE_CASE     ,   'rb'			) as f:
      for chunk in iter(lambda: f.read(1 << 20			)     ,   B''			):
        m.update(_SCREAMING_SNAKE_CASE			)
      lowerCAmelCase__			:Optional[Any]											=							m.hexdigest()
  else:
    lowerCAmelCase__			:Tuple											=							None
  return {"num_bytes": os.path.getsize(_SCREAMING_SNAKE_CASE			), "checksum": checksum}




def  __A   (_SCREAMING_SNAKE_CASE			)					->Optional[Any]:





  """simple docstring"""


  if dataset_size and config.IN_MEMORY_MAX_SIZE:
    return dataset_size < config.IN_MEMORY_MAX_SIZE
  else:
    return False







"""simple docstring"""





import argparse

import torch

from transformers import BertConfig, BertForPreTraining, load_tf_weights_in_bert
from transformers.utils import logging


logging.set_verbosity_info()
def  __A   (_SCREAMING_SNAKE_CASE     ,   _SCREAMING_SNAKE_CASE     ,   _SCREAMING_SNAKE_CASE			)					->Dict:





  """simple docstring"""


  lowerCAmelCase__			:str											=							BertConfig.from_json_file(_SCREAMING_SNAKE_CASE			)
  print(F"Building PyTorch model from configuration: {config}"			)
  lowerCAmelCase__			:int											=							BertForPreTraining(_SCREAMING_SNAKE_CASE			)

  # Load weights from tf checkpoint
  load_tf_weights_in_bert(_SCREAMING_SNAKE_CASE     ,   _SCREAMING_SNAKE_CASE     ,   _SCREAMING_SNAKE_CASE			)

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


if __name__ == "__main__":
  __A											=		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(
      """--bert_config_file""",
      default=None,
      type=str,
      required=True,
      help=(
          """The config json file corresponding to the pre-trained BERT 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."""
  )
  __A											=		parser.parse_args()
  convert_tf_checkpoint_to_pytorch(args.tf_checkpoint_path, args.bert_config_file, args.pytorch_dump_path)
