
"""simple docstring"""


import tempfile
import unittest

from transformers import DPRConfig, is_torch_available
from transformers.testing_utils import require_torch, slow, torch_device

from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, ids_tensor, random_attention_mask
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
			import torch

			from transformers import DPRContextEncoder, DPRQuestionEncoder, DPRReader, DPRReaderTokenizer
			from transformers.models.dpr.modeling_dpr import (
			    DPR_CONTEXT_ENCODER_PRETRAINED_MODEL_ARCHIVE_LIST,
			    DPR_QUESTION_ENCODER_PRETRAINED_MODEL_ARCHIVE_LIST,
			    DPR_READER_PRETRAINED_MODEL_ARCHIVE_LIST,
			)







class 						lowerCamelCase__   :





			'''simple docstring'''



			def __init__(				self	,	__UpperCAmelCase	,	__UpperCAmelCase=13	,	__UpperCAmelCase=7	,	__UpperCAmelCase=False	,	__UpperCAmelCase=True	,	__UpperCAmelCase=True	,	__UpperCAmelCase=True	,	__UpperCAmelCase=99	,	__UpperCAmelCase=32	,	__UpperCAmelCase=5	,	__UpperCAmelCase=4	,	__UpperCAmelCase=37	,	__UpperCAmelCase="gelu"	,	__UpperCAmelCase=0.1	,	__UpperCAmelCase=0.1	,	__UpperCAmelCase=5_12	,	__UpperCAmelCase=16	,	__UpperCAmelCase=2	,	__UpperCAmelCase=0.0_2	,	__UpperCAmelCase=3	,	__UpperCAmelCase=4	,	__UpperCAmelCase=None	,	__UpperCAmelCase=0	,	)					->	Any:
				_lowerCAmelCase								=parent
				_lowerCAmelCase								=batch_size
				_lowerCAmelCase								=seq_length
				_lowerCAmelCase								=is_training
				_lowerCAmelCase								=use_input_mask
				_lowerCAmelCase								=use_token_type_ids
				_lowerCAmelCase								=use_labels
				_lowerCAmelCase								=vocab_size
				_lowerCAmelCase								=hidden_size
				_lowerCAmelCase								=num_hidden_layers
				_lowerCAmelCase								=num_attention_heads
				_lowerCAmelCase								=intermediate_size
				_lowerCAmelCase								=hidden_act
				_lowerCAmelCase								=hidden_dropout_prob
				_lowerCAmelCase								=attention_probs_dropout_prob
				_lowerCAmelCase								=max_position_embeddings
				_lowerCAmelCase								=type_vocab_size
				_lowerCAmelCase								=type_sequence_label_size
				_lowerCAmelCase								=initializer_range
				_lowerCAmelCase								=num_labels
				_lowerCAmelCase								=num_choices
				_lowerCAmelCase								=scope
				_lowerCAmelCase								=projection_dim



			def    _lowerCAmelCase						(				self    )					->	Optional[int]:
				_lowerCAmelCase								=ids_tensor([self.batch_size, self.seq_length]	,	self.vocab_size    )

				_lowerCAmelCase								=None
				if self.use_input_mask:
					_lowerCAmelCase								=random_attention_mask([self.batch_size, self.seq_length]    )

				_lowerCAmelCase								=None
				if self.use_token_type_ids:
					_lowerCAmelCase								=ids_tensor([self.batch_size, self.seq_length]	,	self.type_vocab_size    )

				_lowerCAmelCase								=None
				_lowerCAmelCase								=None
				_lowerCAmelCase								=None
				if self.use_labels:
					_lowerCAmelCase								=ids_tensor([self.batch_size]	,	self.type_sequence_label_size    )
					_lowerCAmelCase								=ids_tensor([self.batch_size, self.seq_length]	,	self.num_labels    )
					_lowerCAmelCase								=ids_tensor([self.batch_size]	,	self.num_choices    )

				_lowerCAmelCase								=self.get_config()

				return config, input_ids, token_type_ids, input_mask, sequence_labels, token_labels, choice_labels



			def    _lowerCAmelCase						(				self    )					->	Optional[Any]:
				return DPRConfig(
				    projection_dim=self.projection_dim	,	vocab_size=self.vocab_size	,	hidden_size=self.hidden_size	,	num_hidden_layers=self.num_hidden_layers	,	num_attention_heads=self.num_attention_heads	,	intermediate_size=self.intermediate_size	,	hidden_act=self.hidden_act	,	hidden_dropout_prob=self.hidden_dropout_prob	,	attention_probs_dropout_prob=self.attention_probs_dropout_prob	,	max_position_embeddings=self.max_position_embeddings	,	type_vocab_size=self.type_vocab_size	,	initializer_range=self.initializer_range	,	)



			def    _lowerCAmelCase						(				self	,	__UpperCAmelCase	,	__UpperCAmelCase	,	__UpperCAmelCase	,	__UpperCAmelCase	,	__UpperCAmelCase	,	__UpperCAmelCase	,	__UpperCAmelCase    )					->	Tuple:
				_lowerCAmelCase								=DPRContextEncoder(config=__UpperCAmelCase    )
				model.to(__UpperCAmelCase    )
				model.eval()
				_lowerCAmelCase								=model(__UpperCAmelCase	,	attention_mask=__UpperCAmelCase	,	token_type_ids=__UpperCAmelCase    )
				_lowerCAmelCase								=model(__UpperCAmelCase	,	token_type_ids=__UpperCAmelCase    )
				_lowerCAmelCase								=model(__UpperCAmelCase    )
				self.parent.assertEqual(result.pooler_output.shape	,	(self.batch_size, self.projection_dim or self.hidden_size)    )



			def    _lowerCAmelCase						(				self	,	__UpperCAmelCase	,	__UpperCAmelCase	,	__UpperCAmelCase	,	__UpperCAmelCase	,	__UpperCAmelCase	,	__UpperCAmelCase	,	__UpperCAmelCase    )					->	int:
				_lowerCAmelCase								=DPRQuestionEncoder(config=__UpperCAmelCase    )
				model.to(__UpperCAmelCase    )
				model.eval()
				_lowerCAmelCase								=model(__UpperCAmelCase	,	attention_mask=__UpperCAmelCase	,	token_type_ids=__UpperCAmelCase    )
				_lowerCAmelCase								=model(__UpperCAmelCase	,	token_type_ids=__UpperCAmelCase    )
				_lowerCAmelCase								=model(__UpperCAmelCase    )
				self.parent.assertEqual(result.pooler_output.shape	,	(self.batch_size, self.projection_dim or self.hidden_size)    )



			def    _lowerCAmelCase						(				self	,	__UpperCAmelCase	,	__UpperCAmelCase	,	__UpperCAmelCase	,	__UpperCAmelCase	,	__UpperCAmelCase	,	__UpperCAmelCase	,	__UpperCAmelCase    )					->	Tuple:
				_lowerCAmelCase								=DPRReader(config=__UpperCAmelCase    )
				model.to(__UpperCAmelCase    )
				model.eval()
				_lowerCAmelCase								=model(
				    __UpperCAmelCase	,	attention_mask=__UpperCAmelCase	,	)

				self.parent.assertEqual(result.start_logits.shape	,	(self.batch_size, self.seq_length)    )
				self.parent.assertEqual(result.end_logits.shape	,	(self.batch_size, self.seq_length)    )
				self.parent.assertEqual(result.relevance_logits.shape	,	(self.batch_size,)    )



			def    _lowerCAmelCase						(				self    )					->	Tuple:
				_lowerCAmelCase								=self.prepare_config_and_inputs()
				(
				    (
				    _lowerCAmelCase
				)		,				(
				    _lowerCAmelCase
				)		,				(
				    _lowerCAmelCase
				)		,				(
				    _lowerCAmelCase
				)		,				(
				    _lowerCAmelCase
				)		,				(
				    _lowerCAmelCase
				)		,				(
				    _lowerCAmelCase
				)		,				
				)								=config_and_inputs
				_lowerCAmelCase								={"""input_ids""": input_ids}
				return config, inputs_dict







@require_torch
class 						lowerCamelCase__   (   __magic_name__					,      __magic_name__					,      unittest.TestCase							):





			'''simple docstring'''
			lowerCamelCase       =						(
			    (
			        DPRContextEncoder,
			        DPRQuestionEncoder,
			        DPRReader,
			    )
			    if is_torch_available()
			    else ()
			)
			lowerCamelCase       =						{'''feature-extraction''': DPRQuestionEncoder} if is_torch_available() else {}

			lowerCamelCase       =						False
			lowerCamelCase       =						False  # why?
			lowerCamelCase       =						False
			lowerCamelCase       =						False



			def    _lowerCAmelCase						(				self    )					->	Dict:
				_lowerCAmelCase								=DPRModelTester(self    )
				_lowerCAmelCase								=ConfigTester(self	,	config_class=__UpperCAmelCase	,	hidden_size=37    )



			def    _lowerCAmelCase						(				self    )					->	Optional[Any]:
				self.config_tester.run_common_tests()



			def    _lowerCAmelCase						(				self    )					->	Union[str, Any]:
				_lowerCAmelCase								=self.model_tester.prepare_config_and_inputs()
				self.model_tester.create_and_check_context_encoder(*__UpperCAmelCase    )



			def    _lowerCAmelCase						(				self    )					->	List[Any]:
				_lowerCAmelCase								=self.model_tester.prepare_config_and_inputs()
				self.model_tester.create_and_check_question_encoder(*__UpperCAmelCase    )



			def    _lowerCAmelCase						(				self    )					->	Optional[Any]:
				_lowerCAmelCase								=self.model_tester.prepare_config_and_inputs()
				self.model_tester.create_and_check_reader(*__UpperCAmelCase    )



			def    _lowerCAmelCase						(				self    )					->	List[str]:
				_lowerCAmelCase								=self.model_tester.prepare_config_and_inputs()[0]

				_lowerCAmelCase								=DPRQuestionEncoder(config=__UpperCAmelCase    )
				model.to(__UpperCAmelCase    )
				model.eval()

				with tempfile.TemporaryDirectory() as tmp_dirname:
					model.save_pretrained(__UpperCAmelCase    )
					_lowerCAmelCase								=DPRQuestionEncoder.from_pretrained(__UpperCAmelCase	,	projection_dim=5_12    )

				self.assertIsNotNone(__UpperCAmelCase    )



			@slow
			def    _lowerCAmelCase						(				self    )					->	Dict:
				for model_name in DPR_CONTEXT_ENCODER_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
					_lowerCAmelCase								=DPRContextEncoder.from_pretrained(__UpperCAmelCase    )
					self.assertIsNotNone(__UpperCAmelCase    )

				for model_name in DPR_CONTEXT_ENCODER_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
					_lowerCAmelCase								=DPRContextEncoder.from_pretrained(__UpperCAmelCase    )
					self.assertIsNotNone(__UpperCAmelCase    )

				for model_name in DPR_QUESTION_ENCODER_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
					_lowerCAmelCase								=DPRQuestionEncoder.from_pretrained(__UpperCAmelCase    )
					self.assertIsNotNone(__UpperCAmelCase    )

				for model_name in DPR_READER_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
					_lowerCAmelCase								=DPRReader.from_pretrained(__UpperCAmelCase    )
					self.assertIsNotNone(__UpperCAmelCase    )







@require_torch
class 						lowerCamelCase__   (   unittest.TestCase							):





			'''simple docstring'''



			@slow
			def    _lowerCAmelCase						(				self    )					->	Union[str, Any]:
				_lowerCAmelCase								=DPRQuestionEncoder.from_pretrained("""facebook/dpr-question_encoder-single-nq-base"""	,	return_dict=__UpperCAmelCase    )
				model.to(__UpperCAmelCase    )

				_lowerCAmelCase								=torch.tensor(
				    [[1_01, 75_92, 10_10, 20_03, 20_26, 38_99, 1_01_40, 10_29, 1_02]]	,	dtype=torch.long	,	device=__UpperCAmelCase    )  # [CLS] hello, is my dog cute? [SEP]
				_lowerCAmelCase								=model(__UpperCAmelCase    )[0]  # embedding shape = (1, 768)
				# compare the actual values for a slice.
				_lowerCAmelCase								=torch.tensor(
				    [
				        [
				            0.0_3_2_3_6_2_5_3,
				            0.1_2_7_5_3_3_3_5,
				            0.1_6_8_1_8_5_0_9,
				            0.0_0_2_7_9_7_8_6,
				            0.3_8_9_6_9_3_3,
				            0.2_4_2_6_4_9_4_5,
				            0.2_1_7_8_9_7_1,
				            -0.0_2_3_3_5_2_2_7,
				            -0.0_8_4_8_1_9_5_9,
				            -0.1_4_3_2_4_1_1_7,
				        ]
				    ]	,	dtype=torch.float	,	device=__UpperCAmelCase	,	)
				self.assertTrue(torch.allclose(output[:, :10]	,	__UpperCAmelCase	,	atol=1e-4    )    )



			@slow
			def    _lowerCAmelCase						(				self    )					->	Tuple:
				_lowerCAmelCase								=DPRReaderTokenizer.from_pretrained("""facebook/dpr-reader-single-nq-base"""    )
				_lowerCAmelCase								=DPRReader.from_pretrained("""facebook/dpr-reader-single-nq-base"""    )
				model.to(__UpperCAmelCase    )

				_lowerCAmelCase								=tokenizer(
				    questions="""What is love ?"""	,	titles="""Haddaway"""	,	texts="""What Is Love is a song recorded by the artist Haddaway"""	,	padding=__UpperCAmelCase	,	return_tensors="""pt"""	,	)
				encoded_inputs.to(__UpperCAmelCase    )

				_lowerCAmelCase								=model(**__UpperCAmelCase    )

				# compare the actual values for a slice.
				_lowerCAmelCase								=torch.tensor(
				    [[-1_0.3_0_0_5, -1_0.7_7_6_5, -1_1.4_8_7_2, -1_1.6_8_4_1, -1_1.9_3_1_2, -1_0.3_0_0_2, -9.8_5_4_4, -1_1.7_3_7_8, -1_2.0_8_2_1, -1_0.2_9_7_5]]	,	dtype=torch.float	,	device=__UpperCAmelCase	,	)

				_lowerCAmelCase								=torch.tensor(
				    [[-1_1.0_6_8_4, -1_1.7_0_4_1, -1_1.5_3_9_7, -1_0.3_4_6_5, -1_0.8_7_9_1, -6.8_4_4_3, -1_1.9_9_5_9, -1_1.0_3_6_4, -1_0.0_0_9_6, -6.8_4_0_5]]	,	dtype=torch.float	,	device=__UpperCAmelCase	,	)
				self.assertTrue(torch.allclose(outputs.start_logits[:, :10]	,	__UpperCAmelCase	,	atol=1e-4    )    )
				self.assertTrue(torch.allclose(outputs.end_logits[:, :10]	,	__UpperCAmelCase	,	atol=1e-4    )    )





"""simple docstring"""


from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available, is_vision_available


__A					=			{
    'configuration_donut_swin': ['DONUT_SWIN_PRETRAINED_CONFIG_ARCHIVE_MAP', 'DonutSwinConfig'],
    'processing_donut': ['DonutProcessor'],
}

try:
			if not is_torch_available():
						raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
			pass
else:
			__A					=			[
			    'DONUT_SWIN_PRETRAINED_MODEL_ARCHIVE_LIST',
			    'DonutSwinModel',
			    'DonutSwinPreTrainedModel',
			]

try:
			if not is_vision_available():
						raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
			pass
else:
			__A					=			['DonutFeatureExtractor']
			__A					=			['DonutImageProcessor']


if TYPE_CHECKING:
			from .configuration_donut_swin import DONUT_SWIN_PRETRAINED_CONFIG_ARCHIVE_MAP, DonutSwinConfig
			from .processing_donut import DonutProcessor

			try:
						if not is_torch_available():
									raise OptionalDependencyNotAvailable()
			except OptionalDependencyNotAvailable:
						pass
			else:
						from .modeling_donut_swin import (
						    DONUT_SWIN_PRETRAINED_MODEL_ARCHIVE_LIST,
						    DonutSwinModel,
						    DonutSwinPreTrainedModel,
						)

			try:
						if not is_vision_available():
									raise OptionalDependencyNotAvailable()
			except OptionalDependencyNotAvailable:
						pass
			else:
						from .feature_extraction_donut import DonutFeatureExtractor
						from .image_processing_donut import DonutImageProcessor

else:
			import sys

			__A					=			_LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)



