





import unittest

from transformers import MODEL_FOR_DOCUMENT_QUESTION_ANSWERING_MAPPING, AutoTokenizer, is_vision_available
from transformers.pipelines import pipeline
from transformers.pipelines.document_question_answering import apply_tesseract
from transformers.testing_utils import (
    is_pipeline_test,
    nested_simplify,
    require_detectrona,
    require_pytesseract,
    require_tf,
    require_torch,
    require_vision,
    slow,
)

from .test_pipelines_common import ANY


if is_vision_available():
				from PIL import Image

				from transformers.image_utils import load_image
else:

				class 	A_       :
					@staticmethod
					def      _lowercase				(    *_A							,					**_A		):






								'''simple docstring'''







								pass





				def 						__SCREAMING_SNAKE_CASE  (				UpperCamelCase__ )  ->				Optional[Any]:







							'''simple docstring'''

							return None


# This is a pinned image from a specific revision of a document question answering space, hosted by HuggingFace,
# so we can expect it to be available.
__A				:    List[Any]       =   (
    "https://huggingface.co/spaces/impira/docquery/resolve/2f6c96314dc84dfda62d40de9da55f2f5165d403/invoice.png"
)

@is_pipeline_test
@require_torch
@require_vision
class 	A_       (unittest.TestCase			):
	UpperCAmelCase__					=			MODEL_FOR_DOCUMENT_QUESTION_ANSWERING_MAPPING
	@require_pytesseract
	@require_vision
	def      _lowercase				(    self							,					_A							,					_A							,					_A		):






				'''simple docstring'''







				UpperCAmelCase   		=				pipeline(
				    '''document-question-answering'''							,					model=_A							,					tokenizer=_A							,					image_processor=_A		)

				UpperCAmelCase   		=				INVOICE_URL
				UpperCAmelCase   		=				list(zip(*apply_tesseract(load_image(_A		)							,					_A							,					''''''		)		)		)
				UpperCAmelCase   		=				'''What is the placebo?'''
				UpperCAmelCase   		=				[
				    {
				        '''image''': load_image(_A		),
				        '''question''': question,
				    },
				    {
				        '''image''': image,
				        '''question''': question,
				    },
				    {
				        '''image''': image,
				        '''question''': question,
				        '''word_boxes''': word_boxes,
				    },
				]
				return dqa_pipeline, examples
	def      _lowercase				(    self							,					_A							,					_A		):






				'''simple docstring'''







				UpperCAmelCase   		=				dqa_pipeline(_A							,					top_k=2		)
				self.assertEqual(
				    _A							,					[
				        [
				            {'''score''': ANY(_A		), '''answer''': ANY(_A		), '''start''': ANY(_A		), '''end''': ANY(_A		)},
				            {'''score''': ANY(_A		), '''answer''': ANY(_A		), '''start''': ANY(_A		), '''end''': ANY(_A		)},
				        ]
				    ]
				    * 3							,					)
	@require_torch
	@require_detectrona
	@require_pytesseract
	def      _lowercase				(    self		):






				'''simple docstring'''







				UpperCAmelCase   		=				pipeline('''document-question-answering'''							,					model='''hf-internal-testing/tiny-random-layoutlmv2'''		)
				UpperCAmelCase   		=				INVOICE_URL
				UpperCAmelCase   		=				'''How many cats are there?'''

				UpperCAmelCase   		=				[
				    {'''score''': 0.00_01, '''answer''': '''oy 2312/2019''', '''start''': 3_8, '''end''': 3_9},
				    {'''score''': 0.00_01, '''answer''': '''oy 2312/2019 DUE''', '''start''': 3_8, '''end''': 4_0},
				]
				UpperCAmelCase   		=				dqa_pipeline(image=_A							,					question=_A							,					top_k=2		)
				self.assertEqual(nested_simplify(_A							,					decimals=4		)							,					_A		)

				UpperCAmelCase   		=				dqa_pipeline({'''image''': image, '''question''': question}							,					top_k=2		)
				self.assertEqual(nested_simplify(_A							,					decimals=4		)							,					_A		)

				# This image does not detect ANY text in it, meaning layoutlmv2 should fail.
				# Empty answer probably
				UpperCAmelCase   		=				'''./tests/fixtures/tests_samples/COCO/000000039769.png'''
				UpperCAmelCase   		=				dqa_pipeline(image=_A							,					question=_A							,					top_k=2		)
				self.assertEqual(_A							,					[]		)

				# We can optionnally pass directly the words and bounding boxes
				UpperCAmelCase   		=				'''./tests/fixtures/tests_samples/COCO/000000039769.png'''
				UpperCAmelCase   		=				[]
				UpperCAmelCase   		=				[]
				UpperCAmelCase   		=				dqa_pipeline(image=_A							,					question=_A							,					words=_A							,					boxes=_A							,					top_k=2		)
				self.assertEqual(_A							,					[]		)
	@slow
	@require_torch
	@require_detectrona
	@require_pytesseract
	def      _lowercase				(    self		):






				'''simple docstring'''







				UpperCAmelCase   		=				pipeline(
				    '''document-question-answering'''							,					model='''tiennvcs/layoutlmv2-base-uncased-finetuned-docvqa'''							,					revision='''9977165'''							,					)
				UpperCAmelCase   		=				INVOICE_URL
				UpperCAmelCase   		=				'''What is the invoice number?'''

				UpperCAmelCase   		=				dqa_pipeline(image=_A							,					question=_A							,					top_k=2		)
				self.assertEqual(
				    nested_simplify(_A							,					decimals=4		)							,					[
				        {'''score''': 0.99_44, '''answer''': '''us-001''', '''start''': 1_6, '''end''': 1_6},
				        {'''score''': 0.00_09, '''answer''': '''us-001''', '''start''': 1_6, '''end''': 1_6},
				    ]							,					)

				UpperCAmelCase   		=				dqa_pipeline({'''image''': image, '''question''': question}							,					top_k=2		)
				self.assertEqual(
				    nested_simplify(_A							,					decimals=4		)							,					[
				        {'''score''': 0.99_44, '''answer''': '''us-001''', '''start''': 1_6, '''end''': 1_6},
				        {'''score''': 0.00_09, '''answer''': '''us-001''', '''start''': 1_6, '''end''': 1_6},
				    ]							,					)

				UpperCAmelCase   		=				dqa_pipeline(
				    [{'''image''': image, '''question''': question}, {'''image''': image, '''question''': question}]							,					top_k=2		)
				self.assertEqual(
				    nested_simplify(_A							,					decimals=4		)							,					[
				        [
				            {'''score''': 0.99_44, '''answer''': '''us-001''', '''start''': 1_6, '''end''': 1_6},
				            {'''score''': 0.00_09, '''answer''': '''us-001''', '''start''': 1_6, '''end''': 1_6},
				        ],
				    ]
				    * 2							,					)
	@slow
	@require_torch
	@require_detectrona
	@require_pytesseract
	def      _lowercase				(    self		):






				'''simple docstring'''







				UpperCAmelCase   		=				pipeline(
				    '''document-question-answering'''							,					model='''tiennvcs/layoutlmv2-base-uncased-finetuned-docvqa'''							,					revision='''9977165'''							,					max_seq_len=5_0							,					)
				UpperCAmelCase   		=				INVOICE_URL
				UpperCAmelCase   		=				'''What is the invoice number?'''

				UpperCAmelCase   		=				dqa_pipeline(image=_A							,					question=_A							,					top_k=2		)
				self.assertEqual(
				    nested_simplify(_A							,					decimals=4		)							,					[
				        {'''score''': 0.99_74, '''answer''': '''1110212019''', '''start''': 2_3, '''end''': 2_3},
				        {'''score''': 0.99_48, '''answer''': '''us-001''', '''start''': 1_6, '''end''': 1_6},
				    ]							,					)

				UpperCAmelCase   		=				dqa_pipeline({'''image''': image, '''question''': question}							,					top_k=2		)
				self.assertEqual(
				    nested_simplify(_A							,					decimals=4		)							,					[
				        {'''score''': 0.99_74, '''answer''': '''1110212019''', '''start''': 2_3, '''end''': 2_3},
				        {'''score''': 0.99_48, '''answer''': '''us-001''', '''start''': 1_6, '''end''': 1_6},
				    ]							,					)

				UpperCAmelCase   		=				dqa_pipeline(
				    [{'''image''': image, '''question''': question}, {'''image''': image, '''question''': question}]							,					top_k=2		)
				self.assertEqual(
				    nested_simplify(_A							,					decimals=4		)							,					[
				        [
				            {'''score''': 0.99_74, '''answer''': '''1110212019''', '''start''': 2_3, '''end''': 2_3},
				            {'''score''': 0.99_48, '''answer''': '''us-001''', '''start''': 1_6, '''end''': 1_6},
				        ]
				    ]
				    * 2							,					)
	@slow
	@require_torch
	@require_pytesseract
	@require_vision
	def      _lowercase				(    self		):






				'''simple docstring'''







				UpperCAmelCase   		=				AutoTokenizer.from_pretrained(
				    '''impira/layoutlm-document-qa'''							,					revision='''3dc6de3'''							,					add_prefix_space=_A		)
				UpperCAmelCase   		=				pipeline(
				    '''document-question-answering'''							,					model='''impira/layoutlm-document-qa'''							,					tokenizer=_A							,					revision='''3dc6de3'''							,					)
				UpperCAmelCase   		=				INVOICE_URL
				UpperCAmelCase   		=				'''What is the invoice number?'''

				UpperCAmelCase   		=				dqa_pipeline(image=_A							,					question=_A							,					top_k=2		)
				self.assertEqual(
				    nested_simplify(_A							,					decimals=4		)							,					[
				        {'''score''': 0.42_51, '''answer''': '''us-001''', '''start''': 1_6, '''end''': 1_6},
				        {'''score''': 0.08_19, '''answer''': '''1110212019''', '''start''': 2_3, '''end''': 2_3},
				    ]							,					)

				UpperCAmelCase   		=				dqa_pipeline({'''image''': image, '''question''': question}							,					top_k=2		)
				self.assertEqual(
				    nested_simplify(_A							,					decimals=4		)							,					[
				        {'''score''': 0.42_51, '''answer''': '''us-001''', '''start''': 1_6, '''end''': 1_6},
				        {'''score''': 0.08_19, '''answer''': '''1110212019''', '''start''': 2_3, '''end''': 2_3},
				    ]							,					)

				UpperCAmelCase   		=				dqa_pipeline(
				    [{'''image''': image, '''question''': question}, {'''image''': image, '''question''': question}]							,					top_k=2		)
				self.assertEqual(
				    nested_simplify(_A							,					decimals=4		)							,					[
				        [
				            {'''score''': 0.42_51, '''answer''': '''us-001''', '''start''': 1_6, '''end''': 1_6},
				            {'''score''': 0.08_19, '''answer''': '''1110212019''', '''start''': 2_3, '''end''': 2_3},
				        ]
				    ]
				    * 2							,					)

				UpperCAmelCase   		=				list(zip(*apply_tesseract(load_image(_A		)							,					_A							,					''''''		)		)		)

				# This model should also work if `image` is set to None
				UpperCAmelCase   		=				dqa_pipeline({'''image''': None, '''word_boxes''': word_boxes, '''question''': question}							,					top_k=2		)
				self.assertEqual(
				    nested_simplify(_A							,					decimals=4		)							,					[
				        {'''score''': 0.42_51, '''answer''': '''us-001''', '''start''': 1_6, '''end''': 1_6},
				        {'''score''': 0.08_19, '''answer''': '''1110212019''', '''start''': 2_3, '''end''': 2_3},
				    ]							,					)
	@slow
	@require_torch
	@require_pytesseract
	@require_vision
	def      _lowercase				(    self		):






				'''simple docstring'''







				UpperCAmelCase   		=				AutoTokenizer.from_pretrained(
				    '''impira/layoutlm-document-qa'''							,					revision='''3dc6de3'''							,					add_prefix_space=_A		)
				UpperCAmelCase   		=				pipeline(
				    '''document-question-answering'''							,					model='''impira/layoutlm-document-qa'''							,					tokenizer=_A							,					revision='''3dc6de3'''							,					max_seq_len=5_0							,					)
				UpperCAmelCase   		=				INVOICE_URL
				UpperCAmelCase   		=				'''What is the invoice number?'''

				UpperCAmelCase   		=				dqa_pipeline(image=_A							,					question=_A							,					top_k=2		)
				self.assertEqual(
				    nested_simplify(_A							,					decimals=4		)							,					[
				        {'''score''': 0.99_99, '''answer''': '''us-001''', '''start''': 1_6, '''end''': 1_6},
				        {'''score''': 0.99_98, '''answer''': '''us-001''', '''start''': 1_6, '''end''': 1_6},
				    ]							,					)

				UpperCAmelCase   		=				dqa_pipeline(
				    [{'''image''': image, '''question''': question}, {'''image''': image, '''question''': question}]							,					top_k=2		)
				self.assertEqual(
				    nested_simplify(_A							,					decimals=4		)							,					[
				        [
				            {'''score''': 0.99_99, '''answer''': '''us-001''', '''start''': 1_6, '''end''': 1_6},
				            {'''score''': 0.99_98, '''answer''': '''us-001''', '''start''': 1_6, '''end''': 1_6},
				        ]
				    ]
				    * 2							,					)

				UpperCAmelCase   		=				list(zip(*apply_tesseract(load_image(_A		)							,					_A							,					''''''		)		)		)

				# This model should also work if `image` is set to None
				UpperCAmelCase   		=				dqa_pipeline({'''image''': None, '''word_boxes''': word_boxes, '''question''': question}							,					top_k=2		)
				self.assertEqual(
				    nested_simplify(_A							,					decimals=4		)							,					[
				        {'''score''': 0.99_99, '''answer''': '''us-001''', '''start''': 1_6, '''end''': 1_6},
				        {'''score''': 0.99_98, '''answer''': '''us-001''', '''start''': 1_6, '''end''': 1_6},
				    ]							,					)
	@slow
	@require_torch
	def      _lowercase				(    self		):






				'''simple docstring'''







				UpperCAmelCase   		=				pipeline(
				    '''document-question-answering'''							,					model='''naver-clova-ix/donut-base-finetuned-docvqa'''							,					tokenizer=AutoTokenizer.from_pretrained('''naver-clova-ix/donut-base-finetuned-docvqa'''		)							,					feature_extractor='''naver-clova-ix/donut-base-finetuned-docvqa'''							,					)

				UpperCAmelCase   		=				INVOICE_URL
				UpperCAmelCase   		=				'''What is the invoice number?'''
				UpperCAmelCase   		=				dqa_pipeline(image=_A							,					question=_A							,					top_k=2		)
				self.assertEqual(nested_simplify(_A							,					decimals=4		)							,					[{'''answer''': '''us-001'''}]		)







	@require_tf
	@unittest.skip('''Document question answering not implemented in TF'''		)
	def      _lowercase				(    self		):






				'''simple docstring'''







				pass










import argparse
import re

from flax.traverse_util import flatten_dict, unflatten_dict
from tax import checkpoints

from transformers import SwitchTransformersConfig, SwitchTransformersForConditionalGeneration
from transformers.modeling_flax_pytorch_utils import load_flax_weights_in_pytorch_model
from transformers.utils import logging


logging.set_verbosity_info()


# should not include what is already done by the `from_pt` argument
__A				:    int       =   {
    "/attention/": "/0/SelfAttention/",
    "/self_attention/": "/0/SelfAttention/",
    "/encoder_decoder_attention/": "/1/EncDecAttention/",
    "value": "v",
    "query": "q",
    "key": "k",
    "out": "o",
    "pre_self_attention_layer_norm": "0/layer_norm",
    "pre_cross_attention_layer_norm": "1/layer_norm",
    "pre_attention_layer_norm": "0/layer_norm",  # previously 1, but seems wrong
    "token_embedder": "shared",
    "encoder_norm": "final_layer_norm",
    "decoder_norm": "final_layer_norm",
    "relpos_bias/rel_embedding": "block/0/layer/0/SelfAttention/relative_attention_bias/weight",
    "router/router_weights/w/": "router/classifier/",
    "roer/roer_weights/w/": "router/classifier/",
    "logits_dense": "lm_head",
}





def 						__SCREAMING_SNAKE_CASE  (				UpperCamelCase__ )  ->				List[str]:







			'''simple docstring'''

			UpperCAmelCase   		=				list(s_dict.keys() )
			for key in keys:
						UpperCAmelCase   		=				R'''.*/layers_(\d+)'''
						UpperCAmelCase   		=				key
						if re.match(UpperCamelCase__			,			UpperCamelCase__ ):
									UpperCAmelCase   		=				re.sub(R'''layers_(\d+)'''			,			R'''block/\1/layer'''			,			UpperCamelCase__ )

						UpperCAmelCase   		=				R'''(encoder|decoder)\/'''

						if re.match(UpperCamelCase__			,			UpperCamelCase__ ):
									UpperCAmelCase   		=				re.match(UpperCamelCase__			,			UpperCamelCase__ ).groups()
									if groups[0] == "encoder":
												UpperCAmelCase   		=				re.sub(R'''/mlp/'''			,			R'''/1/mlp/'''			,			UpperCamelCase__ )
												UpperCAmelCase   		=				re.sub(R'''/pre_mlp_layer_norm/'''			,			R'''/1/layer_norm/'''			,			UpperCamelCase__ )

									elif groups[0] == "decoder":
												UpperCAmelCase   		=				re.sub(R'''/mlp/'''			,			R'''/2/mlp/'''			,			UpperCamelCase__ )
												UpperCAmelCase   		=				re.sub(R'''/pre_mlp_layer_norm/'''			,			R'''/2/layer_norm/'''			,			UpperCamelCase__ )

        # 2. Convert other classic mappings
						for old_key, temp_key in MOE_LAYER_NAME_MAPPING.items():
									if old_key in new_key:
												UpperCAmelCase   		=				new_key.replace(UpperCamelCase__			,			UpperCamelCase__ )

						print(F"""{key} -> {new_key}""" )
						UpperCAmelCase   		=				s_dict.pop(UpperCamelCase__ )

			if "encoder/block/0/layer/0/SelfAttention/relative_attention_bias/weight" in s_dict:
						UpperCAmelCase   		=				s_dict[
						    '''encoder/block/0/layer/0/SelfAttention/relative_attention_bias/weight'''
						].T
			if "decoder/block/0/layer/0/SelfAttention/relative_attention_bias/weight" in s_dict:
						UpperCAmelCase   		=				s_dict[
						    '''decoder/block/0/layer/0/SelfAttention/relative_attention_bias/weight'''
						].T

			# 3. Take extra care of the EXPERTS layer
			for key in list(s_dict.keys() ):
						if "expert" in key:
									UpperCAmelCase   		=				s_dict[key].shape[0]
									UpperCAmelCase   		=				s_dict[key]
									for idx in range(UpperCamelCase__ ):
												UpperCAmelCase   		=				expert_weihts[idx]
												print(F"""{key} -> {key.replace("expert/"			,			"nested fstring" )}""" )

									s_dict.pop(UpperCamelCase__ )

			return s_dict


__A				:    Optional[int]       =   {
    "NUM_ENCODER_LAYERS": "num_layers",
    "NUM_DECODER_LAYERS": "num_decoder_layers",
    "NUM_HEADS": "num_heads",
    "HEAD_DIM": "d_kv",
    "EMBED_DIM": "d_model",
    "MLP_DIM": "d_ff",
    "NUM_SELECTED_EXPERTS": "num_selected_experts",
    "NUM_ENCODER_SPARSE_LAYERS": "num_sparse_encoder_layers",
    "NUM_DECODER_SPARSE_LAYERS": "num_sparse_decoder_layers",
    "dense.MlpBlock.activations": "feed_forward_proj",
}





def 						__SCREAMING_SNAKE_CASE  (				UpperCamelCase__			,			UpperCamelCase__ )  ->				List[str]:







			'''simple docstring'''

			import regex as re

			with open(UpperCamelCase__			,			'''r''' ) as f:
						UpperCAmelCase   		=				f.read()

			UpperCAmelCase   		=				re.findall(R'''(.*) = ([0-9.]*)'''			,			UpperCamelCase__ )
			UpperCAmelCase   		=				{}
			for param, value in regex_match:
						if param in GIN_TO_CONFIG_MAPPING and value != "":
									UpperCAmelCase   		=				float(UpperCamelCase__ ) if '''.''' in value else int(UpperCamelCase__ )

			UpperCAmelCase   		=				re.findall(R'''(.*activations) = \(\'(.*)\',\)'''			,			UpperCamelCase__ )[0]
			UpperCAmelCase   		=				str(activation[1] )

			UpperCAmelCase   		=				num_experts
			UpperCAmelCase   		=				SwitchTransformersConfig(**UpperCamelCase__ )
			return config





def 						__SCREAMING_SNAKE_CASE  (				UpperCamelCase__			,			UpperCamelCase__			,			UpperCamelCase__=None			,			UpperCamelCase__="./"			,			UpperCamelCase__=8 )  ->				List[Any]:







			'''simple docstring'''

			print(F"""Loading flax weights from : {flax_checkpoint_path}""" )
			UpperCAmelCase   		=				checkpoints.load_tax_checkpoint(UpperCamelCase__ )

			if gin_file is not None:
						UpperCAmelCase   		=				convert_gin_to_config(UpperCamelCase__			,			UpperCamelCase__ )
			else:
						UpperCAmelCase   		=				SwitchTransformersConfig.from_pretrained(UpperCamelCase__ )

			UpperCAmelCase   		=				SwitchTransformersForConditionalGeneration(UpperCamelCase__ )

			UpperCAmelCase   		=				flax_params['''target''']
			UpperCAmelCase   		=				flatten_dict(UpperCamelCase__			,			sep='''/''' )
			UpperCAmelCase   		=				rename_keys(UpperCamelCase__ )
			UpperCAmelCase   		=				unflatten_dict(UpperCamelCase__			,			sep='''/''' )

			# Load the flax params in the PT model
			load_flax_weights_in_pytorch_model(UpperCamelCase__			,			UpperCamelCase__ )

			print(F"""Save PyTorch model to {pytorch_dump_path}""" )
			pt_model.save_pretrained(UpperCamelCase__ )


if __name__ == "__main__":
				__A				:    Tuple       =   argparse.ArgumentParser()
				# Required parameters
				parser.add_argument(
				    "--switch_t5x_checkpoint_path",
				    default=None,
				    type=str,
				    required=True,
				    help=(
				        "The config json file corresponding to the pre-trained SwitchTransformers model. \nThis specifies the"
				        " model architecture. If not provided, a `gin_file` has to be provided."
				    ),
				)
				parser.add_argument(
				    "--gin_file",
				    default=None,
				    type=str,
				    required=False,
				    help="Path to the gin config file. If not provided, a `config_file` has to be passed   ",
				)
				parser.add_argument(
				    "--config_name", default=None, type=str, required=False, help="Config name of SwitchTransformers model."
				)
				parser.add_argument(
				    "--pytorch_dump_folder_path", default=None, type=str, required=True, help="Path to the output pytorch model."
				)
				parser.add_argument("--num_experts", default=8, type=int, required=False, help="Number of experts")
				__A				:    Tuple       =   parser.parse_args()
				convert_flax_checkpoint_to_pytorch(
				    args.switch_tax_checkpoint_path,
				    args.config_name,
				    args.gin_file,
				    args.pytorch_dump_folder_path,
				    args.num_experts,
				)



