

# This model implementation is heavily based on:

import gc
import random
import tempfile
import unittest

import numpy as np
import torch
from PIL import Image
from transformers import CLIPTextConfig, CLIPTextModel, CLIPTokenizer

from diffusers import (
    AutoencoderKL,
    ControlNetModel,
    DDIMScheduler,
    StableDiffusionControlNetInpaintPipeline,
    UNetaDConditionModel,
)
from diffusers.pipelines.stable_diffusion.pipeline_stable_diffusion_controlnet import MultiControlNetModel
from diffusers.utils import floats_tensor, load_image, load_numpy, randn_tensor, slow, torch_device
from diffusers.utils.import_utils import is_xformers_available
from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu

from ..pipeline_params import (
    TEXT_GUIDED_IMAGE_INPAINTING_BATCH_PARAMS,
    TEXT_GUIDED_IMAGE_INPAINTING_PARAMS,
    TEXT_TO_IMAGE_IMAGE_PARAMS,
)
from ..test_pipelines_common import (
    PipelineKarrasSchedulerTesterMixin,
    PipelineLatentTesterMixin,
    PipelineTesterMixin,
)


enable_full_determinism()



class 					__snake_case     (			lowerCAmelCase__   ,       lowerCAmelCase__   ,       lowerCAmelCase__   ,       unittest.TestCase				):
  __lowerCAmelCase   :		Any         =     StableDiffusionControlNetInpaintPipeline
  __lowerCAmelCase   :		Any         =     TEXT_GUIDED_IMAGE_INPAINTING_PARAMS
  __lowerCAmelCase   :		Optional[int]         =     TEXT_GUIDED_IMAGE_INPAINTING_BATCH_PARAMS
  __lowerCAmelCase   :		str         =     frozenset({'control_image'}				)  # skip `image` and `mask` for now, only test for control_image
  __lowerCAmelCase   :		Union[str, Any]         =     TEXT_TO_IMAGE_IMAGE_PARAMS

  def   lowerCAmelCase__   (    self):
      torch.manual_seed(0)
      SCREAMING_SNAKE_CASE_													=  UNetaDConditionModel(
          block_out_channels=(32, 64)  ,						layers_per_block=2  ,						sample_size=32  ,						in_channels=9  ,						out_channels=4  ,						down_block_types=('DownBlock2D', 'CrossAttnDownBlock2D')  ,						up_block_types=('CrossAttnUpBlock2D', 'UpBlock2D')  ,						cross_attention_dim=32  ,						)
      torch.manual_seed(0)
      SCREAMING_SNAKE_CASE_													=  ControlNetModel(
          block_out_channels=(32, 64)  ,						layers_per_block=2  ,						in_channels=4  ,						down_block_types=('DownBlock2D', 'CrossAttnDownBlock2D')  ,						cross_attention_dim=32  ,						conditioning_embedding_out_channels=(16, 32)  ,						)
      torch.manual_seed(0)
      SCREAMING_SNAKE_CASE_													=  DDIMScheduler(
          beta_start=0.0_0_0_8_5  ,						beta_end=0.0_1_2  ,						beta_schedule='scaled_linear'  ,						clip_sample=_A  ,						set_alpha_to_one=_A  ,						)
      torch.manual_seed(0)
      SCREAMING_SNAKE_CASE_													=  AutoencoderKL(
          block_out_channels=[32, 64]  ,						in_channels=3  ,						out_channels=3  ,						down_block_types=['DownEncoderBlock2D', 'DownEncoderBlock2D']  ,						up_block_types=['UpDecoderBlock2D', 'UpDecoderBlock2D']  ,						latent_channels=4  ,						)
      torch.manual_seed(0)
      SCREAMING_SNAKE_CASE_													=  CLIPTextConfig(
          bos_token_id=0  ,						eos_token_id=2  ,						hidden_size=32  ,						intermediate_size=37  ,						layer_norm_eps=1E-05  ,						num_attention_heads=4  ,						num_hidden_layers=5  ,						pad_token_id=1  ,						vocab_size=1000  ,						)
      SCREAMING_SNAKE_CASE_													=  CLIPTextModel(_A)
      SCREAMING_SNAKE_CASE_													=  CLIPTokenizer.from_pretrained('hf-internal-testing/tiny-random-clip')

      SCREAMING_SNAKE_CASE_													=  {
          'unet': unet,
          'controlnet': controlnet,
          'scheduler': scheduler,
          'vae': vae,
          'text_encoder': text_encoder,
          'tokenizer': tokenizer,
          'safety_checker': None,
          'feature_extractor': None,
      }
      return components

  def   lowerCAmelCase__   (    self  ,						_A  ,						_A=0):
      if str(_A).startswith('mps'):
          SCREAMING_SNAKE_CASE_													=  torch.manual_seed(_A)
      else:
          SCREAMING_SNAKE_CASE_													=  torch.Generator(device=_A).manual_seed(_A)

      SCREAMING_SNAKE_CASE_													=  2
      SCREAMING_SNAKE_CASE_													=  randn_tensor(
          (1, 3, 32 * controlnet_embedder_scale_factor, 32 * controlnet_embedder_scale_factor)  ,						generator=_A  ,						device=torch.device(_A)  ,						)
      SCREAMING_SNAKE_CASE_													=  floats_tensor((1, 3, 32, 32)  ,						rng=random.Random(_A)).to(_A)
      SCREAMING_SNAKE_CASE_													=  init_image.cpu().permute(0  ,						2  ,						3  ,						1)[0]

      SCREAMING_SNAKE_CASE_													=  Image.fromarray(np.uinta(_A)).convert('RGB').resize((64, 64))
      SCREAMING_SNAKE_CASE_													=  Image.fromarray(np.uinta(init_image + 4)).convert('RGB').resize((64, 64))

      SCREAMING_SNAKE_CASE_													=  {
          'prompt': 'A painting of a squirrel eating a burger',
          'generator': generator,
          'num_inference_steps': 2,
          'guidance_scale': 6.0,
          'output_type': 'numpy',
          'image': image,
          'mask_image': mask_image,
          'control_image': control_image,
      }

      return inputs

  def   lowerCAmelCase__   (    self):
      return self._test_attention_slicing_forward_pass(expected_max_diff=2E-3)

  @unittest.skipIf(
      torch_device != 'cuda' or not is_xformers_available()  ,						reason='XFormers attention is only available with CUDA and `xformers` installed'  ,						)
  def   lowerCAmelCase__   (    self):
      self._test_xformers_attention_forwardGenerator_pass(expected_max_diff=2E-3)


  def   lowerCAmelCase__   (    self):
      self._test_inference_batch_single_identical(expected_max_diff=2E-3)






class 					__snake_case     (			lowerCAmelCase__				):
  __lowerCAmelCase   :		List[str]         =     StableDiffusionControlNetInpaintPipeline
  __lowerCAmelCase   :		Tuple         =     TEXT_GUIDED_IMAGE_INPAINTING_PARAMS
  __lowerCAmelCase   :		Any         =     TEXT_GUIDED_IMAGE_INPAINTING_BATCH_PARAMS
  __lowerCAmelCase   :		Tuple         =     frozenset([]				)

  def   lowerCAmelCase__   (    self):
      torch.manual_seed(0)
      SCREAMING_SNAKE_CASE_													=  UNetaDConditionModel(
          block_out_channels=(32, 64)  ,						layers_per_block=2  ,						sample_size=32  ,						in_channels=4  ,						out_channels=4  ,						down_block_types=('DownBlock2D', 'CrossAttnDownBlock2D')  ,						up_block_types=('CrossAttnUpBlock2D', 'UpBlock2D')  ,						cross_attention_dim=32  ,						)
      torch.manual_seed(0)
      SCREAMING_SNAKE_CASE_													=  ControlNetModel(
          block_out_channels=(32, 64)  ,						layers_per_block=2  ,						in_channels=4  ,						down_block_types=('DownBlock2D', 'CrossAttnDownBlock2D')  ,						cross_attention_dim=32  ,						conditioning_embedding_out_channels=(16, 32)  ,						)
      torch.manual_seed(0)
      SCREAMING_SNAKE_CASE_													=  DDIMScheduler(
          beta_start=0.0_0_0_8_5  ,						beta_end=0.0_1_2  ,						beta_schedule='scaled_linear'  ,						clip_sample=_A  ,						set_alpha_to_one=_A  ,						)
      torch.manual_seed(0)
      SCREAMING_SNAKE_CASE_													=  AutoencoderKL(
          block_out_channels=[32, 64]  ,						in_channels=3  ,						out_channels=3  ,						down_block_types=['DownEncoderBlock2D', 'DownEncoderBlock2D']  ,						up_block_types=['UpDecoderBlock2D', 'UpDecoderBlock2D']  ,						latent_channels=4  ,						)
      torch.manual_seed(0)
      SCREAMING_SNAKE_CASE_													=  CLIPTextConfig(
          bos_token_id=0  ,						eos_token_id=2  ,						hidden_size=32  ,						intermediate_size=37  ,						layer_norm_eps=1E-05  ,						num_attention_heads=4  ,						num_hidden_layers=5  ,						pad_token_id=1  ,						vocab_size=1000  ,						)
      SCREAMING_SNAKE_CASE_													=  CLIPTextModel(_A)
      SCREAMING_SNAKE_CASE_													=  CLIPTokenizer.from_pretrained('hf-internal-testing/tiny-random-clip')

      SCREAMING_SNAKE_CASE_													=  {
          'unet': unet,
          'controlnet': controlnet,
          'scheduler': scheduler,
          'vae': vae,
          'text_encoder': text_encoder,
          'tokenizer': tokenizer,
          'safety_checker': None,
          'feature_extractor': None,
      }
      return components






class 					__snake_case     (			lowerCAmelCase__   ,       lowerCAmelCase__   ,       unittest.TestCase				):
  __lowerCAmelCase   :		Optional[int]         =     StableDiffusionControlNetInpaintPipeline
  __lowerCAmelCase   :		Dict         =     TEXT_GUIDED_IMAGE_INPAINTING_PARAMS
  __lowerCAmelCase   :		Tuple         =     TEXT_GUIDED_IMAGE_INPAINTING_BATCH_PARAMS

  def   lowerCAmelCase__   (    self):
      torch.manual_seed(0)
      SCREAMING_SNAKE_CASE_													=  UNetaDConditionModel(
          block_out_channels=(32, 64)  ,						layers_per_block=2  ,						sample_size=32  ,						in_channels=9  ,						out_channels=4  ,						down_block_types=('DownBlock2D', 'CrossAttnDownBlock2D')  ,						up_block_types=('CrossAttnUpBlock2D', 'UpBlock2D')  ,						cross_attention_dim=32  ,						)
      torch.manual_seed(0)

      def init_weights(_A):
          if isinstance(_A  ,						torch.nn.Convad):
              torch.nn.init.normal(m.weight)
              m.bias.data.fill_(1.0)

      SCREAMING_SNAKE_CASE_													=  ControlNetModel(
          block_out_channels=(32, 64)  ,						layers_per_block=2  ,						in_channels=4  ,						down_block_types=('DownBlock2D', 'CrossAttnDownBlock2D')  ,						cross_attention_dim=32  ,						conditioning_embedding_out_channels=(16, 32)  ,						)
      controlneta.controlnet_down_blocks.apply(_A)

      torch.manual_seed(0)
      SCREAMING_SNAKE_CASE_													=  ControlNetModel(
          block_out_channels=(32, 64)  ,						layers_per_block=2  ,						in_channels=4  ,						down_block_types=('DownBlock2D', 'CrossAttnDownBlock2D')  ,						cross_attention_dim=32  ,						conditioning_embedding_out_channels=(16, 32)  ,						)
      controlneta.controlnet_down_blocks.apply(_A)

      torch.manual_seed(0)
      SCREAMING_SNAKE_CASE_													=  DDIMScheduler(
          beta_start=0.0_0_0_8_5  ,						beta_end=0.0_1_2  ,						beta_schedule='scaled_linear'  ,						clip_sample=_A  ,						set_alpha_to_one=_A  ,						)
      torch.manual_seed(0)
      SCREAMING_SNAKE_CASE_													=  AutoencoderKL(
          block_out_channels=[32, 64]  ,						in_channels=3  ,						out_channels=3  ,						down_block_types=['DownEncoderBlock2D', 'DownEncoderBlock2D']  ,						up_block_types=['UpDecoderBlock2D', 'UpDecoderBlock2D']  ,						latent_channels=4  ,						)
      torch.manual_seed(0)
      SCREAMING_SNAKE_CASE_													=  CLIPTextConfig(
          bos_token_id=0  ,						eos_token_id=2  ,						hidden_size=32  ,						intermediate_size=37  ,						layer_norm_eps=1E-05  ,						num_attention_heads=4  ,						num_hidden_layers=5  ,						pad_token_id=1  ,						vocab_size=1000  ,						)
      SCREAMING_SNAKE_CASE_													=  CLIPTextModel(_A)
      SCREAMING_SNAKE_CASE_													=  CLIPTokenizer.from_pretrained('hf-internal-testing/tiny-random-clip')

      SCREAMING_SNAKE_CASE_													=  MultiControlNetModel([controlneta, controlneta])

      SCREAMING_SNAKE_CASE_													=  {
          'unet': unet,
          'controlnet': controlnet,
          'scheduler': scheduler,
          'vae': vae,
          'text_encoder': text_encoder,
          'tokenizer': tokenizer,
          'safety_checker': None,
          'feature_extractor': None,
      }
      return components

  def   lowerCAmelCase__   (    self  ,						_A  ,						_A=0):
      if str(_A).startswith('mps'):
          SCREAMING_SNAKE_CASE_													=  torch.manual_seed(_A)
      else:
          SCREAMING_SNAKE_CASE_													=  torch.Generator(device=_A).manual_seed(_A)

      SCREAMING_SNAKE_CASE_													=  2

      SCREAMING_SNAKE_CASE_													=  [
          randn_tensor(
              (1, 3, 32 * controlnet_embedder_scale_factor, 32 * controlnet_embedder_scale_factor)  ,						generator=_A  ,						device=torch.device(_A)  ,						),
          randn_tensor(
              (1, 3, 32 * controlnet_embedder_scale_factor, 32 * controlnet_embedder_scale_factor)  ,						generator=_A  ,						device=torch.device(_A)  ,						),
      ]
      SCREAMING_SNAKE_CASE_													=  floats_tensor((1, 3, 32, 32)  ,						rng=random.Random(_A)).to(_A)
      SCREAMING_SNAKE_CASE_													=  init_image.cpu().permute(0  ,						2  ,						3  ,						1)[0]

      SCREAMING_SNAKE_CASE_													=  Image.fromarray(np.uinta(_A)).convert('RGB').resize((64, 64))
      SCREAMING_SNAKE_CASE_													=  Image.fromarray(np.uinta(init_image + 4)).convert('RGB').resize((64, 64))

      SCREAMING_SNAKE_CASE_													=  {
          'prompt': 'A painting of a squirrel eating a burger',
          'generator': generator,
          'num_inference_steps': 2,
          'guidance_scale': 6.0,
          'output_type': 'numpy',
          'image': image,
          'mask_image': mask_image,
          'control_image': control_image,
      }

      return inputs

  def   lowerCAmelCase__   (    self):
      SCREAMING_SNAKE_CASE_													=  self.get_dummy_components()
      SCREAMING_SNAKE_CASE_													=  self.pipeline_class(**_A)
      pipe.to(_A)

      SCREAMING_SNAKE_CASE_													=  1_0.0
      SCREAMING_SNAKE_CASE_													=  4

      SCREAMING_SNAKE_CASE_													=  self.get_dummy_inputs(_A)
      SCREAMING_SNAKE_CASE_													=  steps
      SCREAMING_SNAKE_CASE_													=  scale
      SCREAMING_SNAKE_CASE_													=  pipe(**_A)[0]

      SCREAMING_SNAKE_CASE_													=  self.get_dummy_inputs(_A)
      SCREAMING_SNAKE_CASE_													=  steps
      SCREAMING_SNAKE_CASE_													=  scale
      SCREAMING_SNAKE_CASE_													=  pipe(**_A  ,						control_guidance_start=0.1  ,						control_guidance_end=0.2)[0]

      SCREAMING_SNAKE_CASE_													=  self.get_dummy_inputs(_A)
      SCREAMING_SNAKE_CASE_													=  steps
      SCREAMING_SNAKE_CASE_													=  scale
      SCREAMING_SNAKE_CASE_													=  pipe(**_A  ,						control_guidance_start=[0.1, 0.3]  ,						control_guidance_end=[0.2, 0.7])[0]

      SCREAMING_SNAKE_CASE_													=  self.get_dummy_inputs(_A)
      SCREAMING_SNAKE_CASE_													=  steps
      SCREAMING_SNAKE_CASE_													=  scale
      SCREAMING_SNAKE_CASE_													=  pipe(**_A  ,						control_guidance_start=0.4  ,						control_guidance_end=[0.5, 0.8])[0]

      # make sure that all outputs are different
      assert np.sum(np.abs(output_a - output_a)) > 1E-3
      assert np.sum(np.abs(output_a - output_a)) > 1E-3
      assert np.sum(np.abs(output_a - output_a)) > 1E-3

  def   lowerCAmelCase__   (    self):
      return self._test_attention_slicing_forward_pass(expected_max_diff=2E-3)

  @unittest.skipIf(
      torch_device != 'cuda' or not is_xformers_available()  ,						reason='XFormers attention is only available with CUDA and `xformers` installed'  ,						)
  def   lowerCAmelCase__   (    self):
      self._test_xformers_attention_forwardGenerator_pass(expected_max_diff=2E-3)

  def   lowerCAmelCase__   (    self):
      self._test_inference_batch_single_identical(expected_max_diff=2E-3)


  def   lowerCAmelCase__   (    self):
      SCREAMING_SNAKE_CASE_													=  self.get_dummy_components()
      SCREAMING_SNAKE_CASE_													=  self.pipeline_class(**_A)
      pipe.to(_A)
      pipe.set_progress_bar_config(disable=_A)
      with tempfile.TemporaryDirectory() as tmpdir:
          try:
              # save_pretrained is not implemented for Multi-ControlNet
              pipe.save_pretrained(_A)
          except NotImplementedError:
              pass






@slow
@require_torch_gpu
class 					__snake_case     (			unittest.TestCase				):

  def   lowerCAmelCase__   (    self):
      super().tearDown()
      gc.collect()
      torch.cuda.empty_cache()

  def   lowerCAmelCase__   (    self):
      SCREAMING_SNAKE_CASE_													=  ControlNetModel.from_pretrained('lllyasviel/sd-controlnet-canny')

      SCREAMING_SNAKE_CASE_													=  StableDiffusionControlNetInpaintPipeline.from_pretrained(
          'runwayml/stable-diffusion-inpainting'  ,						safety_checker=_A  ,						controlnet=_A)
      pipe.enable_model_cpu_offload()
      pipe.set_progress_bar_config(disable=_A)

      SCREAMING_SNAKE_CASE_													=  torch.Generator(device='cpu').manual_seed(0)
      SCREAMING_SNAKE_CASE_													=  load_image(
          'https://huggingface.co/lllyasviel/sd-controlnet-canny/resolve/main/images/bird.png').resize((512, 512))

      SCREAMING_SNAKE_CASE_													=  load_image(
          'https://huggingface.co/datasets/diffusers/test-arrays/resolve/main'
          '/stable_diffusion_inpaint/input_bench_mask.png').resize((512, 512))

      SCREAMING_SNAKE_CASE_													=  'pitch black hole'

      SCREAMING_SNAKE_CASE_													=  load_image(
          'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/sd_controlnet/bird_canny.png').resize((512, 512))

      SCREAMING_SNAKE_CASE_													=  pipe(
          _A  ,						image=_A  ,						mask_image=_A  ,						control_image=_A  ,						generator=_A  ,						output_type='np'  ,						num_inference_steps=3  ,						)

      SCREAMING_SNAKE_CASE_													=  output.images[0]

      assert image.shape == (512, 512, 3)

      SCREAMING_SNAKE_CASE_													=  load_numpy(
          'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/sd_controlnet/inpaint.npy')

      assert np.abs(expected_image - image).max() < 9E-2


  def   lowerCAmelCase__   (    self):
      SCREAMING_SNAKE_CASE_													=  ControlNetModel.from_pretrained('lllyasviel/control_v11p_sd15_inpaint')

      SCREAMING_SNAKE_CASE_													=  StableDiffusionControlNetInpaintPipeline.from_pretrained(
          'runwayml/stable-diffusion-v1-5'  ,						safety_checker=_A  ,						controlnet=_A)
      SCREAMING_SNAKE_CASE_													=  DDIMScheduler.from_config(pipe.scheduler.config)
      pipe.enable_model_cpu_offload()
      pipe.set_progress_bar_config(disable=_A)

      SCREAMING_SNAKE_CASE_													=  torch.Generator(device='cpu').manual_seed(33)

      SCREAMING_SNAKE_CASE_													=  load_image(
          'https://huggingface.co/datasets/diffusers/test-arrays/resolve/main/stable_diffusion_inpaint/boy.png')
      SCREAMING_SNAKE_CASE_													=  init_image.resize((512, 512))

      SCREAMING_SNAKE_CASE_													=  load_image(
          'https://huggingface.co/datasets/diffusers/test-arrays/resolve/main/stable_diffusion_inpaint/boy_mask.png')
      SCREAMING_SNAKE_CASE_													=  mask_image.resize((512, 512))

      SCREAMING_SNAKE_CASE_													=  'a handsome man with ray-ban sunglasses'

      def make_inpaint_condition(_A  ,						_A):
          SCREAMING_SNAKE_CASE_													=  np.array(image.convert('RGB')).astype(np.floataa) / 2_5_5.0
          SCREAMING_SNAKE_CASE_													=  np.array(image_mask.convert('L')).astype(np.floataa) / 2_5_5.0

          assert image.shape[0:1] == image_mask.shape[0:1], "image and image_mask must have the same image size"
          SCREAMING_SNAKE_CASE_													=  -1.0  # set as masked pixel
          SCREAMING_SNAKE_CASE_													=  np.expand_dims(_A  ,						0).transpose(0  ,						3  ,						1  ,						2)
          SCREAMING_SNAKE_CASE_													=  torch.from_numpy(_A)
          return image

      SCREAMING_SNAKE_CASE_													=  make_inpaint_condition(_A  ,						_A)

      SCREAMING_SNAKE_CASE_													=  pipe(
          _A  ,						image=_A  ,						mask_image=_A  ,						control_image=_A  ,						guidance_scale=9.0  ,						eta=1.0  ,						generator=_A  ,						num_inference_steps=20  ,						output_type='np'  ,						)
      SCREAMING_SNAKE_CASE_													=  output.images[0]

      assert image.shape == (512, 512, 3)

      SCREAMING_SNAKE_CASE_													=  load_numpy(
          'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/sd_controlnet/boy_ray_ban.npy')

      assert np.abs(expected_image - image).max() < 9E-2





import argparse
import json

from transformers import GPTNeoConfig, GPTNeoForCausalLM, load_tf_weights_in_gpt_neo
from transformers.utils import logging


logging.set_verbosity_info()


def     _UpperCAmelCase				(     _SCREAMING_SNAKE_CASE    :						int       ,      _SCREAMING_SNAKE_CASE    :						Tuple       ,      _SCREAMING_SNAKE_CASE    :						Union[str, Any]				):





    """simple docstring"""


    SCREAMING_SNAKE_CASE_													=  json.load(open(_SCREAMING_SNAKE_CASE       ,      'r'				)				)
    SCREAMING_SNAKE_CASE_													=  GPTNeoConfig(
        hidden_size=config_json['n_embd']       ,      num_layers=config_json['n_layer']       ,      num_heads=config_json['n_head']       ,      attention_types=config_json['attention_types']       ,      max_position_embeddings=config_json['n_positions']       ,      resid_dropout=config_json['res_dropout']       ,      embed_dropout=config_json['embed_dropout']       ,      attention_dropout=config_json['attn_dropout']       ,      )
    print(f"""Building PyTorch model from configuration: {config}"""				)
    SCREAMING_SNAKE_CASE_													=  GPTNeoForCausalLM(_SCREAMING_SNAKE_CASE				)

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

    # Save pytorch-model
    print(f"""Save PyTorch model to {pytorch_dump_path}"""				)
    model.save_pretrained(_SCREAMING_SNAKE_CASE				)


if __name__ == "__main__":
       UpperCamelCase__     :					Tuple								=			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 mesh-tf 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."
       )
       UpperCamelCase__     :					Any								=			parser.parse_args()
       convert_tf_checkpoint_to_pytorch(args.tf_checkpoint_path, args.config_file, args.pytorch_dump_path)


