



import copy

from transformers.configuration_utils import PretrainedConfig
from transformers.utils import logging


__lowerCamelCase  				=					logging.get_logger(__name__)



class 		_snake_case      (			lowerCamelCase				):





 """simple docstring"""



 lowerCamelCase_          =			'''hybrid-clip'''
 lowerCamelCase_          =			True
 def __init__(						self	,    a=5_1_2	,    **a					)	->							int:




   """simple docstring"""







   super().__init__(**a					)

   if "text_config" not in kwargs:
     raise ValueError('''`text_config` can not be `None`.'''					)

   if "vision_config" not in kwargs:
     raise ValueError('''`vision_config` can not be `None`.'''					)

   _A           =    kwargs.pop('''text_config'''					)
   _A           =    kwargs.pop('''vision_config'''					)

   _A           =    text_config.pop('''model_type'''					)
   _A           =    vision_config.pop('''model_type'''					)

   from transformers import AutoConfig

   _A           =    AutoConfig.for_model(a	,    **a					)

   if vision_model_type == "clip":
     _A           =    AutoConfig.for_model(a	,    **a					).vision_config
   elif vision_model_type == "clip_vision_model":
     from transformers import CLIPVisionConfig

     _A           =    CLIPVisionConfig(**a					)
   else:
     _A           =    AutoConfig.for_model(a	,    **a					)

   _A           =    projection_dim
   _A           =    1.0
 @classmethod
 def lowercase_		(						cls	,    a	,    a	,    **a					)	->							Tuple:




   """simple docstring"""







   return cls(text_config=text_config.to_dict()	,    vision_config=vision_config.to_dict()	,    **a					)



 def lowercase_		(						self					)	->							Dict:




   """simple docstring"""







   _A           =    copy.deepcopy(self.__dict__					)
   _A           =    self.text_config.to_dict()
   _A           =    self.vision_config.to_dict()
   _A           =    self.__class__.model_type
   return output




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
    )