
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


__SCREAMING_SNAKE_CASE           =  {
    '''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 	UpperCAmelCase   (						_lowerCamelCase ,    _lowerCamelCase ,    _lowerCamelCase ,    _lowerCamelCase=None    ):
			# Initialise PyTorch model
			A							:					int              =						XLNetConfig.from_json_file(lowerCAmelCase__    )

			A							:					Dict              =						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}"""    )
						A							:					Optional[int]              =						finetuning_task
						A							:					int              =						GLUE_TASKS_NUM_LABELS[finetuning_task]
						A							:					str              =						XLNetForSequenceClassification(lowerCAmelCase__    )
			elif "squad" in finetuning_task:
						A							:					Dict              =						finetuning_task
						A							:					Dict              =						XLNetForQuestionAnswering(lowerCAmelCase__    )
			else:
						A							:					Any              =						XLNetLMHeadModel(lowerCAmelCase__    )

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

			# Save pytorch-model
			A							:					Tuple              =						os.path.join(lowerCAmelCase__ ,    lowerCAmelCase__    )
			A							:					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__":
							__SCREAMING_SNAKE_CASE           =  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""",
							)
							__SCREAMING_SNAKE_CASE           =  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
							)




from collections.abc import Sequence




def 	UpperCAmelCase   (						_lowerCamelCase = None    ):
			if nums is None or not nums:
						raise ValueError("Input sequence should not be empty"    )

			A							:					Dict              =						nums[0]
			for i in range(1 ,    len(_lowerCamelCase    )    ):
						A							:					Tuple              =						nums[i]
						A							:					List[Any]              =						max(_lowerCamelCase ,    ans + num ,    _lowerCamelCase    )

			return ans


if __name__ == "__main__":
							import doctest

							doctest.testmod()

							# Try on a sample input from the user
							__SCREAMING_SNAKE_CASE           =  int(input("""Enter number of elements : """).strip())
							__SCREAMING_SNAKE_CASE           =  list(map(int, input("""\nEnter the numbers : """).strip().split()))[:n]
							print(max_subsequence_sum(array))