




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   (_lowerCAmelCase     ):
							SCREAMING_SNAKE_CASE_   	=    model.config

							SCREAMING_SNAKE_CASE_   	=    DonutSwinConfig(
							    image_size=original_config.input_size  ,    patch_size=4  ,    depths=original_config.encoder_layer  ,    num_heads=[4, 8, 1_6, 3_2]  ,    window_size=original_config.window_size  ,    embed_dim=1_2_8  ,    )
							SCREAMING_SNAKE_CASE_   	=    MBartConfig(
							    is_decoder=_lowerCAmelCase  ,    is_encoder_decoder=_lowerCAmelCase  ,    add_cross_attention=_lowerCAmelCase  ,    decoder_layers=original_config.decoder_layer  ,    max_position_embeddings=original_config.max_position_embeddings  ,    vocab_size=len(
							        model.decoder.tokenizer     )  ,    scale_embedding=_lowerCAmelCase  ,    add_final_layer_norm=_lowerCAmelCase  ,    )

							return encoder_config, decoder_config

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

														if name == "encoder.norm.weight":
																					SCREAMING_SNAKE_CASE_   	=    '''encoder.layernorm.weight'''
														if name == "encoder.norm.bias":
																					SCREAMING_SNAKE_CASE_   	=    '''encoder.layernorm.bias'''

							return name

def 			a   (_lowerCAmelCase  ,    _lowerCAmelCase     ):
							for key in orig_state_dict.copy().keys():
														SCREAMING_SNAKE_CASE_   	=    orig_state_dict.pop(_lowerCAmelCase     )

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

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

							return orig_state_dict

def 			a   (_lowerCAmelCase  ,    _lowerCAmelCase=None  ,    _lowerCAmelCase=False     ):
							# load original model
							SCREAMING_SNAKE_CASE_   	=    DonutModel.from_pretrained(_lowerCAmelCase     ).eval()

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

							SCREAMING_SNAKE_CASE_   	=    original_model.state_dict()
							SCREAMING_SNAKE_CASE_   	=    convert_state_dict(_lowerCAmelCase  ,    _lowerCAmelCase     )
							model.load_state_dict(_lowerCAmelCase     )

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

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

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

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

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

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

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

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








import unittest

from transformers import is_torch_available
from transformers.testing_utils import require_torch


if is_torch_available():
			import torch

			from transformers.generation import DisjunctiveConstraint






@require_torch
class  __magic_name__						(  unittest.TestCase):
				'''simple docstring'''







				def     _A							(							self:   str		):
											# For consistency across different places the DisjunctiveConstraint is called,
											# dc.token_ids is a list of integers. It is also initialized only by integers.

											SCREAMING_SNAKE_CASE_   	=    [[1, 2, 4], [1, 2, 3, 4]]
											SCREAMING_SNAKE_CASE_   	=    DisjunctiveConstraint(_lowerCamelCase		)
											self.assertTrue(isinstance(dc.token_ids		,					_lowerCamelCase		)		)

											with self.assertRaises(_lowerCamelCase		):
																		DisjunctiveConstraint(torch.LongTensor([[1, 2, 4], [1, 2, 3]]		)		)

											with self.assertRaises(_lowerCamelCase		):
																		DisjunctiveConstraint([torch.LongTensor([1, 2, 4]		), torch.LongTensor([1, 2, 3, 4, 5]		)]		)


				def     _A							(							self:   Union[str, Any]		):
											# We can't have constraints that are complete subsets of another. This leads to a preverse
											# interpretation of "constraint fulfillment": does generating [1,2,3] fulfill the constraint?
											# It would mean that it generated [1,2] which fulfills it, but it's in the middle of potentially
											# fulfilling [1,2,3,4]. If we believe that [1,2,3] does fulfill the constraint, then the algorithm
											# will necessarily never reach [1,2,3,4], giving users a false sense of control (better to just not allow it).
											SCREAMING_SNAKE_CASE_   	=    [[1, 2], [1, 2, 3, 4]]

											with self.assertRaises(_lowerCamelCase		):
																		DisjunctiveConstraint(_lowerCamelCase		)  # fails here


				def     _A							(							self:   Dict		):
											SCREAMING_SNAKE_CASE_   	=    [[1, 2, 3], [1, 2, 4]]

											SCREAMING_SNAKE_CASE_   	=    DisjunctiveConstraint(_lowerCamelCase		)

											SCREAMING_SNAKE_CASE_	,	SCREAMING_SNAKE_CASE_	,	SCREAMING_SNAKE_CASE_   	=    dc.update(1		)
											SCREAMING_SNAKE_CASE_   	=    stepped is True and completed is False and reset is False
											self.assertTrue(_lowerCamelCase		)
											self.assertTrue(not dc.completed		)
											self.assertTrue(dc.current_seq == [1]		)

											SCREAMING_SNAKE_CASE_	,	SCREAMING_SNAKE_CASE_	,	SCREAMING_SNAKE_CASE_   	=    dc.update(2		)
											SCREAMING_SNAKE_CASE_   	=    stepped is True and completed is False and reset is False
											self.assertTrue(_lowerCamelCase		)
											self.assertTrue(not dc.completed		)
											self.assertTrue(dc.current_seq == [1, 2]		)

											SCREAMING_SNAKE_CASE_	,	SCREAMING_SNAKE_CASE_	,	SCREAMING_SNAKE_CASE_   	=    dc.update(3		)
											SCREAMING_SNAKE_CASE_   	=    stepped is True and completed is True and reset is False
											self.assertTrue(_lowerCamelCase		)
											self.assertTrue(dc.completed		)  # Completed!
											self.assertTrue(dc.current_seq == [1, 2, 3]		)





				def     _A							(							self:   Optional[int]		):
											SCREAMING_SNAKE_CASE_   	=    [[1, 2, 3], [1, 2, 4, 5], [1, 2, 5]]

											SCREAMING_SNAKE_CASE_   	=    DisjunctiveConstraint(_lowerCamelCase		)

											SCREAMING_SNAKE_CASE_	,	SCREAMING_SNAKE_CASE_	,	SCREAMING_SNAKE_CASE_   	=    dc.update(1		)
											self.assertTrue(not dc.completed		)
											self.assertTrue(dc.current_seq == [1]		)

											SCREAMING_SNAKE_CASE_	,	SCREAMING_SNAKE_CASE_	,	SCREAMING_SNAKE_CASE_   	=    dc.update(2		)
											self.assertTrue(not dc.completed		)
											self.assertTrue(dc.current_seq == [1, 2]		)

											SCREAMING_SNAKE_CASE_	,	SCREAMING_SNAKE_CASE_	,	SCREAMING_SNAKE_CASE_   	=    dc.update(4		)
											self.assertTrue(not dc.completed		)
											self.assertTrue(dc.current_seq == [1, 2, 4]		)

											SCREAMING_SNAKE_CASE_	,	SCREAMING_SNAKE_CASE_	,	SCREAMING_SNAKE_CASE_   	=    dc.update(5		)
											self.assertTrue(dc.completed		)  # Completed!
											self.assertTrue(dc.current_seq == [1, 2, 4, 5]		)

											dc.reset()

											SCREAMING_SNAKE_CASE_	,	SCREAMING_SNAKE_CASE_	,	SCREAMING_SNAKE_CASE_   	=    dc.update(1		)
											self.assertTrue(not dc.completed		)
											self.assertTrue(dc.remaining() == 3		)
											self.assertTrue(dc.current_seq == [1]		)

											SCREAMING_SNAKE_CASE_	,	SCREAMING_SNAKE_CASE_	,	SCREAMING_SNAKE_CASE_   	=    dc.update(2		)
											self.assertTrue(not dc.completed		)
											self.assertTrue(dc.remaining() == 2		)
											self.assertTrue(dc.current_seq == [1, 2]		)

											SCREAMING_SNAKE_CASE_	,	SCREAMING_SNAKE_CASE_	,	SCREAMING_SNAKE_CASE_   	=    dc.update(5		)
											self.assertTrue(dc.completed		)  # Completed!
											self.assertTrue(dc.remaining() == 0		)
											self.assertTrue(dc.current_seq == [1, 2, 5]		)


