



from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_tokenizers_available, is_torch_available


__lowerCamelCase  				=					{
    """configuration_splinter""": ["""SPLINTER_PRETRAINED_CONFIG_ARCHIVE_MAP""", """SplinterConfig"""],
    """tokenization_splinter""": ["""SplinterTokenizer"""],
}

try:
    if not is_tokenizers_available():
        raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
    pass
else:
    __lowerCamelCase  				=					["""SplinterTokenizerFast"""]

try:
    if not is_torch_available():
        raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
    pass
else:
    __lowerCamelCase  				=					[
        """SPLINTER_PRETRAINED_MODEL_ARCHIVE_LIST""",
        """SplinterForQuestionAnswering""",
        """SplinterForPreTraining""",
        """SplinterLayer""",
        """SplinterModel""",
        """SplinterPreTrainedModel""",
    ]


if TYPE_CHECKING:
    from .configuration_splinter import SPLINTER_PRETRAINED_CONFIG_ARCHIVE_MAP, SplinterConfig
    from .tokenization_splinter import SplinterTokenizer

    try:
        if not is_tokenizers_available():
            raise OptionalDependencyNotAvailable()
    except OptionalDependencyNotAvailable:
        pass
    else:
        from .tokenization_splinter_fast import SplinterTokenizerFast

    try:
        if not is_torch_available():
            raise OptionalDependencyNotAvailable()
    except OptionalDependencyNotAvailable:
        pass
    else:
        from .modeling_splinter import (
            SPLINTER_PRETRAINED_MODEL_ARCHIVE_LIST,
            SplinterForPreTraining,
            SplinterForQuestionAnswering,
            SplinterLayer,
            SplinterModel,
            SplinterPreTrainedModel,
        )


else:
    import sys

    __lowerCamelCase  				=					_LazyModule(__name__, globals()["""__file__"""], _import_structure, module_spec=__spec__)




import argparse

import torch

from transformers import ElectraConfig, ElectraForMaskedLM, ElectraForPreTraining, load_tf_weights_in_electra
from transformers.utils import logging


logging.set_verbosity_info()




def     UpperCAmelCase__ (							__snake_case						,				__snake_case						,				__snake_case						,				__snake_case							)   -> Tuple:
  # Initialise PyTorch model
  _A           =    ElectraConfig.from_json_file(__snake_case							)
  print(F'''Building PyTorch model from configuration: {config}'''							)

  if discriminator_or_generator == "discriminator":
    _A           =    ElectraForPreTraining(__snake_case							)
  elif discriminator_or_generator == "generator":
    _A           =    ElectraForMaskedLM(__snake_case							)
  else:
    raise ValueError('''The discriminator_or_generator argument should be either \'discriminator\' or \'generator\''''							)

  # Load weights from tf checkpoint
  load_tf_weights_in_electra(
      __snake_case						,				__snake_case						,				__snake_case						,				discriminator_or_generator=__snake_case							)

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


if __name__ == "__main__":
    __lowerCamelCase  				=					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(
        """--config_file""",
        default=None,
        type=str,
        required=True,
        help="""The config json file corresponding to the pre-trained model. \nThis specifies the model architecture.""",
    )
    parser.add_argument(
        """--pytorch_dump_path""", default=None, type=str, required=True, help="""Path to the output PyTorch model."""
    )
    parser.add_argument(
        """--discriminator_or_generator""",
        default=None,
        type=str,
        required=True,
        help=(
            """Whether to export the generator or the discriminator. Should be a string, either 'discriminator' or """
            """'generator'."""
        ),
    )
    __lowerCamelCase  				=					parser.parse_args()
    convert_tf_checkpoint_to_pytorch(
        args.tf_checkpoint_path, args.config_file, args.pytorch_dump_path, args.discriminator_or_generator
    )