





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:	Union[str, Any],				lowerCamelCase_:	Optional[Any],				lowerCamelCase_:	Dict=13,				lowerCamelCase_:	Any=7,				lowerCamelCase_:	Tuple=False,				lowerCamelCase_:	Optional[Any]=True,				lowerCamelCase_:	List[Any]=True,				lowerCamelCase_:	Any=True,				lowerCamelCase_:	List[Any]=99,				lowerCamelCase_:	Optional[Any]=32,				lowerCamelCase_:	Tuple=5,				lowerCamelCase_:	Optional[int]=4,				lowerCamelCase_:	List[Any]=37,				lowerCamelCase_:	Optional[int]="gelu",				lowerCamelCase_:	Any=0.1,				lowerCamelCase_:	List[str]=0.1,				lowerCamelCase_:	Dict=512,				lowerCamelCase_:	List[str]=16,				lowerCamelCase_:	Dict=2,				lowerCamelCase_:	List[str]=0.0_2,				lowerCamelCase_:	Dict=3,				lowerCamelCase_:	int=4,				lowerCamelCase_:	Union[str, Any]=None,				lowerCamelCase_:	Any=0,				):
			lowercase__				:			Optional[int]            =		parent
			lowercase__				:			List[str]            =		batch_size
			lowercase__				:			List[str]            =		seq_length
			lowercase__				:			Union[str, Any]            =		is_training
			lowercase__				:			Optional[int]            =		use_input_mask
			lowercase__				:			Dict            =		use_token_type_ids
			lowercase__				:			str            =		use_labels
			lowercase__				:			Any            =		vocab_size
			lowercase__				:			Optional[Any]            =		hidden_size
			lowercase__				:			Union[str, Any]            =		num_hidden_layers
			lowercase__				:			Dict            =		num_attention_heads
			lowercase__				:			Optional[int]            =		intermediate_size
			lowercase__				:			List[str]            =		hidden_act
			lowercase__				:			Optional[Any]            =		hidden_dropout_prob
			lowercase__				:			Union[str, Any]            =		attention_probs_dropout_prob
			lowercase__				:			int            =		max_position_embeddings
			lowercase__				:			str            =		type_vocab_size
			lowercase__				:			str            =		type_sequence_label_size
			lowercase__				:			Tuple            =		initializer_range
			lowercase__				:			str            =		num_labels
			lowercase__				:			Any            =		num_choices
			lowercase__				:			Optional[int]            =		scope
			lowercase__				:			Optional[Any]            =		projection_dim

	def       snake_case__(	self:	str ):
			lowercase__				:			Tuple            =		ids_tensor([self.batch_size, self.seq_length],				self.vocab_size )

			lowercase__				:			Tuple            =		None
			if self.use_input_mask:
					lowercase__				:			List[str]            =		random_attention_mask([self.batch_size, self.seq_length] )

			lowercase__				:			Optional[Any]            =		None
			if self.use_token_type_ids:
					lowercase__				:			List[Any]            =		ids_tensor([self.batch_size, self.seq_length],				self.type_vocab_size )

			lowercase__				:			Any            =		None
			lowercase__				:			Union[str, Any]            =		None
			lowercase__				:			Any            =		None
			if self.use_labels:
					lowercase__				:			Optional[int]            =		ids_tensor([self.batch_size],				self.type_sequence_label_size )
					lowercase__				:			Optional[Any]            =		ids_tensor([self.batch_size, self.seq_length],				self.num_labels )
					lowercase__				:			Tuple            =		ids_tensor([self.batch_size],				self.num_choices )

			lowercase__				:			Optional[Any]            =		self.get_config()

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

	def       snake_case__(	self:	List[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       snake_case__(	self:	Optional[Any],				lowerCamelCase_:	Tuple,				lowerCamelCase_:	Optional[Any],				lowerCamelCase_:	Optional[int],				lowerCamelCase_:	Tuple,				lowerCamelCase_:	Any,				lowerCamelCase_:	Optional[int],				lowerCamelCase_:	List[str] ):
			lowercase__				:			List[str]            =		DPRContextEncoder(config=lowerCamelCase_ )
			model.to(lowerCamelCase_ )
			model.eval()
			lowercase__				:			str            =		model(lowerCamelCase_,				attention_mask=lowerCamelCase_,				token_type_ids=lowerCamelCase_ )
			lowercase__				:			Optional[Any]            =		model(lowerCamelCase_,				token_type_ids=lowerCamelCase_ )
			lowercase__				:			Optional[int]            =		model(lowerCamelCase_ )
			self.parent.assertEqual(result.pooler_output.shape,				(self.batch_size, self.projection_dim or self.hidden_size) )

	def       snake_case__(	self:	Dict,				lowerCamelCase_:	Optional[int],				lowerCamelCase_:	Optional[Any],				lowerCamelCase_:	Optional[int],				lowerCamelCase_:	List[Any],				lowerCamelCase_:	str,				lowerCamelCase_:	Optional[Any],				lowerCamelCase_:	Union[str, Any] ):
			lowercase__				:			Tuple            =		DPRQuestionEncoder(config=lowerCamelCase_ )
			model.to(lowerCamelCase_ )
			model.eval()
			lowercase__				:			List[Any]            =		model(lowerCamelCase_,				attention_mask=lowerCamelCase_,				token_type_ids=lowerCamelCase_ )
			lowercase__				:			Union[str, Any]            =		model(lowerCamelCase_,				token_type_ids=lowerCamelCase_ )
			lowercase__				:			Tuple            =		model(lowerCamelCase_ )
			self.parent.assertEqual(result.pooler_output.shape,				(self.batch_size, self.projection_dim or self.hidden_size) )

	def       snake_case__(	self:	Union[str, Any],				lowerCamelCase_:	Union[str, Any],				lowerCamelCase_:	Tuple,				lowerCamelCase_:	Optional[int],				lowerCamelCase_:	List[Any],				lowerCamelCase_:	Union[str, Any],				lowerCamelCase_:	str,				lowerCamelCase_:	int ):
			lowercase__				:			int            =		DPRReader(config=lowerCamelCase_ )
			model.to(lowerCamelCase_ )
			model.eval()
			lowercase__				:			Dict            =		model(
			    lowerCamelCase_,				attention_mask=lowerCamelCase_,				)

			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       snake_case__(	self:	Union[str, Any] ):
			lowercase__				:			Any            =		self.prepare_config_and_inputs()
			(
			    (
			    lowercase__
			)      ,							(
			    lowercase__
			)      ,							(
			    lowercase__
			)      ,							(
			    lowercase__
			)      ,							(
			    lowercase__
			)      ,							(
			    lowercase__
			)      ,							(
			    lowercase__
			)      ,							
			)				:			Optional[int]            =		config_and_inputs
			lowercase__				:			int            =		{'input_ids': input_ids}
			return config, inputs_dict


@require_torch
class 			__lowerCAmelCase				(					_UpperCamelCase      ,						_UpperCamelCase      ,						unittest.TestCase			):


	'''simple docstring'''





	_A       	=							(
	    (
	        DPRContextEncoder,
	        DPRQuestionEncoder,
	        DPRReader,
	    )
	    if is_torch_available()
	    else ()
	)
	_A       	=							{"feature-extraction": DPRQuestionEncoder} if is_torch_available() else {}

	_A       	=							False
	_A       	=							False  # why?
	_A       	=							False
	_A       	=							False

	def       snake_case__(	self:	Optional[Any] ):
			lowercase__				:			Union[str, Any]            =		DPRModelTester(self )
			lowercase__				:			Tuple            =		ConfigTester(self,				config_class=lowerCamelCase_,				hidden_size=37 )

	def       snake_case__(	self:	Optional[Any] ):
			self.config_tester.run_common_tests()

	def       snake_case__(	self:	Tuple ):
			lowercase__				:			Dict            =		self.model_tester.prepare_config_and_inputs()
			self.model_tester.create_and_check_context_encoder(*lowerCamelCase_ )

	def       snake_case__(	self:	List[str] ):
			lowercase__				:			List[str]            =		self.model_tester.prepare_config_and_inputs()
			self.model_tester.create_and_check_question_encoder(*lowerCamelCase_ )

	def       snake_case__(	self:	int ):
			lowercase__				:			Union[str, Any]            =		self.model_tester.prepare_config_and_inputs()
			self.model_tester.create_and_check_reader(*lowerCamelCase_ )

	def       snake_case__(	self:	Any ):
			lowercase__				:			str            =		self.model_tester.prepare_config_and_inputs()[0]

			lowercase__				:			int            =		DPRQuestionEncoder(config=lowerCamelCase_ )
			model.to(lowerCamelCase_ )
			model.eval()

			with tempfile.TemporaryDirectory() as tmp_dirname:
					model.save_pretrained(lowerCamelCase_ )
					lowercase__				:			Tuple            =		DPRQuestionEncoder.from_pretrained(lowerCamelCase_,				projection_dim=512 )

			self.assertIsNotNone(lowerCamelCase_ )





	@slow
	def       snake_case__(	self:	Optional[Any] ):
			for model_name in DPR_CONTEXT_ENCODER_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
					lowercase__				:			List[Any]            =		DPRContextEncoder.from_pretrained(lowerCamelCase_ )
					self.assertIsNotNone(lowerCamelCase_ )

			for model_name in DPR_CONTEXT_ENCODER_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
					lowercase__				:			int            =		DPRContextEncoder.from_pretrained(lowerCamelCase_ )
					self.assertIsNotNone(lowerCamelCase_ )

			for model_name in DPR_QUESTION_ENCODER_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
					lowercase__				:			Tuple            =		DPRQuestionEncoder.from_pretrained(lowerCamelCase_ )
					self.assertIsNotNone(lowerCamelCase_ )

			for model_name in DPR_READER_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
					lowercase__				:			Optional[int]            =		DPRReader.from_pretrained(lowerCamelCase_ )
					self.assertIsNotNone(lowerCamelCase_ )


@require_torch
class 			__lowerCAmelCase				(					unittest.TestCase			):


	'''simple docstring'''





	@slow
	def       snake_case__(	self:	Tuple ):
			lowercase__				:			Optional[Any]            =		DPRQuestionEncoder.from_pretrained('facebook/dpr-question_encoder-single-nq-base',				return_dict=lowerCamelCase_ )
			model.to(lowerCamelCase_ )

			lowercase__				:			Tuple            =		torch.tensor(
			    [[101, 7592, 1010, 2003, 2026, 3899, 10140, 1029, 102]],				dtype=torch.long,				device=lowerCamelCase_ )  # [CLS] hello, is my dog cute? [SEP]
			lowercase__				:			List[Any]            =		model(lowerCamelCase_ )[0]  # embedding shape = (1, 768)
			# compare the actual values for a slice.
			lowercase__				:			str            =		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=lowerCamelCase_,				)
			self.assertTrue(torch.allclose(output[:, :10],				lowerCamelCase_,				atol=1E-4 ) )





	@slow
	def       snake_case__(	self:	Dict ):
			lowercase__				:			Optional[int]            =		DPRReaderTokenizer.from_pretrained('facebook/dpr-reader-single-nq-base' )
			lowercase__				:			str            =		DPRReader.from_pretrained('facebook/dpr-reader-single-nq-base' )
			model.to(lowerCamelCase_ )

			lowercase__				:			List[str]            =		tokenizer(
			    questions='What is love ?',				titles='Haddaway',				texts='What Is Love is a song recorded by the artist Haddaway',				padding=lowerCamelCase_,				return_tensors='pt',				)
			encoded_inputs.to(lowerCamelCase_ )

			lowercase__				:			Tuple            =		model(**lowerCamelCase_ )

			# compare the actual values for a slice.
			lowercase__				:			Optional[int]            =		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=lowerCamelCase_,				)

			lowercase__				:			Optional[Any]            =		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=lowerCamelCase_,				)
			self.assertTrue(torch.allclose(outputs.start_logits[:, :10],				lowerCamelCase_,				atol=1E-4 ) )
			self.assertTrue(torch.allclose(outputs.end_logits[:, :10],				lowerCamelCase_,				atol=1E-4 ) )









def 			SCREAMING_SNAKE_CASE__     (					_lowercase    :   int )      ->       bool:




		'''simple docstring'''
		lowercase__				:			Optional[int]            =		9

		while num > 0:
				if num % 10 != digit:
						return False
				num //= 100
				digit -= 1

		return True


def 			SCREAMING_SNAKE_CASE__     (					)      ->       int:




		'''simple docstring'''
		lowercase__				:			List[str]            =		138_902_663

		while not is_square_form(num * num ):
				if num % 10 == 3:
						num -= 6  # (3 - 6) % 10 = 7
				else:
						num -= 4  # (7 - 4) % 10 = 3

		return num * 10


if __name__ == "__main__":
			print(F'{solution() = }')


