




'''simple docstring'''


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 						snake_case_       (UpperCamelCase			:    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=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 						snake_case_       (UpperCamelCase			:    Tuple ):





							'''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 						snake_case_       (UpperCamelCase			:    Dict					,		UpperCamelCase			:    Optional[int] ):





							'''simple docstring'''


							for key in orig_state_dict.copy().keys():
														_a      	=							orig_state_dict.pop(UpperCamelCase )

														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 						snake_case_       (UpperCamelCase			:    List[Any]					,		UpperCamelCase			:    Tuple=None					,		UpperCamelCase			:    List[str]=False ):





							'''simple docstring'''


							_a      	=							DonutModel.from_pretrained(UpperCamelCase ).eval()

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

							_a      	=							original_model.state_dict()
							_a      	=							convert_state_dict(UpperCamelCase					,		UpperCamelCase )
							model.load_state_dict(UpperCamelCase )

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

							_a      	=							XLMRobertaTokenizerFast.from_pretrained(UpperCamelCase					,		from_slow=UpperCamelCase )
							_a      	=							DonutImageProcessor(
							    do_align_long_axis=original_model.config.align_long_axis					,		size=original_model.config.input_size[::-1] )
							_a      	=							DonutProcessor(UpperCamelCase					,		UpperCamelCase )
							_a      	=							processor(UpperCamelCase					,		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}'''					,		UpperCamelCase )
							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(UpperCamelCase					,		add_special_tokens=UpperCamelCase					,		return_tensors='''pt''' )[
							    '''input_ids'''
							]

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

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

							# verify decoder hidden states
							_a      	=							original_model(UpperCamelCase					,		UpperCamelCase					,		UpperCamelCase ).logits
							_a      	=							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__":
				_snake_case : 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.',
				)

				_snake_case : Union[str, Any]  				=						parser.parse_args()
				convert_donut_checkpoint(args.model_name, args.pytorch_dump_folder_path, args.push_to_hub)







'''simple docstring'''


import requests
def 						snake_case_       (UpperCamelCase			:    str					,		UpperCamelCase			:    str ):





							'''simple docstring'''


							_a      	=							{'''Content-Type''': '''application/json'''}
							_a      	=							requests.post(UpperCamelCase					,		json={'''text''': message_body}					,		headers=UpperCamelCase )
							if response.status_code != 200:
														_a      	=							(
														    '''Request to slack returned an error '''
														    f'{response.status_code}, the response is:\n{response.text}'
														)
														raise ValueError(UpperCamelCase )


if __name__ == "__main__":
				# Set the slack url to the one provided by Slack when you create the webhook at
				# https://my.slack.com/services/new/incoming-webhook/
				send_slack_message('<YOUR MESSAGE BODY>', '<SLACK CHANNEL URL>')

