
import contextlib
import importlib
import io
import unittest

import transformers

# Try to import everything from transformers to ensure every object can be loaded.
from transformers import *  # noqa F406
from transformers.testing_utils import DUMMY_UNKNOWN_IDENTIFIER, require_flax, require_tf, require_torch
from transformers.utils import ContextManagers, find_labels, is_flax_available, is_tf_available, is_torch_available


if is_torch_available():
			from transformers import BertForPreTraining, BertForQuestionAnswering, BertForSequenceClassification

if is_tf_available():
			from transformers import TFBertForPreTraining, TFBertForQuestionAnswering, TFBertForSequenceClassification

if is_flax_available():
			from transformers import FlaxBertForPreTraining, FlaxBertForQuestionAnswering, FlaxBertForSequenceClassification


_A   =     DUMMY_UNKNOWN_IDENTIFIER
# An actual model hosted on huggingface.co

_A   =     "main"
# Default branch name
_A   =     "f2c752cfc5c0ab6f4bdec59acea69eefbee381c2"
# One particular commit (not the top of `main`)
_A   =     "aaaaaaa"
# This commit does not exist, so we should 404.

_A   =     "d9e9f15bc825e4b2c9249e9578f884bbcb5e3684"
# Sha-1 of config.json on the top of `main`, for checking purposes
_A   =     "4b243c475af8d0a7754e87d7d096c92e5199ec2fe168a2ee7998e3b8e9bcb1d3"






@contextlib.contextmanager
def    lowerCamelCase__				(				):




			"""simple docstring"""


			print("Welcome!"				)
			yield
			print("Bye!"				)






@contextlib.contextmanager
def    lowerCamelCase__				(				):




			"""simple docstring"""


			print("Bonjour!"				)
			yield
			print("Au revoir!"				)





class 	_lowerCAmelCase					(	unittest.TestCase       ):




				def      __a						(					self     )				->      int:
							# If the spec is missing, importlib would not be able to import the module dynamically.
							assert transformers.__spec__ is not None
							assert importlib.util.find_spec("transformers"     ) is not None





class 	_lowerCAmelCase					(	unittest.TestCase       ):




				@unittest.mock.patch("sys.stdout"				,				new_callable=io.StringIO     )
				def      __a						(					self				,				_UpperCamelCase     )				->      Optional[int]:
							with ContextManagers([]     ):
										print("Transformers are awesome!"     )
							# The print statement adds a new line at the end of the output
							self.assertEqual(mock_stdout.getvalue()				,				"Transformers are awesome!\n"     )




				@unittest.mock.patch("sys.stdout"				,				new_callable=io.StringIO     )
				def      __a						(					self				,				_UpperCamelCase     )				->      Any:
							with ContextManagers([context_en()]     ):
										print("Transformers are awesome!"     )
							# The output should be wrapped with an English welcome and goodbye
							self.assertEqual(mock_stdout.getvalue()				,				"Welcome!\nTransformers are awesome!\nBye!\n"     )




				@unittest.mock.patch("sys.stdout"				,				new_callable=io.StringIO     )
				def      __a						(					self				,				_UpperCamelCase     )				->      Optional[Any]:
							with ContextManagers([context_fr(), context_en()]     ):
										print("Transformers are awesome!"     )
							# The output should be wrapped with an English and French welcome and goodbye
							self.assertEqual(mock_stdout.getvalue()				,				"Bonjour!\nWelcome!\nTransformers are awesome!\nBye!\nAu revoir!\n"     )




				@require_torch
				def      __a						(					self     )				->      List[Any]:
							self.assertEqual(find_labels(_UpperCamelCase     )				,				["labels"]     )
							self.assertEqual(find_labels(_UpperCamelCase     )				,				["labels", "next_sentence_label"]     )
							self.assertEqual(find_labels(_UpperCamelCase     )				,				["start_positions", "end_positions"]     )





							class 	_lowerCAmelCase					(	__a       ):
											pass


							self.assertEqual(find_labels(_UpperCamelCase     )				,				["labels"]     )




				@require_tf
				def      __a						(					self     )				->      Tuple:
							self.assertEqual(find_labels(_UpperCamelCase     )				,				["labels"]     )
							self.assertEqual(find_labels(_UpperCamelCase     )				,				["labels", "next_sentence_label"]     )
							self.assertEqual(find_labels(_UpperCamelCase     )				,				["start_positions", "end_positions"]     )





							class 	_lowerCAmelCase					(	__a       ):
											pass


							self.assertEqual(find_labels(_UpperCamelCase     )				,				["labels"]     )




				@require_flax
				def      __a						(					self     )				->      Dict:
							# Flax models don't have labels
							self.assertEqual(find_labels(_UpperCamelCase     )				,				[]     )
							self.assertEqual(find_labels(_UpperCamelCase     )				,				[]     )
							self.assertEqual(find_labels(_UpperCamelCase     )				,				[]     )





							class 	_lowerCAmelCase					(	__a       ):
											pass


							self.assertEqual(find_labels(_UpperCamelCase     )				,				[]     )





import argparse

import pytorch_lightning as pl
import torch
from torch import nn

from transformers import LongformerForQuestionAnswering, LongformerModel





class 	_lowerCAmelCase					(	pl.LightningModule       ):




				def __init__(					self				,				_UpperCamelCase     )				->      List[str]:
							super().__init__()
							lowerCAmelCase_						=	model
							lowerCAmelCase_						=	2
							lowerCAmelCase_						=	nn.Linear(self.model.config.hidden_size				,				self.num_labels     )




				def      __a						(					self     )				->      Tuple:
							pass






def    lowerCamelCase__				(				__lowerCAmelCase  :  str    ,							__lowerCAmelCase  :  str    ,							__lowerCAmelCase  :  str				):




			"""simple docstring"""


			lowerCAmelCase_						=	LongformerModel.from_pretrained(__lowerCAmelCase				)
			lowerCAmelCase_						=	LightningModel(__lowerCAmelCase				)

			lowerCAmelCase_						=	torch.load(__lowerCAmelCase    ,							map_location=torch.device("cpu"				)				)
			lightning_model.load_state_dict(ckpt["state_dict"]				)

			# init longformer question answering model
			lowerCAmelCase_						=	LongformerForQuestionAnswering.from_pretrained(__lowerCAmelCase				)

			# transfer weights
			longformer_for_qa.longformer.load_state_dict(lightning_model.model.state_dict()				)
			longformer_for_qa.qa_outputs.load_state_dict(lightning_model.qa_outputs.state_dict()				)
			longformer_for_qa.eval()

			# save model
			longformer_for_qa.save_pretrained(__lowerCAmelCase				)

			print(F"""Conversion successful. Model saved under {pytorch_dump_folder_path}"""				)


if __name__ == "__main__":
			_A   =     argparse.ArgumentParser()
			# Required parameters
			parser.add_argument(
			    "--longformer_model",
			    default=None,
			    type=str,
			    required=True,
			    help="model identifier of longformer. Should be either `longformer-base-4096` or `longformer-large-4096`.",
			)
			parser.add_argument(
			    "--longformer_question_answering_ckpt_path",
			    default=None,
			    type=str,
			    required=True,
			    help="Path the official PyTorch Lightning Checkpoint.",
			)
			parser.add_argument(
			    "--pytorch_dump_folder_path", default=None, type=str, required=True, help="Path to the output PyTorch model."
			)
			_A   =     parser.parse_args()
			convert_longformer_qa_checkpoint_to_pytorch(
			    args.longformer_model, args.longformer_question_answering_ckpt_path, args.pytorch_dump_folder_path
			)



