



def     a(      A       :    int       )		->       int:
					"""simple docstring"""





					a					     =   abs(A       )
					a					     =   0
					while n > 0:
										res += n % 10
										n //= 10
					return res






def     a(      A       :    int       )		->       int:
					"""simple docstring"""





					a					     =   abs(A       )
					return n if n < 10 else n % 10 + sum_of_digits(n // 10       )






def     a(      A       :    int       )		->       int:
					"""simple docstring"""





					return sum(int(A       ) for c in str(abs(A       )       )       )






def     a(      )		->       None:
					"""simple docstring"""





					from collections.abc import Callable
					from timeit import timeit

					def benchmark_a_function(A       :    Callable ,     A       :    int       ) -> None:
										a					     =   f'''{func.__name__}({value})'''
										a					     =   timeit(f'''__main__.{call}''' ,     setup="import __main__"       )
										print(f'''{call:56} = {func(A       )} -- {timing:.4f} seconds'''       )

					for value in (26_2144, 1125_8999_0684_2624, 126_7650_6002_2822_9401_4967_0320_5376):
										for func in (sum_of_digits, sum_of_digits_recursion, sum_of_digits_compact):
															benchmark_a_function(A ,     A       )
										print()


if __name__ == "__main__":
				import doctest

				doctest.testmod()
				benchmark()





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     a(      A       :    Tuple       )		->       Optional[Any]:
					"""simple docstring"""





					a					     =   model.config

					a					     =   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 ,     )
					a					     =   MBartConfig(
					    is_decoder=A ,     is_encoder_decoder=A ,     add_cross_attention=A ,     decoder_layers=original_config.decoder_layer ,     max_position_embeddings=original_config.max_position_embeddings ,     vocab_size=len(
					        model.decoder.tokenizer       ) ,     scale_embedding=A ,     add_final_layer_norm=A ,     )

					return encoder_config, decoder_config






def     a(      A       :    List[Any]       )		->       Union[str, Any]:
					"""simple docstring"""





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

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

					return name






def     a(      A       :    Union[str, Any] ,     A       :    Tuple       )		->       List[Any]:
					"""simple docstring"""





					for key in orig_state_dict.copy().keys():
										a					     =   orig_state_dict.pop(A       )

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

															if "weight" in key:
																				a					     =   val[:dim, :]
																				a					     =   val[dim : dim * 2, :]
																				a					     =   val[-dim:, :]
															else:
																				a					     =   val[:dim]
																				a					     =   val[dim : dim * 2]
																				a					     =   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:
															a					     =   val

					return orig_state_dict






def     a(      A       :    List[Any] ,     A       :    Tuple=None ,     A       :    List[Any]=False       )		->       Optional[int]:
					"""simple docstring"""





					a					     =   DonutModel.from_pretrained(A       ).eval()

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

					a					     =   original_model.state_dict()
					a					     =   convert_state_dict(A ,     A       )
					model.load_state_dict(A       )

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

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

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

					a					     =   original_model.encoder.model.patch_embed(A       )
					a     ,				a					     =   model.encoder.embeddings(A       )
					assert torch.allclose(A ,     A ,     atol=1e-3       )

					# verify encoder hidden states
					a					     =   original_model.encoder(A       )
					a					     =   model.encoder(A       ).last_hidden_state
					assert torch.allclose(A ,     A ,     atol=1e-2       )

					# verify decoder hidden states
					a					     =   original_model(A ,     A ,     A       ).logits
					a					     =   model(A ,     decoder_input_ids=A       ).logits
					assert torch.allclose(A ,     A ,     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(A       )
										processor.save_pretrained(A       )

					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__":
				_lowercase: Tuple      			=		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.",
				)

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