


import json
import os
import tempfile
from unittest.mock import patch

import torch
from torch.utils.data import DataLoader, TensorDataset

from accelerate import DistributedType, infer_auto_device_map, init_empty_weights
from accelerate.accelerator import Accelerator
from accelerate.state import GradientState, PartialState
from accelerate.test_utils import require_bnb, require_multi_gpu, slow
from accelerate.test_utils.testing import AccelerateTestCase, require_cuda
from accelerate.utils import patch_environment






def 					UpperCamelCase   (      )  ->    Tuple:
		"""simple docstring"""




		lowercase__	     =						torch.nn.Linear(2       ,       4	)
		lowercase__	     =						torch.optim.AdamW(model.parameters()       ,       lr=1.0	)
		lowercase__	     =						torch.optim.lr_scheduler.OneCycleLR(__magic_name__       ,       max_lr=0.0_1       ,       steps_per_epoch=2       ,       epochs=1	)
		lowercase__	     =						DataLoader(TensorDataset(torch.tensor([1, 2, 3]	)	)	)
		lowercase__	     =						DataLoader(TensorDataset(torch.tensor([4, 5, 6]	)	)	)

		return model, optimizer, scheduler, train_dl, valid_dl






def 					UpperCamelCase   (      __magic_name__	:				Union[str, Any]	)  ->    Optional[int]:
		"""simple docstring"""




		return (model.weight.abs().sum() + model.bias.abs().sum()).item()






def 					UpperCamelCase   (      __magic_name__	:				Tuple	)  ->    int:
		"""simple docstring"""




		lowercase__	     =						torch.nn.Linear(*tuple(model.weight.T.shape	)	).state_dict()
		model.load_state_dict(__magic_name__	)







class 				A       (			UpperCAmelCase__				):
					'''simple docstring'''






					@require_cuda
					def     lowerCamelCase__	(self       :		List[Any]						)		->  List[str]:




							"""simple docstring"""


							lowercase__	     =						Accelerator()
							assert PartialState._shared_state["_cpu"] is False
							assert PartialState._shared_state["device"].type == "cuda"
							with self.assertRaises(_UpperCAmelCase						):
									lowercase__	     =						Accelerator(cpu=_UpperCAmelCase						)

					def     lowerCamelCase__	(self       :		int						)		->  List[str]:




							"""simple docstring"""


							lowercase__	     =						Accelerator()
							lowercase__	     =						GradientState()
							assert state.num_steps == 1
							lowercase__	     =						4
							assert state.num_steps == 4

							assert state.sync_gradients is True
							lowercase__	     =						False
							assert state.sync_gradients is False
							GradientState._reset_state()

					def     lowerCamelCase__	(self       :		Optional[int]						)		->  List[str]:




							"""simple docstring"""


							lowercase__	     =						Accelerator()
							lowercase__     ,      lowercase__     ,      lowercase__     ,      lowercase__     ,      lowercase__	     =						create_components()

							(
							    (
							    lowercase__
							)     ,      (
							    lowercase__
							)     ,      (
							    lowercase__
							)     ,      (
							    lowercase__
							)     ,      (
							    lowercase__
							)     ,      
							)	     =						accelerator.prepare(_UpperCAmelCase ,   _UpperCAmelCase ,   _UpperCAmelCase ,   _UpperCAmelCase ,   _UpperCAmelCase						)

							self.assertTrue(prepared_model in accelerator._models						)
							self.assertTrue(prepared_optimizer in accelerator._optimizers						)
							self.assertTrue(prepared_scheduler in accelerator._schedulers						)
							self.assertTrue(prepared_train_dl in accelerator._dataloaders						)
							self.assertTrue(prepared_valid_dl in accelerator._dataloaders						)

					def     lowerCamelCase__	(self       :		List[str]						)		->  Union[str, Any]:




							"""simple docstring"""


							lowercase__	     =						Accelerator()
							lowercase__     ,      lowercase__     ,      lowercase__     ,      lowercase__     ,      lowercase__	     =						create_components()
							accelerator.prepare(_UpperCAmelCase ,   _UpperCAmelCase ,   _UpperCAmelCase ,   _UpperCAmelCase ,   _UpperCAmelCase						)
							accelerator.free_memory()

							self.assertTrue(len(accelerator._models						) == 0						)
							self.assertTrue(len(accelerator._optimizers						) == 0						)
							self.assertTrue(len(accelerator._schedulers						) == 0						)
							self.assertTrue(len(accelerator._dataloaders						) == 0						)

					def     lowerCamelCase__	(self       :		List[str]						)		->  Tuple:




							"""simple docstring"""


							PartialState._reset_state()

							# Mock torch.cuda.set_device to avoid an exception as the device doesn't exist
							def noop(*_UpperCAmelCase       :		List[str] ,   **_UpperCAmelCase       :		str						):
									pass

							with patch("""torch.cuda.set_device""" ,   _UpperCAmelCase						), patch_environment(ACCELERATE_TORCH_DEVICE="""cuda:64"""						):
									lowercase__	     =						Accelerator()
									self.assertEqual(str(accelerator.state.device						) ,   """cuda:64"""						)

					def     lowerCamelCase__	(self       :		List[Any]						)		->  Dict:




							"""simple docstring"""


							lowercase__	     =						Accelerator()
							lowercase__     ,      lowercase__     ,      lowercase__     ,      lowercase__     ,      lowercase__	     =						create_components()
							accelerator.prepare(_UpperCAmelCase ,   _UpperCAmelCase ,   _UpperCAmelCase ,   _UpperCAmelCase ,   _UpperCAmelCase						)

							lowercase__	     =						get_signature(_UpperCAmelCase						)

							with tempfile.TemporaryDirectory() as tmpdirname:
									accelerator.save_state(_UpperCAmelCase						)

									# make sure random weights don't match
									load_random_weights(_UpperCAmelCase						)
									self.assertTrue(abs(model_signature - get_signature(_UpperCAmelCase						)						) > 1E-3						)

									# make sure loaded weights match
									accelerator.load_state(_UpperCAmelCase						)
									self.assertTrue(abs(model_signature - get_signature(_UpperCAmelCase						)						) < 1E-3						)

					def     lowerCamelCase__	(self       :		Optional[int]						)		->  int:




							"""simple docstring"""


							lowercase__	     =						Accelerator()
							lowercase__     ,      lowercase__     ,      lowercase__     ,      lowercase__     ,      lowercase__	     =						create_components()
							accelerator.prepare(_UpperCAmelCase ,   _UpperCAmelCase ,   _UpperCAmelCase ,   _UpperCAmelCase ,   _UpperCAmelCase						)

							lowercase__	     =						get_signature(_UpperCAmelCase						)

							# saving hook
							def save_config(_UpperCAmelCase       :		Dict ,   _UpperCAmelCase       :		Dict ,   _UpperCAmelCase       :		int						):
									lowercase__	     =						{"""class_name""": models[0].__class__.__name__}

									with open(os.path.join(_UpperCAmelCase ,   """data.json"""						) ,   """w"""						) as f:
											json.dump(_UpperCAmelCase ,   _UpperCAmelCase						)

        # loading hook
							def load_config(_UpperCAmelCase       :		List[Any] ,   _UpperCAmelCase       :		int						):
									with open(os.path.join(_UpperCAmelCase ,   """data.json"""						) ,   """r"""						) as f:
											lowercase__	     =						json.load(_UpperCAmelCase						)

									lowercase__	     =						config["""class_name"""]

							lowercase__	     =						accelerator.register_save_state_pre_hook(_UpperCAmelCase						)
							lowercase__	     =						accelerator.register_load_state_pre_hook(_UpperCAmelCase						)

							with tempfile.TemporaryDirectory() as tmpdirname:
									accelerator.save_state(_UpperCAmelCase						)

									# make sure random weights don't match with hooks
									load_random_weights(_UpperCAmelCase						)
									self.assertTrue(abs(model_signature - get_signature(_UpperCAmelCase						)						) > 1E-3						)

									# random class name to verify correct one is loaded
									lowercase__	     =						"""random"""

									# make sure loaded weights match with hooks
									accelerator.load_state(_UpperCAmelCase						)
									self.assertTrue(abs(model_signature - get_signature(_UpperCAmelCase						)						) < 1E-3						)

									# mode.class_name is loaded from config
									self.assertTrue(model.class_name == model.__class__.__name__						)

							# remove hooks
							save_hook.remove()
							load_hook.remove()

							with tempfile.TemporaryDirectory() as tmpdirname:
									accelerator.save_state(_UpperCAmelCase						)

									# make sure random weights don't match with hooks removed
									load_random_weights(_UpperCAmelCase						)
									self.assertTrue(abs(model_signature - get_signature(_UpperCAmelCase						)						) > 1E-3						)

									# random class name to verify correct one is loaded
									lowercase__	     =						"""random"""

									# make sure loaded weights match with hooks removed
									accelerator.load_state(_UpperCAmelCase						)
									self.assertTrue(abs(model_signature - get_signature(_UpperCAmelCase						)						) < 1E-3						)

									# mode.class_name is NOT loaded from config
									self.assertTrue(model.class_name != model.__class__.__name__						)

					def     lowerCamelCase__	(self       :		Optional[Any]						)		->  Any:




							"""simple docstring"""


							lowercase__	     =						Accelerator()
							lowercase__     ,      lowercase__     ,      lowercase__     ,      lowercase__     ,      lowercase__	     =						create_components()
							lowercase__	     =						None

							# This should work
							lowercase__     ,      lowercase__     ,      lowercase__     ,      lowercase__     ,      lowercase__     ,      lowercase__	     =						accelerator.prepare(
							    _UpperCAmelCase ,   _UpperCAmelCase ,   _UpperCAmelCase ,   _UpperCAmelCase ,   _UpperCAmelCase ,   _UpperCAmelCase						)
							self.assertTrue(dummy_obj is None						)

					def     lowerCamelCase__	(self       :		str						)		->  Tuple:




							"""simple docstring"""


							lowercase__	     =						Accelerator()
							lowercase__     ,      lowercase__     ,      lowercase__     ,      lowercase__     ,      lowercase__	     =						create_components()
							lowercase__	     =						[1, 2, 3]

							# This should work
							lowercase__     ,      lowercase__     ,      lowercase__     ,      lowercase__     ,      lowercase__     ,      lowercase__	     =						accelerator.prepare(
							    _UpperCAmelCase ,   _UpperCAmelCase ,   _UpperCAmelCase ,   _UpperCAmelCase ,   _UpperCAmelCase ,   _UpperCAmelCase						)
							self.assertEqual(
							    getattr(_UpperCAmelCase ,   """_is_accelerate_prepared""" ,   _UpperCAmelCase						) ,   _UpperCAmelCase ,   """Dummy object should have `_is_accelerate_prepared` set to `True`""" ,   )
							self.assertEqual(
							    getattr(_UpperCAmelCase ,   """_is_accelerate_prepared""" ,   _UpperCAmelCase						) ,   _UpperCAmelCase ,   """Model is missing `_is_accelerator_prepared` or is set to `False`""" ,   )
							self.assertEqual(
							    getattr(_UpperCAmelCase ,   """_is_accelerate_prepared""" ,   _UpperCAmelCase						) ,   _UpperCAmelCase ,   """Optimizer is missing `_is_accelerator_prepared` or is set to `False`""" ,   )
							self.assertEqual(
							    getattr(_UpperCAmelCase ,   """_is_accelerate_prepared""" ,   _UpperCAmelCase						) ,   _UpperCAmelCase ,   """Scheduler is missing `_is_accelerator_prepared` or is set to `False`""" ,   )
							self.assertEqual(
							    getattr(_UpperCAmelCase ,   """_is_accelerate_prepared""" ,   _UpperCAmelCase						) ,   _UpperCAmelCase ,   """Train Dataloader is missing `_is_accelerator_prepared` or is set to `False`""" ,   )
							self.assertEqual(
							    getattr(_UpperCAmelCase ,   """_is_accelerate_prepared""" ,   _UpperCAmelCase						) ,   _UpperCAmelCase ,   """Valid Dataloader is missing `_is_accelerator_prepared` or is set to `False`""" ,   )

					@slow
					@require_bnb
					def     lowerCamelCase__	(self       :		Any						)		->  Optional[Any]:




							"""simple docstring"""


							from transformers import AutoModelForCausalLM

							lowercase__	     =						AutoModelForCausalLM.from_pretrained(
							    """EleutherAI/gpt-neo-125m""" ,   load_in_abit=_UpperCAmelCase ,   device_map={"""""": 0} ,   )
							lowercase__	     =						Accelerator()

							# This should work
							lowercase__	     =						accelerator.prepare(_UpperCAmelCase						)

					@slow
					@require_bnb
					def     lowerCamelCase__	(self       :		str						)		->  Union[str, Any]:




							"""simple docstring"""


							from transformers import AutoModelForCausalLM

							lowercase__	     =						Accelerator()

							with init_empty_weights():
									lowercase__	     =						AutoModelForCausalLM.from_pretrained(
									    """EleutherAI/gpt-neo-125m""" ,   )
									model.tie_weights()
									lowercase__	     =						infer_auto_device_map(_UpperCAmelCase						)
									lowercase__	     =						"""cpu"""

							lowercase__	     =						AutoModelForCausalLM.from_pretrained(
							    """EleutherAI/gpt-neo-125m""" ,   device_map=_UpperCAmelCase ,   load_in_abit=_UpperCAmelCase ,   llm_inta_enable_fpaa_cpu_offload=_UpperCAmelCase						)

							# This should not work and get value error
							with self.assertRaises(_UpperCAmelCase						):
									lowercase__	     =						accelerator.prepare(_UpperCAmelCase						)

					@slow
					@require_bnb
					@require_multi_gpu
					def     lowerCamelCase__	(self       :		List[str]						)		->  Optional[int]:




							"""simple docstring"""


							from transformers import AutoModelForCausalLM

							lowercase__	     =						{"""distributed_type""": DistributedType.MULTI_GPU}

							with init_empty_weights():
									lowercase__	     =						AutoModelForCausalLM.from_pretrained(
									    """EleutherAI/gpt-neo-125m""" ,   )
									model.tie_weights()
									lowercase__	     =						infer_auto_device_map(_UpperCAmelCase						)
									lowercase__	     =						1

							lowercase__	     =						AutoModelForCausalLM.from_pretrained(
							    """EleutherAI/gpt-neo-125m""" ,   load_in_abit=_UpperCAmelCase ,   device_map=_UpperCAmelCase ,   )
							lowercase__	     =						Accelerator()

							# This should not work and get value error
							with self.assertRaises(_UpperCAmelCase						):
									lowercase__	     =						accelerator.prepare(_UpperCAmelCase						)

							PartialState._reset_state()

					@slow
					@require_bnb
					@require_multi_gpu
					def     lowerCamelCase__	(self       :		Union[str, Any]						)		->  int:




							"""simple docstring"""


							from transformers import AutoModelForCausalLM

							with init_empty_weights():
									lowercase__	     =						AutoModelForCausalLM.from_pretrained(
									    """EleutherAI/gpt-neo-125m""" ,   )
									lowercase__	     =						infer_auto_device_map(_UpperCAmelCase						)
									lowercase__	     =						1

							lowercase__	     =						AutoModelForCausalLM.from_pretrained(
							    """EleutherAI/gpt-neo-125m""" ,   load_in_abit=_UpperCAmelCase ,   device_map=_UpperCAmelCase ,   )
							lowercase__	     =						Accelerator()

							# This should work
							lowercase__	     =						accelerator.prepare(_UpperCAmelCase						)


					@require_cuda
					def     lowerCamelCase__	(self       :		Optional[Any]						)		->  Optional[Any]:




							"""simple docstring"""


							lowercase__	     =						torch.nn.Linear(10 ,   10						)
							lowercase__	     =						torch.optim.SGD(model.parameters() ,   lr=0.01						)
							lowercase__	     =						Accelerator(cpu=_UpperCAmelCase						)
							lowercase__	     =						accelerator.prepare(_UpperCAmelCase						)





import argparse

import torch
from datasets import load_dataset
from donut import DonutModel

from transformers import (
    DonutImageProcessor,
    DonutProcessor,
    DonutSwinConfig,
    DonutSwinModel,
    MBartConfig,
    MBartForCausalLM,
    VisionEncoderDecoderModel,
    XLMRobertaTokenizerFast,
)






def 					UpperCamelCase   (      __magic_name__	:				Any	)  ->    int:
		"""simple docstring"""




		lowercase__	     =						model.config

		lowercase__	     =						DonutSwinConfig(
		    image_size=original_config.input_size       ,       patch_size=4       ,       depths=original_config.encoder_layer       ,       num_heads=[4, 8, 16, 32]       ,       window_size=original_config.window_size       ,       embed_dim=128       ,       )
		lowercase__	     =						MBartConfig(
		    is_decoder=__magic_name__       ,       is_encoder_decoder=__magic_name__       ,       add_cross_attention=__magic_name__       ,       decoder_layers=original_config.decoder_layer       ,       max_position_embeddings=original_config.max_position_embeddings       ,       vocab_size=len(
		        model.decoder.tokenizer	)       ,       scale_embedding=__magic_name__       ,       add_final_layer_norm=__magic_name__       ,       )

		return encoder_config, decoder_config






def 					UpperCamelCase   (      __magic_name__	:				Optional[Any]	)  ->    Optional[Any]:
		"""simple docstring"""




		if "encoder.model" in name:
				lowercase__	     =						name.replace("""encoder.model"""       ,       """encoder"""	)
		if "decoder.model" in name:
				lowercase__	     =						name.replace("""decoder.model"""       ,       """decoder"""	)
		if "patch_embed.proj" in name:
				lowercase__	     =						name.replace("""patch_embed.proj"""       ,       """embeddings.patch_embeddings.projection"""	)
		if "patch_embed.norm" in name:
				lowercase__	     =						name.replace("""patch_embed.norm"""       ,       """embeddings.norm"""	)
		if name.startswith("""encoder"""	):
				if "layers" in name:
						lowercase__	     =						"""encoder.""" + name
				if "attn.proj" in name:
						lowercase__	     =						name.replace("""attn.proj"""       ,       """attention.output.dense"""	)
				if "attn" in name and "mask" not in name:
						lowercase__	     =						name.replace("""attn"""       ,       """attention.self"""	)
				if "norm1" in name:
						lowercase__	     =						name.replace("""norm1"""       ,       """layernorm_before"""	)
				if "norm2" in name:
						lowercase__	     =						name.replace("""norm2"""       ,       """layernorm_after"""	)
				if "mlp.fc1" in name:
						lowercase__	     =						name.replace("""mlp.fc1"""       ,       """intermediate.dense"""	)
				if "mlp.fc2" in name:
						lowercase__	     =						name.replace("""mlp.fc2"""       ,       """output.dense"""	)

				if name == "encoder.norm.weight":
						lowercase__	     =						"""encoder.layernorm.weight"""
				if name == "encoder.norm.bias":
						lowercase__	     =						"""encoder.layernorm.bias"""

		return name






def 					UpperCamelCase   (      __magic_name__	:				Any       ,       __magic_name__	:				str	)  ->    Optional[int]:
		"""simple docstring"""




		for key in orig_state_dict.copy().keys():
				lowercase__	     =						orig_state_dict.pop(__magic_name__	)

				if "qkv" in key:
						lowercase__	     =						key.split("""."""	)
						lowercase__	     =						int(key_split[3]	)
						lowercase__	     =						int(key_split[5]	)
						lowercase__	     =						model.encoder.encoder.layers[layer_num].blocks[block_num].attention.self.all_head_size

						if "weight" in key:
								lowercase__	     =						val[:dim, :]
								lowercase__	     =						val[dim : dim * 2, :]
								lowercase__	     =						val[-dim:, :]
						else:
								lowercase__	     =						val[:dim]
								lowercase__	     =						val[dim : dim * 2]
								lowercase__	     =						val[-dim:]
				elif "attn_mask" in key or key in ["encoder.model.norm.weight", "encoder.model.norm.bias"]:
						# HuggingFace implementation doesn't use attn_mask buffer
						# and model doesn't use final LayerNorms for the encoder
						pass
				else:
						lowercase__	     =						val

		return orig_state_dict






def 					UpperCamelCase   (      __magic_name__	:				Union[str, Any]       ,       __magic_name__	:				List[Any]=None       ,       __magic_name__	:				Dict=False	)  ->    int:
		"""simple docstring"""




		lowercase__	     =						DonutModel.from_pretrained(__magic_name__	).eval()

		# load HuggingFace model
		lowercase__     ,      lowercase__	     =						get_configs(__magic_name__	)
		lowercase__	     =						DonutSwinModel(__magic_name__	)
		lowercase__	     =						MBartForCausalLM(__magic_name__	)
		lowercase__	     =						VisionEncoderDecoderModel(encoder=__magic_name__       ,       decoder=__magic_name__	)
		model.eval()

		lowercase__	     =						original_model.state_dict()
		lowercase__	     =						convert_state_dict(__magic_name__       ,       __magic_name__	)
		model.load_state_dict(__magic_name__	)

		# verify results on scanned document
		lowercase__	     =						load_dataset("""hf-internal-testing/example-documents"""	)
		lowercase__	     =						dataset["""test"""][0]["""image"""].convert("""RGB"""	)

		lowercase__	     =						XLMRobertaTokenizerFast.from_pretrained(__magic_name__       ,       from_slow=__magic_name__	)
		lowercase__	     =						DonutImageProcessor(
		    do_align_long_axis=original_model.config.align_long_axis       ,       size=original_model.config.input_size[::-1]	)
		lowercase__	     =						DonutProcessor(__magic_name__       ,       __magic_name__	)
		lowercase__	     =						processor(__magic_name__       ,       return_tensors="""pt"""	).pixel_values

		if model_name == "naver-clova-ix/donut-base-finetuned-docvqa":
				lowercase__	     =						"""<s_docvqa><s_question>{user_input}</s_question><s_answer>"""
				lowercase__	     =						"""When is the coffee break?"""
				lowercase__	     =						task_prompt.replace("""{user_input}"""       ,       __magic_name__	)
		elif model_name == "naver-clova-ix/donut-base-finetuned-rvlcdip":
				lowercase__	     =						"""<s_rvlcdip>"""
		elif model_name in [
		    "naver-clova-ix/donut-base-finetuned-cord-v1",
		    "naver-clova-ix/donut-base-finetuned-cord-v1-2560",
		]:
				lowercase__	     =						"""<s_cord>"""
		elif model_name == "naver-clova-ix/donut-base-finetuned-cord-v2":
				lowercase__	     =						"""s_cord-v2>"""
		elif model_name == "naver-clova-ix/donut-base-finetuned-zhtrainticket":
				lowercase__	     =						"""<s_zhtrainticket>"""
		elif model_name in ["naver-clova-ix/donut-proto", "naver-clova-ix/donut-base"]:
				# use a random prompt
				lowercase__	     =						"""hello world"""
		else:
				raise ValueError("""Model name not supported"""	)
		lowercase__	     =						original_model.decoder.tokenizer(__magic_name__       ,       add_special_tokens=__magic_name__       ,       return_tensors="""pt"""	)[
		    """input_ids"""
		]

		lowercase__	     =						original_model.encoder.model.patch_embed(__magic_name__	)
		lowercase__     ,      lowercase__	     =						model.encoder.embeddings(__magic_name__	)
		assert torch.allclose(__magic_name__       ,       __magic_name__       ,       atol=1E-3	)

		# verify encoder hidden states
		lowercase__	     =						original_model.encoder(__magic_name__	)
		lowercase__	     =						model.encoder(__magic_name__	).last_hidden_state
		assert torch.allclose(__magic_name__       ,       __magic_name__       ,       atol=1E-2	)

		# verify decoder hidden states
		lowercase__	     =						original_model(__magic_name__       ,       __magic_name__       ,       __magic_name__	).logits
		lowercase__	     =						model(__magic_name__       ,       decoder_input_ids=__magic_name__	).logits
		assert torch.allclose(__magic_name__       ,       __magic_name__       ,       atol=1E-3	)
		print("""Looks ok!"""	)

		if pytorch_dump_folder_path is not None:
				print(f'''Saving model and processor to {pytorch_dump_folder_path}'''	)
				model.save_pretrained(__magic_name__	)
				processor.save_pretrained(__magic_name__	)

		if push_to_hub:
				model.push_to_hub("""nielsr/""" + model_name.split("""/"""	)[-1]       ,       commit_message="""Update model"""	)
				processor.push_to_hub("""nielsr/""" + model_name.split("""/"""	)[-1]       ,       commit_message="""Update model"""	)


if __name__ == "__main__":
	A			:						Dict        =  argparse.ArgumentParser()
	# Required parameters
	parser.add_argument(
	    '--model_name',
	    default='naver-clova-ix/donut-base-finetuned-docvqa',
	    required=False,
	    type=str,
	    help='Name of the original model you\'d like to convert.',
	)
	parser.add_argument(
	    '--pytorch_dump_folder_path',
	    default=None,
	    required=False,
	    type=str,
	    help='Path to the output PyTorch model directory.',
	)
	parser.add_argument(
	    '--push_to_hub',
	    action='store_true',
	    help='Whether or not to push the converted model and processor to the 🤗 hub.',
	)

	A			:						Optional[int]        =  parser.parse_args()
	convert_donut_checkpoint(args.model_name, args.pytorch_dump_folder_path, args.push_to_hub)

