




'''simple docstring'''






from __future__ import annotations

import unittest

from transformers import is_tf_available
from transformers.testing_utils import require_tf, slow

from ...test_configuration_common import ConfigTester
from ...test_modeling_tf_common import TFModelTesterMixin, ids_tensor, random_attention_mask
from ...test_pipeline_mixin import PipelineTesterMixin


if is_tf_available():
		import numpy
		import tensorflow as tf

		from transformers import (
		    TF_DPR_CONTEXT_ENCODER_PRETRAINED_MODEL_ARCHIVE_LIST,
		    TF_DPR_QUESTION_ENCODER_PRETRAINED_MODEL_ARCHIVE_LIST,
		    TF_DPR_READER_PRETRAINED_MODEL_ARCHIVE_LIST,
		    BertConfig,
		    DPRConfig,
		    TFDPRContextEncoder,
		    TFDPRQuestionEncoder,
		    TFDPRReader,
		)




class 		a__    :





							'''simple docstring'''






							def __init__(		self ,   lowerCamelCase_ ,   lowerCamelCase_=13 ,   lowerCamelCase_=7 ,   lowerCamelCase_=True ,   lowerCamelCase_=True ,   lowerCamelCase_=True ,   lowerCamelCase_=True ,   lowerCamelCase_=99 ,   lowerCamelCase_=32 ,   lowerCamelCase_=2 ,   lowerCamelCase_=4 ,   lowerCamelCase_=37 ,   lowerCamelCase_="gelu" ,   lowerCamelCase_=0.1 ,   lowerCamelCase_=0.1 ,   lowerCamelCase_=5_12 ,   lowerCamelCase_=16 ,   lowerCamelCase_=2 ,   lowerCamelCase_=0.02 ,   lowerCamelCase_=3 ,   lowerCamelCase_=4 ,   lowerCamelCase_=None ,   lowerCamelCase_=0 ,   )	->							List[str]:
														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   __SCREAMING_SNAKE_CASE							(		self       )	->							int:
														lowerCAmelCase__	       =     ids_tensor([self.batch_size, self.seq_length] ,   self.vocab_size       )

														lowerCAmelCase__	       =     None
														if self.use_input_mask:
																					# follow test_modeling_tf_ctrl.py
																					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__	       =     BertConfig(
														    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 ,   is_decoder=lowerCamelCase_ ,   initializer_range=self.initializer_range ,   )
														lowerCAmelCase__	       =     DPRConfig(projection_dim=self.projection_dim ,   **config.to_dict()       )

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







							def   __SCREAMING_SNAKE_CASE							(		self ,   lowerCamelCase_ ,   lowerCamelCase_ ,   lowerCamelCase_ ,   lowerCamelCase_ ,   lowerCamelCase_ ,   lowerCamelCase_ ,   lowerCamelCase_       )	->							str:
														lowerCAmelCase__	       =     TFDPRContextEncoder(config=lowerCamelCase_       )
														lowerCAmelCase__	       =     model(lowerCamelCase_ ,   attention_mask=lowerCamelCase_ ,   token_type_ids=lowerCamelCase_       )
														lowerCAmelCase__	       =     model(lowerCamelCase_ ,   token_type_ids=lowerCamelCase_       )
														lowerCAmelCase__	       =     model(lowerCamelCase_       )
														self.parent.assertEqual(result.pooler_output.shape ,   (self.batch_size, self.projection_dim or self.hidden_size)       )







							def   __SCREAMING_SNAKE_CASE							(		self ,   lowerCamelCase_ ,   lowerCamelCase_ ,   lowerCamelCase_ ,   lowerCamelCase_ ,   lowerCamelCase_ ,   lowerCamelCase_ ,   lowerCamelCase_       )	->							int:
														lowerCAmelCase__	       =     TFDPRQuestionEncoder(config=lowerCamelCase_       )
														lowerCAmelCase__	       =     model(lowerCamelCase_ ,   attention_mask=lowerCamelCase_ ,   token_type_ids=lowerCamelCase_       )
														lowerCAmelCase__	       =     model(lowerCamelCase_ ,   token_type_ids=lowerCamelCase_       )
														lowerCAmelCase__	       =     model(lowerCamelCase_       )
														self.parent.assertEqual(result.pooler_output.shape ,   (self.batch_size, self.projection_dim or self.hidden_size)       )







							def   __SCREAMING_SNAKE_CASE							(		self ,   lowerCamelCase_ ,   lowerCamelCase_ ,   lowerCamelCase_ ,   lowerCamelCase_ ,   lowerCamelCase_ ,   lowerCamelCase_ ,   lowerCamelCase_       )	->							str:
														lowerCAmelCase__	       =     TFDPRReader(config=lowerCamelCase_       )
														lowerCAmelCase__	       =     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   __SCREAMING_SNAKE_CASE							(		self       )	->							str:
														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_tf
class 		a__    (							a__    ,    a__    ,    unittest.TestCase  ):





							'''simple docstring'''






							lowercase__      :       Tuple     						=				(
							    (
							        TFDPRContextEncoder,
							        TFDPRQuestionEncoder,
							        TFDPRReader,
							    )
							    if is_tf_available()
							    else ()
							)
							lowercase__      :       str     						=				{"feature-extraction": TFDPRQuestionEncoder} if is_tf_available() else {}

							lowercase__      :       Optional[int]     						=				False
							lowercase__      :       str     						=				False
							lowercase__      :       Any     						=				False
							lowercase__      :       str     						=				False
							lowercase__      :       str     						=				False







							def   __SCREAMING_SNAKE_CASE							(		self       )	->							int:
														lowerCAmelCase__	       =     TFDPRModelTester(self       )
														lowerCAmelCase__	       =     ConfigTester(self ,   config_class=lowerCamelCase_ ,   hidden_size=37       )







							def   __SCREAMING_SNAKE_CASE							(		self       )	->							Tuple:
														self.config_tester.run_common_tests()







							def   __SCREAMING_SNAKE_CASE							(		self       )	->							Dict:
														lowerCAmelCase__	       =     self.model_tester.prepare_config_and_inputs()
														self.model_tester.create_and_check_dpr_context_encoder(*lowerCamelCase_       )







							def   __SCREAMING_SNAKE_CASE							(		self       )	->							List[str]:
														lowerCAmelCase__	       =     self.model_tester.prepare_config_and_inputs()
														self.model_tester.create_and_check_dpr_question_encoder(*lowerCamelCase_       )







							def   __SCREAMING_SNAKE_CASE							(		self       )	->							int:
														lowerCAmelCase__	       =     self.model_tester.prepare_config_and_inputs()
														self.model_tester.create_and_check_dpr_reader(*lowerCamelCase_       )







							@slow
							def   __SCREAMING_SNAKE_CASE							(		self       )	->							int:
														for model_name in TF_DPR_CONTEXT_ENCODER_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
																					lowerCAmelCase__	       =     TFDPRContextEncoder.from_pretrained(lowerCamelCase_       )
																					self.assertIsNotNone(lowerCamelCase_       )

														for model_name in TF_DPR_CONTEXT_ENCODER_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
																					lowerCAmelCase__	       =     TFDPRContextEncoder.from_pretrained(lowerCamelCase_       )
																					self.assertIsNotNone(lowerCamelCase_       )

														for model_name in TF_DPR_QUESTION_ENCODER_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
																					lowerCAmelCase__	       =     TFDPRQuestionEncoder.from_pretrained(lowerCamelCase_       )
																					self.assertIsNotNone(lowerCamelCase_       )

														for model_name in TF_DPR_READER_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
																					lowerCAmelCase__	       =     TFDPRReader.from_pretrained(lowerCamelCase_       )
																					self.assertIsNotNone(lowerCamelCase_       )




@require_tf
class 		a__    (							unittest.TestCase  ):





							'''simple docstring'''






							@slow
							def   __SCREAMING_SNAKE_CASE							(		self       )	->							Optional[Any]:
														lowerCAmelCase__	       =     TFDPRQuestionEncoder.from_pretrained('''facebook/dpr-question_encoder-single-nq-base'''       )

														lowerCAmelCase__	       =     tf.constant(
														    [[1_01, 75_92, 10_10, 20_03, 20_26, 38_99, 1_01_40, 10_29, 1_02]]       )  # [CLS] hello, is my dog cute? [SEP]
														lowerCAmelCase__	       =     model(lowerCamelCase_       )[0]  # embedding shape = (1, 768)
														# compare the actual values for a slice.
														lowerCAmelCase__	       =     tf.constant(
														    [
														        [
														            0.03_236_253,
														            0.12_753_335,
														            0.16_818_509,
														            0.00_279_786,
														            0.3_896_933,
														            0.24_264_945,
														            0.2_178_971,
														            -0.02_335_227,
														            -0.08_481_959,
														            -0.14_324_117,
														        ]
														    ]       )
														self.assertTrue(numpy.allclose(output[:, :10].numpy() ,   expected_slice.numpy() ,   atol=1e-4       )       )



'''simple docstring'''






def  _snake_case       (					A = 10	)						->   str:
							if not isinstance(A			,   A	) or n < 0:
														raise ValueError('''Invalid input'''	)
							lowerCAmelCase__	       =     10**n
							lowerCAmelCase__	       =     28433 * (pow(2			,   7830457			,   A	)) + 1
							return str(number % modulus	)


if __name__ == "__main__":
		from doctest import testmod

		testmod()
		print(f"""{solution(10) = }""")