code: 
  
  
  
  
  """simple docstring"""
  
  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__     (		lowercase__  :     Optional[Any]       ,     lowercase__  :     Optional[int]       ,     lowercase__  :     Any       ,     lowercase__  :     Any   ):
  		# Initialise PyTorch model
  		snake_case		:						Optional[Any]								=				ElectraConfig.from_json_file(lowercase__   )
  		print(F'''Building PyTorch model from configuration: {config}'''   )
  
  		if discriminator_or_generator == "discriminator":
  				snake_case		:						List[Any]								=				ElectraForPreTraining(lowercase__   )
  		elif discriminator_or_generator == "generator":
  				snake_case		:						Union[str, Any]								=				ElectraForMaskedLM(lowercase__   )
  		else:
  				raise ValueError("The discriminator_or_generator argument should be either 'discriminator' or 'generator'"   )
  
  		# Load weights from tf checkpoint
  		load_tf_weights_in_electra(
  		    lowercase__       ,     lowercase__       ,     lowercase__       ,     discriminator_or_generator=lowercase__   )
  
  		# Save pytorch-model
  		print(F'''Save PyTorch model to {pytorch_dump_path}'''   )
  		torch.save(model.state_dict()       ,     lowercase__   )
  
  
  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(
  							    "--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\'."
  							    ),
  							)
  							__A 		=			parser.parse_args()
  							convert_tf_checkpoint_to_pytorch(
  							    args.tf_checkpoint_path, args.config_file, args.pytorch_dump_path, args.discriminator_or_generator
  							)
  
  
style_context: 
  
  
  
  
  """simple docstring"""
  
  import tempfile
  import unittest
  
  from diffusers import (
      DDIMScheduler,
      DDPMScheduler,
      DPMSolverMultistepScheduler,
      EulerAncestralDiscreteScheduler,
      EulerDiscreteScheduler,
      PNDMScheduler,
      logging,
  )
  from diffusers.configuration_utils import ConfigMixin, register_to_config
  from diffusers.utils.testing_utils import CaptureLogger
  class 			lowerCamelCase__    (  lowerCamelCase_			):
  			a__ :      int								=     """config.json"""
  
  
  			@register_to_config
  			def __init__(     self				, SCREAMING_SNAKE_CASE=2				, SCREAMING_SNAKE_CASE=5				, SCREAMING_SNAKE_CASE=(2, 5)				, SCREAMING_SNAKE_CASE="for diffusion"				, SCREAMING_SNAKE_CASE=[1, 3]				, ):
  
  
  
  					"""simple docstring"""
  
  
  
  
  
  
  
  					pass
  
  
  
  
  
  
  
  class 			lowerCamelCase__    (  lowerCamelCase_			):
  			a__ :      Dict								=     """config.json"""
  
  
  			@register_to_config
  			def __init__(     self				, SCREAMING_SNAKE_CASE=2				, SCREAMING_SNAKE_CASE=5				, SCREAMING_SNAKE_CASE=(2, 5)				, SCREAMING_SNAKE_CASE="for diffusion"				, SCREAMING_SNAKE_CASE=[1, 3]				, ):
  
  
  
  					"""simple docstring"""
  
  
  
  
  
  
  
  					pass
  
  
  
  
  
  
  
  class 			lowerCamelCase__    (  lowerCamelCase_			):
  			a__ :      Union[str, Any]								=     """config.json"""
  
  
  			@register_to_config
  			def __init__(     self				, SCREAMING_SNAKE_CASE=2				, SCREAMING_SNAKE_CASE=5				, SCREAMING_SNAKE_CASE=(2, 5)				, SCREAMING_SNAKE_CASE="for diffusion"				, SCREAMING_SNAKE_CASE=[1, 3]				, SCREAMING_SNAKE_CASE=[1, 3]				, ):
  
  
  
  					"""simple docstring"""
  
  
  
  
  
  
  
  					pass
  
  
  
  
  
  
  
  class 			lowerCamelCase__    (  lowerCamelCase_			):
  			a__ :      Tuple								=     """config.json"""
  
  
  			@register_to_config
  			def __init__(     self				, SCREAMING_SNAKE_CASE=2				, SCREAMING_SNAKE_CASE=5				, SCREAMING_SNAKE_CASE=(2, 5)				, SCREAMING_SNAKE_CASE="for diffusion"				, SCREAMING_SNAKE_CASE=[1, 5]				, SCREAMING_SNAKE_CASE=[5, 4]				, ):
  
  
  
  					"""simple docstring"""
  
  
  
  
  
  
  
  					pass
  
  
  
  
  
  
  
  class 			lowerCamelCase__    (  unittest.TestCase			):
  
  
  			def 							lowerCamelCase_				(     self							):
  
  
  
  					"""simple docstring"""
  
  
  
  
  
  
  
  					with self.assertRaises(SCREAMING_SNAKE_CASE							):
  							ConfigMixin.load_config("dummy_path"							)
  
  
  			def 							lowerCamelCase_				(     self							):
  
  
  
  					"""simple docstring"""
  
  
  
  
  
  
  
  					snake_case		:						Dict								=				SampleObject()
  					snake_case		:						Dict								=				obj.config
  					assert config["a"] == 2
  					assert config["b"] == 5
  					assert config["c"] == (2, 5)
  					assert config["d"] == "for diffusion"
  					assert config["e"] == [1, 3]
  
  					# init ignore private arguments
  					snake_case		:						Dict								=				SampleObject(_name_or_path="lalala"							)
  					snake_case		:						List[Any]								=				obj.config
  					assert config["a"] == 2
  					assert config["b"] == 5
  					assert config["c"] == (2, 5)
  					assert config["d"] == "for diffusion"
  					assert config["e"] == [1, 3]
  
  					# can override default
  					snake_case		:						str								=				SampleObject(c=6							)
  					snake_case		:						Any								=				obj.config
  					assert config["a"] == 2
  					assert config["b"] == 5
  					assert config["c"] == 6
  					assert config["d"] == "for diffusion"
  					assert config["e"] == [1, 3]
  
  					# can use positional arguments.
  					snake_case		:						int								=				SampleObject(1				, c=6							)
  					snake_case		:						Dict								=				obj.config
  					assert config["a"] == 1
  					assert config["b"] == 5
  					assert config["c"] == 6
  					assert config["d"] == "for diffusion"
  					assert config["e"] == [1, 3]
  
  
  			def 							lowerCamelCase_				(     self							):
  
  
  
  					"""simple docstring"""
  
  
  
  
  
  
  
  					snake_case		:						str								=				SampleObject()
  					snake_case		:						List[str]								=				obj.config
  
  					assert config["a"] == 2
  					assert config["b"] == 5
  					assert config["c"] == (2, 5)
  					assert config["d"] == "for diffusion"
  					assert config["e"] == [1, 3]
  
  					with tempfile.TemporaryDirectory() as tmpdirname:
  							obj.save_config(SCREAMING_SNAKE_CASE							)
  							snake_case		:						Union[str, Any]								=				SampleObject.from_config(SampleObject.load_config(SCREAMING_SNAKE_CASE							)							)
  							snake_case		:						Union[str, Any]								=				new_obj.config
  
  					# unfreeze configs
  					snake_case		:						List[str]								=				dict(SCREAMING_SNAKE_CASE							)
  					snake_case		:						Union[str, Any]								=				dict(SCREAMING_SNAKE_CASE							)
  
  					assert config.pop("c"							) == (2, 5)  # instantiated as tuple
  					assert new_config.pop("c"							) == [2, 5]  # saved & loaded as list because of json
  					config.pop("_use_default_values"							)
  					assert config == new_config
  
  
  			def 							lowerCamelCase_				(     self							):
  
  
  
  					"""simple docstring"""
  
  
  
  
  
  
  
  					snake_case		:						List[Any]								=				logging.get_logger("diffusers.configuration_utils"							)
  					# 30 for warning
  					logger.setLevel(30							)
  
  					with CaptureLogger(SCREAMING_SNAKE_CASE							) as cap_logger:
  							snake_case		:						Any								=				DDIMScheduler.from_pretrained(
  							    "hf-internal-testing/tiny-stable-diffusion-torch"				, subfolder="scheduler"							)
  
  					assert ddim.__class__ == DDIMScheduler
  					# no warning should be thrown
  					assert cap_logger.out == ""
  
  
  			def 							lowerCamelCase_				(     self							):
  
  
  
  					"""simple docstring"""
  
  
  
  
  
  
  
  					snake_case		:						int								=				logging.get_logger("diffusers.configuration_utils"							)
  					# 30 for warning
  					logger.setLevel(30							)
  
  					with CaptureLogger(SCREAMING_SNAKE_CASE							) as cap_logger:
  							snake_case		:						Optional[int]								=				EulerDiscreteScheduler.from_pretrained(
  							    "hf-internal-testing/tiny-stable-diffusion-torch"				, subfolder="scheduler"							)
  
  					assert euler.__class__ == EulerDiscreteScheduler
  					# no warning should be thrown
  					assert cap_logger.out == ""
  
  
  			def 							lowerCamelCase_				(     self							):
  
  
  
  					"""simple docstring"""
  
  
  
  
  
  
  
  					snake_case		:						Any								=				logging.get_logger("diffusers.configuration_utils"							)
  					# 30 for warning
  					logger.setLevel(30							)
  
  					with CaptureLogger(SCREAMING_SNAKE_CASE							) as cap_logger:
  							snake_case		:						Union[str, Any]								=				EulerAncestralDiscreteScheduler.from_pretrained(
  							    "hf-internal-testing/tiny-stable-diffusion-torch"				, subfolder="scheduler"							)
  
  					assert euler.__class__ == EulerAncestralDiscreteScheduler
  					# no warning should be thrown
  					assert cap_logger.out == ""
  
  
  			def 							lowerCamelCase_				(     self							):
  
  
  
  					"""simple docstring"""
  
  
  
  
  
  
  
  					snake_case		:						Union[str, Any]								=				logging.get_logger("diffusers.configuration_utils"							)
  					# 30 for warning
  					logger.setLevel(30							)
  
  					with CaptureLogger(SCREAMING_SNAKE_CASE							) as cap_logger:
  							snake_case		:						List[Any]								=				PNDMScheduler.from_pretrained(
  							    "hf-internal-testing/tiny-stable-diffusion-torch"				, subfolder="scheduler"							)
  
  					assert pndm.__class__ == PNDMScheduler
  					# no warning should be thrown
  					assert cap_logger.out == ""
  
  
  			def 							lowerCamelCase_				(     self							):
  
  
  
  					"""simple docstring"""
  
  
  
  
  
  
  
  					snake_case		:						str								=				logging.get_logger("diffusers.configuration_utils"							)
  					# 30 for warning
  					logger.setLevel(30							)
  
  					with CaptureLogger(SCREAMING_SNAKE_CASE							) as cap_logger:
  							snake_case		:						List[Any]								=				DDPMScheduler.from_pretrained(
  							    "hf-internal-testing/tiny-stable-diffusion-torch"				, subfolder="scheduler"				, prediction_type="sample"				, beta_end=8				, )
  
  					with CaptureLogger(SCREAMING_SNAKE_CASE							) as cap_logger_a:
  							snake_case		:						Optional[int]								=				DDPMScheduler.from_pretrained("google/ddpm-celebahq-256"				, beta_start=88							)
  
  					assert ddpm.__class__ == DDPMScheduler
  					assert ddpm.config.prediction_type == "sample"
  					assert ddpm.config.beta_end == 8
  					assert ddpm_a.config.beta_start == 88
  
  					# no warning should be thrown
  					assert cap_logger.out == ""
  					assert cap_logger_a.out == ""
  
  
  			def 							lowerCamelCase_				(     self							):
  
  
  
  					"""simple docstring"""
  
  
  
  
  
  
  
  					snake_case		:						Dict								=				logging.get_logger("diffusers.configuration_utils"							)
  					# 30 for warning
  					logger.setLevel(30							)
  
  					with CaptureLogger(SCREAMING_SNAKE_CASE							) as cap_logger:
  							snake_case		:						Union[str, Any]								=				DPMSolverMultistepScheduler.from_pretrained(
  							    "hf-internal-testing/tiny-stable-diffusion-torch"				, subfolder="scheduler"							)
  
  					assert dpm.__class__ == DPMSolverMultistepScheduler
  					# no warning should be thrown
  					assert cap_logger.out == ""
  
  
  
  			def 							lowerCamelCase_				(     self							):
  
  
  
  					"""simple docstring"""
  
  
  
  
  
  
  
  					snake_case		:						Optional[Any]								=				SampleObject()
  
  					snake_case		:						str								=				{k: v for k, v in config.config.items() if not k.startswith("_"							)}
  
  					# make sure that default config has all keys in `_use_default_values`
  					assert set(config_dict.keys()							) == set(config.config._use_default_values							)
  
  					with tempfile.TemporaryDirectory() as tmpdirname:
  							config.save_config(SCREAMING_SNAKE_CASE							)
  
  							# now loading it with SampleObject2 should put f into `_use_default_values`
  							snake_case		:						Optional[int]								=				SampleObjecta.from_config(SCREAMING_SNAKE_CASE							)
  
  							assert "f" in config._use_default_values
  							assert config.f == [1, 3]
  
  					# now loading the config, should **NOT** use [1, 3] for `f`, but the default [1, 4] value
  					# **BECAUSE** it is part of `config._use_default_values`
  					snake_case		:						Tuple								=				SampleObjecta.from_config(config.config							)
  					assert new_config.f == [5, 4]
  
  					config.config._use_default_values.pop()
  					snake_case		:						List[Any]								=				SampleObjecta.from_config(config.config							)
  					assert new_config_a.f == [1, 3]
  
  					# Nevertheless "e" should still be correctly loaded to [1, 3] from SampleObject2 instead of defaulting to [1, 5]
  					assert new_config_a.e == [1, 3]
  
  