





'''simple docstring'''




import argparse
import os

import torch

from transformers import (
    XLNetConfig,
    XLNetForQuestionAnswering,
    XLNetForSequenceClassification,
    XLNetLMHeadModel,
    load_tf_weights_in_xlnet,
)
from transformers.utils import CONFIG_NAME, WEIGHTS_NAME, logging


__UpperCAmelCase            =       {
    """cola""": 2,
    """mnli""": 3,
    """mrpc""": 2,
    """sst-2""": 2,
    """sts-b""": 1,
    """qqp""": 2,
    """qnli""": 2,
    """rte""": 2,
    """wnli""": 2,
}


logging.set_verbosity_info()



def 		__A		(  lowerCamelCase_			,			lowerCamelCase_			,			lowerCamelCase_			,			lowerCamelCase_=None	):


		"""simple docstring"""



		SCREAMING_SNAKE_CASE :				Optional[Any]		=			XLNetConfig.from_json_file(lowerCamelCase_	)

		SCREAMING_SNAKE_CASE :				str		=			finetuning_task.lower() if finetuning_task is not None else """"""
		if finetuning_task in GLUE_TASKS_NUM_LABELS:
				print(f'''Building PyTorch XLNetForSequenceClassification model from configuration: {config}'''	)
				SCREAMING_SNAKE_CASE :				Union[str, Any]		=			finetuning_task
				SCREAMING_SNAKE_CASE :				Tuple		=			GLUE_TASKS_NUM_LABELS[finetuning_task]
				SCREAMING_SNAKE_CASE :				Optional[int]		=			XLNetForSequenceClassification(lowerCamelCase_	)
		elif "squad" in finetuning_task:
				SCREAMING_SNAKE_CASE :				int		=			finetuning_task
				SCREAMING_SNAKE_CASE :				Optional[int]		=			XLNetForQuestionAnswering(lowerCamelCase_	)
		else:
				SCREAMING_SNAKE_CASE :				List[Any]		=			XLNetLMHeadModel(lowerCamelCase_	)

		# Load weights from tf checkpoint
		load_tf_weights_in_xlnet(lowerCamelCase_			,			lowerCamelCase_			,			lowerCamelCase_	)

		# Save pytorch-model
		SCREAMING_SNAKE_CASE :				Optional[Any]		=			os.path.join(lowerCamelCase_			,			lowerCamelCase_	)
		SCREAMING_SNAKE_CASE :				Optional[int]		=			os.path.join(lowerCamelCase_			,			lowerCamelCase_	)
		print(f'''Save PyTorch model to {os.path.abspath(lowerCamelCase_	)}'''	)
		torch.save(model.state_dict()			,			lowerCamelCase_	)
		print(f'''Save configuration file to {os.path.abspath(lowerCamelCase_	)}'''	)
		with open(lowerCamelCase_			,			"""w"""			,			encoding="""utf-8"""	) as f:
				f.write(config.to_json_string()	)


if __name__ == "__main__":
							__UpperCAmelCase            =       argparse.ArgumentParser()
							# Required parameters
							parser.add_argument(
							    """--tf_checkpoint_path""", default=None, type=str, required=True, help="""Path to the TensorFlow checkpoint path."""
							)
							parser.add_argument(
							    """--xlnet_config_file""",
							    default=None,
							    type=str,
							    required=True,
							    help=(
							        """The config json file corresponding to the pre-trained XLNet model. \n"""
							        """This specifies the model architecture."""
							    ),
							)
							parser.add_argument(
							    """--pytorch_dump_folder_path""",
							    default=None,
							    type=str,
							    required=True,
							    help="""Path to the folder to store the PyTorch model or dataset/vocab.""",
							)
							parser.add_argument(
							    """--finetuning_task""",
							    default=None,
							    type=str,
							    help="""Name of a task on which the XLNet TensorFlow model was fine-tuned""",
							)
							__UpperCAmelCase            =       parser.parse_args()
							print(args)

							convert_xlnet_checkpoint_to_pytorch(
							    args.tf_checkpoint_path, args.xlnet_config_file, args.pytorch_dump_folder_path, args.finetuning_task
							)










'''simple docstring'''




import unittest

from transformers import DonutProcessor


__UpperCAmelCase            =       """naver-clova-ix/donut-base"""




class      UpperCamelCase__					(					unittest.TestCase			):




					"""simple docstring"""


					def lowerCamelCase_			(						self				:			List[str]						):

							'''simple docstring'''



							SCREAMING_SNAKE_CASE :				Any		=			DonutProcessor.from_pretrained(lowerCamelCase_						)



					def lowerCamelCase_			(						self				:			Tuple						):

							'''simple docstring'''



							SCREAMING_SNAKE_CASE :				Optional[int]		=			{
							    """name""": """John Doe""",
							    """age""": """99""",
							    """city""": """Atlanta""",
							    """state""": """GA""",
							    """zip""": """30301""",
							    """phone""": """123-4567""",
							    """nicknames""": [{"""nickname""": """Johnny"""}, {"""nickname""": """JD"""}],
							}

							SCREAMING_SNAKE_CASE :				List[Any]		=			(
							    """<s_name>John Doe</s_name><s_age>99</s_age><s_city>Atlanta</s_city>"""
							    """<s_state>GA</s_state><s_zip>30301</s_zip><s_phone>123-4567</s_phone>"""
							    """<s_nicknames><s_nickname>Johnny</s_nickname>"""
							    """<sep/><s_nickname>JD</s_nickname></s_nicknames>"""
							)
							SCREAMING_SNAKE_CASE :				List[Any]		=			self.processor.tokenajson(lowerCamelCase_						)

							self.assertDictEqual(lowerCamelCase_      ,						lowerCamelCase_						)



