





import re
import time
from typing import Optional

import IPython.display as disp

from ..trainer_callback import TrainerCallback
from ..trainer_utils import IntervalStrategy, has_length




def 	lowerCAmelCase_					(						__UpperCAmelCase:    Optional[int]   )   ->			Dict:
    UpperCamelCase__							:       Tuple      =   int(__UpperCAmelCase   )
    UpperCamelCase__     ,UpperCamelCase__     ,UpperCamelCase__							:       Optional[int]      =   t // 3600, (t // 60) % 60, t % 60
    return f"{h}:{m:02d}:{s:02d}" if h != 0 else f"{m:02d}:{s:02d}"




def 	lowerCAmelCase_					(						__UpperCAmelCase:    str	,     __UpperCAmelCase:    int	,     __UpperCAmelCase:    Optional[Any]	,     __UpperCAmelCase:    Union[str, Any]	,     __UpperCAmelCase:    Dict=300   )   ->			int:
    # docstyle-ignore
    return f"\n    <div>\n      {prefix}\n      <progress value='{value}' max='{total}' style='width:{width}px; height:20px; vertical-align: middle;'></progress>\n      {label}\n    </div>\n    "




def 	lowerCAmelCase_					(						__UpperCAmelCase:    Any   )   ->			int:
    UpperCamelCase__							:       Dict      =   '''<table border="1" class="dataframe">\n'''
    html_code += """  <thead>\n <tr style="text-align: left;">\n"""
    for i in items[0]:
        html_code += f"      <th>{i}</th>\n"
    html_code += "    </tr>\n  </thead>\n  <tbody>\n"
    for line in items[1:]:
        html_code += "    <tr>\n"
        for elt in line:
            UpperCamelCase__							:       List[str]      =   f"{elt:.6f}" if isinstance(__UpperCAmelCase	,     __UpperCAmelCase   ) else str(__UpperCAmelCase   )
            html_code += f"      <td>{elt}</td>\n"
        html_code += "    </tr>\n"
    html_code += "  </tbody>\n</table><p>"
    return html_code






class 					lowercase__ :

   '''simple docstring'''


   a		:							List[Any]     	=	5
   a		:							Dict     	=	0.2




   def __init__(					self,	__magic_name__,	__magic_name__ = None,	__magic_name__ = True,	__magic_name__ = None,	__magic_name__ = 300,	)				->   List[Any]:






       """simple docstring"""
       UpperCamelCase__							:       Dict      =   total
       UpperCamelCase__							:       Dict      =   '''''' if prefix is None else prefix
       UpperCamelCase__							:       Optional[Any]      =   leave
       UpperCamelCase__							:       Any      =   parent
       UpperCamelCase__							:       str      =   width
       UpperCamelCase__							:       int      =   None
       UpperCamelCase__							:       int      =   None
       UpperCamelCase__							:       int      =   None




   def    UpperCamelCase__						(					self,	__magic_name__,	__magic_name__ = False,	__magic_name__ = None							)				->   List[Any]:






       """simple docstring"""
       UpperCamelCase__							:       Optional[int]      =   value
       if comment is not None:
           UpperCamelCase__							:       Optional[int]      =   comment
       if self.last_value is None:
           UpperCamelCase__							:       Union[str, Any]      =   time.time()
           UpperCamelCase__							:       Any      =   value
           UpperCamelCase__							:       Tuple      =   None
           UpperCamelCase__							:       Optional[int]      =   self.warmup
           UpperCamelCase__							:       Any      =   1
           self.update_bar(__magic_name__							)
       elif value <= self.last_value and not force_update:
           return
       elif force_update or self.first_calls > 0 or value >= min(self.last_value + self.wait_for,	self.total							):
           if self.first_calls > 0:
               self.first_calls -= 1
           UpperCamelCase__							:       Tuple      =   time.time()
           UpperCamelCase__							:       Tuple      =   current_time - self.start_time
           # We could have value = self.start_value if the update is called twixe with the same start value.
           if value > self.start_value:
               UpperCamelCase__							:       Dict      =   self.elapsed_time / (value - self.start_value)
           else:
               UpperCamelCase__							:       int      =   None
           if value >= self.total:
               UpperCamelCase__							:       Tuple      =   self.total
               UpperCamelCase__							:       Tuple      =   None
               if not self.leave:
                   self.close()
           elif self.average_time_per_item is not None:
               UpperCamelCase__							:       Optional[int]      =   self.average_time_per_item * (self.total - value)
           self.update_bar(__magic_name__							)
           UpperCamelCase__							:       Dict      =   value
           UpperCamelCase__							:       Union[str, Any]      =   current_time
           if self.average_time_per_item is None:
               UpperCamelCase__							:       Dict      =   1
           else:
               UpperCamelCase__							:       Dict      =   max(int(self.update_every / self.average_time_per_item							),	1							)




   def    UpperCamelCase__						(					self,	__magic_name__,	__magic_name__=None							)				->   int:






       """simple docstring"""
       UpperCamelCase__							:       str      =   ''' ''' * (len(str(self.total							)							) - len(str(__magic_name__							)							)) + str(__magic_name__							)
       if self.elapsed_time is None:
           UpperCamelCase__							:       List[str]      =   f"[{spaced_value}/{self.total} : < :"
       elif self.predicted_remaining is None:
           UpperCamelCase__							:       str      =   f"[{spaced_value}/{self.total} {format_time(self.elapsed_time							)}"
       else:
           UpperCamelCase__							:       Any      =   (
               f"[{spaced_value}/{self.total} {format_time(self.elapsed_time							)} <"
               f" {format_time(self.predicted_remaining							)}"
           )
           self.label += f", {1/self.average_time_per_item:.2f} it/s"
       self.label += "]" if self.comment is None or len(self.comment							) == 0 else f", {self.comment}]"
       self.display()




   def    UpperCamelCase__						(					self							)				->   Tuple:






       """simple docstring"""
       UpperCamelCase__							:       int      =   html_progress_bar(self.value,	self.total,	self.prefix,	self.label,	self.width							)
       if self.parent is not None:
           # If this is a child bar, the parent will take care of the display.
           self.parent.display()
           return
       if self.output is None:
           UpperCamelCase__							:       Union[str, Any]      =   disp.display(disp.HTML(self.html_code							),	display_id=__magic_name__							)
       else:
           self.output.update(disp.HTML(self.html_code							)							)




   def    UpperCamelCase__						(					self							)				->   Dict:






       """simple docstring"""
       if self.parent is None and self.output is not None:
           self.output.update(disp.HTML(''''''							)							)






class 					lowercase__ (			__lowerCamelCase       ):

   '''simple docstring'''


   def __init__(					self,	__magic_name__,	__magic_name__=None							)				->   Any:






       """simple docstring"""
       super().__init__(__magic_name__							)
       UpperCamelCase__							:       int      =   None if column_names is None else [column_names]
       UpperCamelCase__							:       str      =   None




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






       """simple docstring"""
       UpperCamelCase__							:       int      =   html_progress_bar(self.value,	self.total,	self.prefix,	self.label,	self.width							)
       if self.inner_table is not None:
           self.html_code += text_to_html_table(self.inner_table							)
       if self.child_bar is not None:
           self.html_code += self.child_bar.html_code
       if self.output is None:
           UpperCamelCase__							:       List[Any]      =   disp.display(disp.HTML(self.html_code							),	display_id=__magic_name__							)
       else:
           self.output.update(disp.HTML(self.html_code							)							)




   def    UpperCamelCase__						(					self,	__magic_name__							)				->   Tuple:






       """simple docstring"""
       if self.inner_table is None:
           UpperCamelCase__							:       List[Any]      =   [list(values.keys()							), list(values.values()							)]
       else:
           UpperCamelCase__							:       Optional[Any]      =   self.inner_table[0]
           if len(self.inner_table							) == 1:
               # We give a chance to update the column names at the first iteration
               for key in values.keys():
                   if key not in columns:
                       columns.append(__magic_name__							)
               UpperCamelCase__							:       Union[str, Any]      =   columns
           self.inner_table.append([values[c] for c in columns]							)




   def    UpperCamelCase__						(					self,	__magic_name__,	__magic_name__=None,	__magic_name__=300							)				->   Tuple:






       """simple docstring"""
       UpperCamelCase__							:       Dict      =   NotebookProgressBar(__magic_name__,	prefix=__magic_name__,	parent=self,	width=__magic_name__							)
       return self.child_bar




   def    UpperCamelCase__						(					self							)				->   List[str]:






       """simple docstring"""
       UpperCamelCase__							:       List[Any]      =   None
       self.display()






class 					lowercase__ (			__lowerCamelCase       ):

   '''simple docstring'''


   def __init__(					self							)				->   str:






       """simple docstring"""
       UpperCamelCase__							:       List[str]      =   None
       UpperCamelCase__							:       List[Any]      =   None
       UpperCamelCase__							:       Union[str, Any]      =   False




   def    UpperCamelCase__						(					self,	__magic_name__,	__magic_name__,	__magic_name__,	**__magic_name__							)				->   Optional[Any]:






       """simple docstring"""
       UpperCamelCase__							:       List[str]      =   '''Epoch''' if args.evaluation_strategy == IntervalStrategy.EPOCH else '''Step'''
       UpperCamelCase__							:       Tuple      =   0
       UpperCamelCase__							:       Any      =   0
       UpperCamelCase__							:       Any      =   [self.first_column] + ['''Training Loss''']
       if args.evaluation_strategy != IntervalStrategy.NO:
           column_names.append('''Validation Loss'''							)
       UpperCamelCase__							:       int      =   NotebookTrainingTracker(state.max_steps,	__magic_name__							)




   def    UpperCamelCase__						(					self,	__magic_name__,	__magic_name__,	__magic_name__,	**__magic_name__							)				->   str:






       """simple docstring"""
       UpperCamelCase__							:       Dict      =   int(state.epoch							) if int(state.epoch							) == state.epoch else f"{state.epoch:.2f}"
       self.training_tracker.update(
           state.global_step + 1,	comment=f"Epoch {epoch}/{state.num_train_epochs}",	force_update=self._force_next_update,	)
       UpperCamelCase__							:       int      =   False




   def    UpperCamelCase__						(					self,	__magic_name__,	__magic_name__,	__magic_name__,	__magic_name__=None,	**__magic_name__							)				->   List[Any]:






       """simple docstring"""
       if not has_length(__magic_name__							):
           return
       if self.prediction_bar is None:
           if self.training_tracker is not None:
               UpperCamelCase__							:       Dict      =   self.training_tracker.add_child(len(__magic_name__							)							)
           else:
               UpperCamelCase__							:       Optional[Any]      =   NotebookProgressBar(len(__magic_name__							)							)
           self.prediction_bar.update(1							)
       else:
           self.prediction_bar.update(self.prediction_bar.value + 1							)




   def    UpperCamelCase__						(					self,	__magic_name__,	__magic_name__,	__magic_name__,	**__magic_name__							)				->   Any:






       """simple docstring"""
       if self.prediction_bar is not None:
           self.prediction_bar.close()
       UpperCamelCase__							:       Dict      =   None




   def    UpperCamelCase__						(					self,	__magic_name__,	__magic_name__,	__magic_name__,	__magic_name__=None,	**__magic_name__							)				->   str:






       """simple docstring"""
       # Only for when there is no evaluation
       if args.evaluation_strategy == IntervalStrategy.NO and "loss" in logs:
           UpperCamelCase__							:       List[Any]      =   {'''Training Loss''': logs['''loss''']}
           # First column is necessarily Step sine we're not in epoch eval strategy
           UpperCamelCase__							:       Any      =   state.global_step
           self.training_tracker.write_line(__magic_name__							)




   def    UpperCamelCase__						(					self,	__magic_name__,	__magic_name__,	__magic_name__,	__magic_name__=None,	**__magic_name__							)				->   Optional[int]:






       """simple docstring"""
       if self.training_tracker is not None:
           UpperCamelCase__							:       Optional[Any]      =   {'''Training Loss''': '''No log''', '''Validation Loss''': '''No log'''}
           for log in reversed(state.log_history							):
               if "loss" in log:
                   UpperCamelCase__							:       Dict      =   log['''loss''']
                   break

           if self.first_column == "Epoch":
               UpperCamelCase__							:       Any      =   int(state.epoch							)
           else:
               UpperCamelCase__							:       Optional[int]      =   state.global_step
           UpperCamelCase__							:       int      =   '''eval'''
           for k in metrics:
               if k.endswith('''_loss'''							):
                   UpperCamelCase__							:       Tuple      =   re.sub(R'''\_loss$''',	'''''',	__magic_name__							)
           UpperCamelCase__							:       Tuple      =   metrics.pop('''total_flos''',	__magic_name__							)
           UpperCamelCase__							:       Union[str, Any]      =   metrics.pop('''epoch''',	__magic_name__							)
           UpperCamelCase__							:       Tuple      =   metrics.pop(f"{metric_key_prefix}_runtime",	__magic_name__							)
           UpperCamelCase__							:       List[Any]      =   metrics.pop(f"{metric_key_prefix}_samples_per_second",	__magic_name__							)
           UpperCamelCase__							:       Any      =   metrics.pop(f"{metric_key_prefix}_steps_per_second",	__magic_name__							)
           UpperCamelCase__							:       Tuple      =   metrics.pop(f"{metric_key_prefix}_jit_compilation_time",	__magic_name__							)
           for k, v in metrics.items():
               if k == f"{metric_key_prefix}_loss":
                   UpperCamelCase__							:       List[Any]      =   v
               else:
                   UpperCamelCase__							:       Any      =   k.split('''_'''							)
                   UpperCamelCase__							:       int      =   ''' '''.join([part.capitalize() for part in splits[1:]]							)
                   UpperCamelCase__							:       Optional[Any]      =   v
           self.training_tracker.write_line(__magic_name__							)
           self.training_tracker.remove_child()
           UpperCamelCase__							:       Tuple      =   None
           # Evaluation takes a long time so we should force the next update.
           UpperCamelCase__							:       Union[str, Any]      =   True




   def    UpperCamelCase__						(					self,	__magic_name__,	__magic_name__,	__magic_name__,	**__magic_name__							)				->   List[str]:






       """simple docstring"""
       self.training_tracker.update(
           state.global_step,	comment=f"Epoch {int(state.epoch							)}/{state.num_train_epochs}",	force_update=__magic_name__							)
       UpperCamelCase__							:       Union[str, Any]      =   None








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 	lowerCAmelCase_					(						__UpperCAmelCase:    Union[str, Any]   )   ->			Union[str, Any]:
    UpperCamelCase__							:       List[str]      =   model.config

    UpperCamelCase__							:       Optional[Any]      =   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	,     )
    UpperCamelCase__							:       Union[str, Any]      =   MBartConfig(
        is_decoder=__UpperCAmelCase	,     is_encoder_decoder=__UpperCAmelCase	,     add_cross_attention=__UpperCAmelCase	,     decoder_layers=original_config.decoder_layer	,     max_position_embeddings=original_config.max_position_embeddings	,     vocab_size=len(
            model.decoder.tokenizer   )	,     scale_embedding=__UpperCAmelCase	,     add_final_layer_norm=__UpperCAmelCase	,     )

    return encoder_config, decoder_config




def 	lowerCAmelCase_					(						__UpperCAmelCase:    str   )   ->			Tuple:
    if "encoder.model" in name:
        UpperCamelCase__							:       str      =   name.replace('''encoder.model'''	,     '''encoder'''   )
    if "decoder.model" in name:
        UpperCamelCase__							:       Optional[int]      =   name.replace('''decoder.model'''	,     '''decoder'''   )
    if "patch_embed.proj" in name:
        UpperCamelCase__							:       Dict      =   name.replace('''patch_embed.proj'''	,     '''embeddings.patch_embeddings.projection'''   )
    if "patch_embed.norm" in name:
        UpperCamelCase__							:       Optional[int]      =   name.replace('''patch_embed.norm'''	,     '''embeddings.norm'''   )
    if name.startswith('''encoder'''   ):
        if "layers" in name:
            UpperCamelCase__							:       Optional[Any]      =   '''encoder.''' + name
        if "attn.proj" in name:
            UpperCamelCase__							:       Optional[int]      =   name.replace('''attn.proj'''	,     '''attention.output.dense'''   )
        if "attn" in name and "mask" not in name:
            UpperCamelCase__							:       str      =   name.replace('''attn'''	,     '''attention.self'''   )
        if "norm1" in name:
            UpperCamelCase__							:       List[str]      =   name.replace('''norm1'''	,     '''layernorm_before'''   )
        if "norm2" in name:
            UpperCamelCase__							:       Union[str, Any]      =   name.replace('''norm2'''	,     '''layernorm_after'''   )
        if "mlp.fc1" in name:
            UpperCamelCase__							:       Any      =   name.replace('''mlp.fc1'''	,     '''intermediate.dense'''   )
        if "mlp.fc2" in name:
            UpperCamelCase__							:       List[str]      =   name.replace('''mlp.fc2'''	,     '''output.dense'''   )

        if name == "encoder.norm.weight":
            UpperCamelCase__							:       Optional[Any]      =   '''encoder.layernorm.weight'''
        if name == "encoder.norm.bias":
            UpperCamelCase__							:       Any      =   '''encoder.layernorm.bias'''

    return name




def 	lowerCAmelCase_					(						__UpperCAmelCase:    str	,     __UpperCAmelCase:    str   )   ->			Dict:
    for key in orig_state_dict.copy().keys():
        UpperCamelCase__							:       Dict      =   orig_state_dict.pop(__UpperCAmelCase   )

        if "qkv" in key:
            UpperCamelCase__							:       Tuple      =   key.split('''.'''   )
            UpperCamelCase__							:       str      =   int(key_split[3]   )
            UpperCamelCase__							:       List[Any]      =   int(key_split[5]   )
            UpperCamelCase__							:       Optional[Any]      =   model.encoder.encoder.layers[layer_num].blocks[block_num].attention.self.all_head_size

            if "weight" in key:
                UpperCamelCase__							:       Tuple      =   val[:dim, :]
                UpperCamelCase__							:       Dict      =   val[dim : dim * 2, :]
                UpperCamelCase__							:       Dict      =   val[-dim:, :]
            else:
                UpperCamelCase__							:       Optional[int]      =   val[:dim]
                UpperCamelCase__							:       str      =   val[dim : dim * 2]
                UpperCamelCase__							:       int      =   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:
            UpperCamelCase__							:       Any      =   val

    return orig_state_dict




def 	lowerCAmelCase_					(						__UpperCAmelCase:    Optional[Any]	,     __UpperCAmelCase:    List[Any]=None	,     __UpperCAmelCase:    Tuple=False   )   ->			Optional[int]:
    # load original model
    UpperCamelCase__							:       List[Any]      =   DonutModel.from_pretrained(__UpperCAmelCase   ).eval()

    # load HuggingFace model
    UpperCamelCase__     ,UpperCamelCase__							:       List[str]      =   get_configs(__UpperCAmelCase   )
    UpperCamelCase__							:       int      =   DonutSwinModel(__UpperCAmelCase   )
    UpperCamelCase__							:       Optional[Any]      =   MBartForCausalLM(__UpperCAmelCase   )
    UpperCamelCase__							:       Optional[int]      =   VisionEncoderDecoderModel(encoder=__UpperCAmelCase	,     decoder=__UpperCAmelCase   )
    model.eval()

    UpperCamelCase__							:       List[Any]      =   original_model.state_dict()
    UpperCamelCase__							:       List[Any]      =   convert_state_dict(__UpperCAmelCase	,     __UpperCAmelCase   )
    model.load_state_dict(__UpperCAmelCase   )

    # verify results on scanned document
    UpperCamelCase__							:       Optional[int]      =   load_dataset('''hf-internal-testing/example-documents'''   )
    UpperCamelCase__							:       Any      =   dataset['''test'''][0]['''image'''].convert('''RGB'''   )

    UpperCamelCase__							:       Optional[Any]      =   XLMRobertaTokenizerFast.from_pretrained(__UpperCAmelCase	,     from_slow=__UpperCAmelCase   )
    UpperCamelCase__							:       Dict      =   DonutImageProcessor(
        do_align_long_axis=original_model.config.align_long_axis	,     size=original_model.config.input_size[::-1]   )
    UpperCamelCase__							:       Any      =   DonutProcessor(__UpperCAmelCase	,     __UpperCAmelCase   )
    UpperCamelCase__							:       str      =   processor(__UpperCAmelCase	,     return_tensors='''pt'''   ).pixel_values

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

    UpperCamelCase__							:       List[str]      =   original_model.encoder.model.patch_embed(__UpperCAmelCase   )
    UpperCamelCase__     ,UpperCamelCase__							:       List[str]      =   model.encoder.embeddings(__UpperCAmelCase   )
    assert torch.allclose(__UpperCAmelCase	,     __UpperCAmelCase	,     atol=1e-3   )

    # verify encoder hidden states
    UpperCamelCase__							:       Dict      =   original_model.encoder(__UpperCAmelCase   )
    UpperCamelCase__							:       Optional[Any]      =   model.encoder(__UpperCAmelCase   ).last_hidden_state
    assert torch.allclose(__UpperCAmelCase	,     __UpperCAmelCase	,     atol=1e-2   )

    # verify decoder hidden states
    UpperCamelCase__							:       Optional[Any]      =   original_model(__UpperCAmelCase	,     __UpperCAmelCase	,     __UpperCAmelCase   ).logits
    UpperCamelCase__							:       str      =   model(__UpperCAmelCase	,     decoder_input_ids=__UpperCAmelCase   ).logits
    assert torch.allclose(__UpperCAmelCase	,     __UpperCAmelCase	,     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(__UpperCAmelCase   )
        processor.save_pretrained(__UpperCAmelCase   )

    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__":
  UpperCAmelCase_  							=				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.',
  )

  UpperCAmelCase_  							=				parser.parse_args()
  convert_donut_checkpoint(args.model_name, args.pytorch_dump_folder_path, args.push_to_hub)

