



import shutil
import tempfile
import unittest

from transformers import SPIECE_UNDERLINE, BatchEncoding, MBartaaTokenizer, MBartaaTokenizerFast, is_torch_available
from transformers.testing_utils import (
    get_tests_dir,
    nested_simplify,
    require_sentencepiece,
    require_tokenizers,
    require_torch,
    slow,
)

from ...test_tokenization_common import TokenizerTesterMixin


a_						:     str	     =		get_tests_dir('fixtures/test_sentencepiece.model')

if is_torch_available():
     from transformers.models.mbart.modeling_mbart import shift_tokens_right

a_						:     Union[str, Any]	     =		2_5_0_0_0_4
a_						:     str	     =		2_5_0_0_2_0





@require_sentencepiece
@require_tokenizers
class    lowerCamelCase__  (						UpperCAmelCase_       ,    unittest.TestCase):
     """simple docstring"""



     _A       =			MBartaaTokenizer
     _A       =			MBartaaTokenizerFast
     _A       =			True
     _A       =			True







     def 						_a      (self    ):






           '''simple docstring'''



           super().setUp()

           # We have a SentencePiece fixture for testing
           lowerCamelCase     :   str								=		MBartaaTokenizer(__UpperCamelCase				,			src_lang="en_XX"				,			tgt_lang="ro_RO"				,			keep_accents=__UpperCamelCase    )
           tokenizer.save_pretrained(self.tmpdirname    )







     def 						_a      (self    ):






           '''simple docstring'''



           lowerCamelCase     :   Tuple								=		"<s>"
           lowerCamelCase     :   Optional[Any]								=		0

           self.assertEqual(self.get_tokenizer()._convert_token_to_id(__UpperCamelCase    )				,			__UpperCamelCase    )
           self.assertEqual(self.get_tokenizer()._convert_id_to_token(__UpperCamelCase    )				,			__UpperCamelCase    )







     def 						_a      (self    ):






           '''simple docstring'''



           lowerCamelCase     :   int								=		list(self.get_tokenizer().get_vocab().keys()    )

           self.assertEqual(vocab_keys[0]				,			"<s>"    )
           self.assertEqual(vocab_keys[1]				,			"<pad>"    )
           self.assertEqual(vocab_keys[-1]				,			"<mask>"    )
           self.assertEqual(len(__UpperCamelCase    )				,			10_54    )







     def 						_a      (self    ):






           '''simple docstring'''



           self.assertEqual(self.get_tokenizer().vocab_size				,			10_54    )







     def 						_a      (self    ):






           '''simple docstring'''



           lowerCamelCase     :   Optional[int]								=		MBartaaTokenizer(__UpperCamelCase				,			src_lang="en_XX"				,			tgt_lang="ro_RO"				,			keep_accents=__UpperCamelCase    )

           lowerCamelCase     :   List[str]								=		tokenizer.tokenize("This is a test"    )
           self.assertListEqual(__UpperCamelCase				,			["▁This", "▁is", "▁a", "▁t", "est"]    )

           self.assertListEqual(
               tokenizer.convert_tokens_to_ids(__UpperCamelCase    )				,			[value + tokenizer.fairseq_offset for value in [2_85, 46, 10, 1_70, 3_82]]				,			)

           lowerCamelCase     :   Union[str, Any]								=		tokenizer.tokenize("I was born in 92000, and this is falsé."    )
           self.assertListEqual(
               __UpperCamelCase				,			[SPIECE_UNDERLINE + "I", SPIECE_UNDERLINE + "was", SPIECE_UNDERLINE + "b", "or", "n", SPIECE_UNDERLINE + "in", SPIECE_UNDERLINE + "", "9", "2", "0", "0", "0", ",", SPIECE_UNDERLINE + "and", SPIECE_UNDERLINE + "this", SPIECE_UNDERLINE + "is", SPIECE_UNDERLINE + "f", "al", "s", "é", "."]				,			)
           lowerCamelCase     :   Tuple								=		tokenizer.convert_tokens_to_ids(__UpperCamelCase    )
           self.assertListEqual(
               __UpperCamelCase				,			[
                   value + tokenizer.fairseq_offset
                   for value in [8, 21, 84, 55, 24, 19, 7, 2, 6_02, 3_47, 3_47, 3_47, 3, 12, 66, 46, 72, 80, 6, 2, 4]
               ]				,			)

           lowerCamelCase     :   Tuple								=		tokenizer.convert_ids_to_tokens(__UpperCamelCase    )
           self.assertListEqual(
               __UpperCamelCase				,			[SPIECE_UNDERLINE + "I", SPIECE_UNDERLINE + "was", SPIECE_UNDERLINE + "b", "or", "n", SPIECE_UNDERLINE + "in", SPIECE_UNDERLINE + "", "<unk>", "2", "0", "0", "0", ",", SPIECE_UNDERLINE + "and", SPIECE_UNDERLINE + "this", SPIECE_UNDERLINE + "is", SPIECE_UNDERLINE + "f", "al", "s", "<unk>", "."]				,			)







     @slow
     def 						_a      (self    ):






           '''simple docstring'''



           lowerCamelCase     :   Dict								=		{"input_ids": [[25_00_04, 1_10_62, 8_27_72, 7, 15, 8_27_72, 5_38, 5_15_29, 2_37, 1_71_98, 12_90, 2_06, 9, 21_51_75, 13_14, 1_36, 1_71_98, 12_90, 2_06, 9, 5_63_59, 42, 12_20_09, 9, 1_64_66, 16, 8_73_44, 45_37, 9, 47_17, 7_83_81, 6, 15_99_58, 7, 15, 2_44_80, 6_18, 4, 5_27, 2_26_93, 54_28, 4, 27_77, 2_44_80, 98_74, 4, 4_35_23, 5_94, 4, 8_03, 1_83_92, 3_31_89, 18, 4, 4_35_23, 2_44_47, 1_23_99, 1_00, 2_49_55, 8_36_58, 96_26, 14_40_57, 15, 8_39, 2_23_35, 16, 1_36, 2_49_55, 8_36_58, 8_34_79, 15, 3_91_02, 7_24, 16, 6_78, 6_45, 27_89, 13_28, 45_89, 42, 12_20_09, 11_57_74, 23, 8_05, 13_28, 4_68_76, 7, 1_36, 5_38_94, 19_40, 4_22_27, 4_11_59, 1_77_21, 8_23, 4_25, 4, 2_75_12, 9_87_22, 2_06, 1_36, 55_31, 49_70, 9_19, 1_73_36, 5, 2], [25_00_04, 2_00_80, 6_18, 83, 8_27_75, 47, 4_79, 9, 15_17, 73, 5_38_94, 3_33, 8_05_81, 11_01_17, 1_88_11, 52_56, 12_95, 51, 15_25_26, 2_97, 79_86, 3_90, 12_44_16, 5_38, 3_54_31, 2_14, 98, 1_50_44, 2_57_37, 1_36, 71_08, 4_37_01, 23, 7_56, 13_53_55, 7, 5, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], [25_00_04, 5_81, 6_37_73, 11_94_55, 6, 14_77_97, 8_82_03, 7, 6_45, 70, 21, 32_85, 1_02_69, 5, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]], "attention_mask": [[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]]}  # noqa: E501
           # fmt: on

           self.tokenizer_integration_test_util(
               expected_encoding=__UpperCamelCase				,			model_name="facebook/mbart-large-50"				,			revision="d3913889c59cd5c9e456b269c376325eabad57e2"				,			)







     def 						_a      (self    ):






           '''simple docstring'''



           if not self.test_slow_tokenizer:
                 # as we don't have a slow version, we can't compare the outputs between slow and fast versions
                 return

           lowerCamelCase     :   Optional[int]								=		(self.rust_tokenizer_class, "hf-internal-testing/tiny-random-mbart50", {})
           for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
                 with self.subTest(F"""{tokenizer.__class__.__name__} ({pretrained_name})"""    ):
                       lowerCamelCase     :   int								=		self.rust_tokenizer_class.from_pretrained(__UpperCamelCase				,			**__UpperCamelCase    )
                       lowerCamelCase     :   str								=		self.tokenizer_class.from_pretrained(__UpperCamelCase				,			**__UpperCamelCase    )

                       lowerCamelCase     :   Optional[int]								=		tempfile.mkdtemp()

                       lowerCamelCase     :   Optional[Any]								=		tokenizer_r.save_pretrained(__UpperCamelCase    )
                       lowerCamelCase     :   int								=		tokenizer_p.save_pretrained(__UpperCamelCase    )

                       # Checks it save with the same files + the tokenizer.json file for the fast one
                       self.assertTrue(any("tokenizer.json" in f for f in tokenizer_r_files    )    )
                       lowerCamelCase     :   List[str]								=		tuple(f for f in tokenizer_r_files if "tokenizer.json" not in f    )
                       self.assertSequenceEqual(__UpperCamelCase				,			__UpperCamelCase    )

                       # Checks everything loads correctly in the same way
                       lowerCamelCase     :   Any								=		tokenizer_r.from_pretrained(__UpperCamelCase    )
                       lowerCamelCase     :   Union[str, Any]								=		tokenizer_p.from_pretrained(__UpperCamelCase    )

                       # Check special tokens are set accordingly on Rust and Python
                       for key in tokenizer_pp.special_tokens_map:
                             self.assertTrue(hasattr(__UpperCamelCase				,			__UpperCamelCase    )    )
                             # self.assertEqual(getattr(tokenizer_rp, key), getattr(tokenizer_pp, key))
                             # self.assertEqual(getattr(tokenizer_rp, key + "_id"), getattr(tokenizer_pp, key + "_id"))

                       shutil.rmtree(__UpperCamelCase    )

                       # Save tokenizer rust, legacy_format=True
                       lowerCamelCase     :   str								=		tempfile.mkdtemp()

                       lowerCamelCase     :   Optional[int]								=		tokenizer_r.save_pretrained(__UpperCamelCase				,			legacy_format=__UpperCamelCase    )
                       lowerCamelCase     :   str								=		tokenizer_p.save_pretrained(__UpperCamelCase    )

                       # Checks it save with the same files
                       self.assertSequenceEqual(__UpperCamelCase				,			__UpperCamelCase    )

                       # Checks everything loads correctly in the same way
                       lowerCamelCase     :   List[Any]								=		tokenizer_r.from_pretrained(__UpperCamelCase    )
                       lowerCamelCase     :   str								=		tokenizer_p.from_pretrained(__UpperCamelCase    )

                       # Check special tokens are set accordingly on Rust and Python
                       for key in tokenizer_pp.special_tokens_map:
                             self.assertTrue(hasattr(__UpperCamelCase				,			__UpperCamelCase    )    )

                       shutil.rmtree(__UpperCamelCase    )

                       # Save tokenizer rust, legacy_format=False
                       lowerCamelCase     :   Any								=		tempfile.mkdtemp()

                       lowerCamelCase     :   Optional[int]								=		tokenizer_r.save_pretrained(__UpperCamelCase				,			legacy_format=__UpperCamelCase    )
                       lowerCamelCase     :   Union[str, Any]								=		tokenizer_p.save_pretrained(__UpperCamelCase    )

                       # Checks it saved the tokenizer.json file
                       self.assertTrue(any("tokenizer.json" in f for f in tokenizer_r_files    )    )

                       # Checks everything loads correctly in the same way
                       lowerCamelCase     :   Optional[Any]								=		tokenizer_r.from_pretrained(__UpperCamelCase    )
                       lowerCamelCase     :   List[str]								=		tokenizer_p.from_pretrained(__UpperCamelCase    )

                       # Check special tokens are set accordingly on Rust and Python
                       for key in tokenizer_pp.special_tokens_map:
                             self.assertTrue(hasattr(__UpperCamelCase				,			__UpperCamelCase    )    )

                       shutil.rmtree(__UpperCamelCase    )





@require_torch
@require_sentencepiece
@require_tokenizers
class    lowerCamelCase__  (						unittest.TestCase):
     """simple docstring"""



     _A       =			'facebook/mbart-large-50-one-to-many-mmt'
     _A       =			[
         ' UN Chief Says There Is No Military Solution in Syria',
         ' Secretary-General Ban Ki-moon says his response to Russia\'s stepped up military support for Syria is that "there is no military solution" to the nearly five-year conflict and more weapons will only worsen the violence and misery for millions of people.',
     ]
     _A       =			[
         'Şeful ONU declară că nu există o soluţie militară în Siria',
         'Secretarul General Ban Ki-moon declară că răspunsul său la intensificarea sprijinului militar al Rusiei'
         ' pentru Siria este că "nu există o soluţie militară" la conflictul de aproape cinci ani şi că noi arme nu vor'
         ' face decât să înrăutăţească violenţele şi mizeria pentru milioane de oameni.',
     ]
     _A       =			[EN_CODE, 82_74, 12_78_73, 2_59_16, 7, 86_22, 20_71, 4_38, 6_74_85, 53, 18_78_95, 23, 5_17_12, 2]







     @classmethod
     def 						_a      (cls    ):






           '''simple docstring'''



           lowerCamelCase     :   str								=		MBartaaTokenizer.from_pretrained(
               cls.checkpoint_name				,			src_lang="en_XX"				,			tgt_lang="ro_RO"    )
           lowerCamelCase     :   Any								=		1
           return cls







     def 						_a      (self    ):






           '''simple docstring'''



           self.assertEqual(self.tokenizer.fairseq_tokens_to_ids["ar_AR"]				,			25_00_01    )
           self.assertEqual(self.tokenizer.fairseq_tokens_to_ids["en_EN"]				,			25_00_04    )
           self.assertEqual(self.tokenizer.fairseq_tokens_to_ids["ro_RO"]				,			25_00_20    )
           self.assertEqual(self.tokenizer.fairseq_tokens_to_ids["mr_IN"]				,			25_00_38    )







     def 						_a      (self    ):






           '''simple docstring'''



           lowerCamelCase     :   Dict								=		self.tokenizer.batch_encode_plus(self.src_text    ).input_ids[0]
           self.assertListEqual(self.expected_src_tokens				,			__UpperCamelCase    )







     def 						_a      (self    ):






           '''simple docstring'''



           self.assertIn(__UpperCamelCase				,			self.tokenizer.all_special_ids    )
           lowerCamelCase     :   Any								=		[RO_CODE, 8_84, 90_19, 96, 9, 9_16, 8_67_92, 36, 1_87_43, 1_55_96, 5, 2]
           lowerCamelCase     :   Optional[int]								=		self.tokenizer.decode(__UpperCamelCase				,			skip_special_tokens=__UpperCamelCase    )
           lowerCamelCase     :   Union[str, Any]								=		self.tokenizer.decode(generated_ids[1:]				,			skip_special_tokens=__UpperCamelCase    )
           self.assertEqual(__UpperCamelCase				,			__UpperCamelCase    )
           self.assertNotIn(self.tokenizer.eos_token				,			__UpperCamelCase    )







     def 						_a      (self    ):






           '''simple docstring'''



           lowerCamelCase     :   str								=		["this is gunna be a long sentence " * 20]
           assert isinstance(src_text[0]				,			__UpperCamelCase    )
           lowerCamelCase     :   List[str]								=		10
           lowerCamelCase     :   str								=		self.tokenizer(__UpperCamelCase				,			max_length=__UpperCamelCase				,			truncation=__UpperCamelCase    ).input_ids[0]
           self.assertEqual(ids[0]				,			__UpperCamelCase    )
           self.assertEqual(ids[-1]				,			2    )
           self.assertEqual(len(__UpperCamelCase    )				,			__UpperCamelCase    )







     def 						_a      (self    ):






           '''simple docstring'''



           self.assertListEqual(self.tokenizer.convert_tokens_to_ids(["<mask>", "ar_AR"]    )				,			[25_00_53, 25_00_01]    )







     def 						_a      (self    ):






           '''simple docstring'''



           lowerCamelCase     :   Any								=		tempfile.mkdtemp()
           lowerCamelCase     :   Dict								=		self.tokenizer.fairseq_tokens_to_ids
           self.tokenizer.save_pretrained(__UpperCamelCase    )
           lowerCamelCase     :   List[str]								=		MBartaaTokenizer.from_pretrained(__UpperCamelCase    )
           self.assertDictEqual(new_tok.fairseq_tokens_to_ids				,			__UpperCamelCase    )







     @require_torch
     def 						_a      (self    ):






           '''simple docstring'''



           lowerCamelCase     :   Dict								=		self.tokenizer(self.src_text				,			text_target=self.tgt_text				,			padding=__UpperCamelCase				,			return_tensors="pt"    )
           lowerCamelCase     :   Any								=		shift_tokens_right(batch["labels"]				,			self.tokenizer.pad_token_id    )

           # fairseq batch: https://gist.github.com/sshleifer/cba08bc2109361a74ac3760a7e30e4f4
           assert batch.input_ids[1][0] == EN_CODE
           assert batch.input_ids[1][-1] == 2
           assert batch.labels[1][0] == RO_CODE
           assert batch.labels[1][-1] == 2
           assert batch.decoder_input_ids[1][:2].tolist() == [2, RO_CODE]







     @require_torch
     def 						_a      (self    ):






           '''simple docstring'''



           lowerCamelCase     :   str								=		self.tokenizer(
               self.src_text				,			text_target=self.tgt_text				,			padding=__UpperCamelCase				,			truncation=__UpperCamelCase				,			max_length=len(self.expected_src_tokens    )				,			return_tensors="pt"				,			)
           lowerCamelCase     :   Any								=		shift_tokens_right(batch["labels"]				,			self.tokenizer.pad_token_id    )

           self.assertIsInstance(__UpperCamelCase				,			__UpperCamelCase    )

           self.assertEqual((2, 14)				,			batch.input_ids.shape    )
           self.assertEqual((2, 14)				,			batch.attention_mask.shape    )
           lowerCamelCase     :   str								=		batch.input_ids.tolist()[0]
           self.assertListEqual(self.expected_src_tokens				,			__UpperCamelCase    )
           self.assertEqual(2				,			batch.decoder_input_ids[0, 0]    )  # decoder_start_token_id
           # Test that special tokens are reset
           self.assertEqual(self.tokenizer.prefix_tokens				,			[EN_CODE]    )
           self.assertEqual(self.tokenizer.suffix_tokens				,			[self.tokenizer.eos_token_id]    )







     def 						_a      (self    ):






           '''simple docstring'''



           lowerCamelCase     :   Optional[Any]								=		self.tokenizer(self.src_text				,			padding=__UpperCamelCase				,			truncation=__UpperCamelCase				,			max_length=3				,			return_tensors="pt"    )
           lowerCamelCase     :   Union[str, Any]								=		self.tokenizer(
               text_target=self.tgt_text				,			padding=__UpperCamelCase				,			truncation=__UpperCamelCase				,			max_length=10				,			return_tensors="pt"    )
           lowerCamelCase     :   int								=		targets["input_ids"]
           lowerCamelCase     :   Any								=		shift_tokens_right(__UpperCamelCase				,			self.tokenizer.pad_token_id    )

           self.assertEqual(batch.input_ids.shape[1]				,			3    )
           self.assertEqual(batch.decoder_input_ids.shape[1]				,			10    )







     @require_torch
     def 						_a      (self    ):






           '''simple docstring'''



           lowerCamelCase     :   List[str]								=		self.tokenizer._build_translation_inputs(
               "A test"				,			return_tensors="pt"				,			src_lang="en_XX"				,			tgt_lang="ar_AR"    )

           self.assertEqual(
               nested_simplify(__UpperCamelCase    )				,			{
                   # en_XX, A, test, EOS
                   "input_ids": [[25_00_04, 62, 30_34, 2]],
                   "attention_mask": [[1, 1, 1, 1]],
                   # ar_AR
                   "forced_bos_token_id": 25_00_01,
               }				,			)




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    lowerCamelCase__  :
     """simple docstring"""



     def __init__(self				,			__a				,			__a=13				,			__a=7				,			__a=True				,			__a=True				,			__a=True				,			__a=True				,			__a=99				,			__a=32				,			__a=2				,			__a=4				,			__a=37				,			__a="gelu"				,			__a=0.1				,			__a=0.1				,			__a=5_12				,			__a=16				,			__a=2				,			__a=0.02				,			__a=3				,			__a=4				,			__a=None				,			__a=0				,			):






           '''simple docstring'''



           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 						_a      (self    ):






           '''simple docstring'''



           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=__a				,			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 						_a      (self				,			__a				,			__a				,			__a				,			__a				,			__a				,			__a				,			__a    ):






           '''simple docstring'''



           lowerCamelCase								=		TFDPRContextEncoder(config=__a    )
           lowerCamelCase								=		model(__a				,			attention_mask=__a				,			token_type_ids=__a    )
           lowerCamelCase								=		model(__a				,			token_type_ids=__a    )
           lowerCamelCase								=		model(__a    )
           self.parent.assertEqual(result.pooler_output.shape				,			(self.batch_size, self.projection_dim or self.hidden_size)    )







     def 						_a      (self				,			__a				,			__a				,			__a				,			__a				,			__a				,			__a				,			__a    ):






           '''simple docstring'''



           lowerCamelCase								=		TFDPRQuestionEncoder(config=__a    )
           lowerCamelCase								=		model(__a				,			attention_mask=__a				,			token_type_ids=__a    )
           lowerCamelCase								=		model(__a				,			token_type_ids=__a    )
           lowerCamelCase								=		model(__a    )
           self.parent.assertEqual(result.pooler_output.shape				,			(self.batch_size, self.projection_dim or self.hidden_size)    )







     def 						_a      (self				,			__a				,			__a				,			__a				,			__a				,			__a				,			__a				,			__a    ):






           '''simple docstring'''



           lowerCamelCase								=		TFDPRReader(config=__a    )
           lowerCamelCase								=		model(__a				,			attention_mask=__a    )

           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 						_a      (self    ):






           '''simple docstring'''



           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    lowerCamelCase__  (						UpperCAmelCase_       ,    UpperCAmelCase_       ,    unittest.TestCase):
     """simple docstring"""



     _A       =			(
         (
             TFDPRContextEncoder,
             TFDPRQuestionEncoder,
             TFDPRReader,
         )
         if is_tf_available()
         else ()
     )
     _A       =			{'feature-extraction': TFDPRQuestionEncoder} if is_tf_available() else {}

     _A       =			False
     _A       =			False
     _A       =			False
     _A       =			False
     _A       =			False







     def 						_a      (self    ):






           '''simple docstring'''



           lowerCamelCase								=		TFDPRModelTester(self    )
           lowerCamelCase								=		ConfigTester(self				,			config_class=__a				,			hidden_size=37    )







     def 						_a      (self    ):






           '''simple docstring'''



           self.config_tester.run_common_tests()







     def 						_a      (self    ):






           '''simple docstring'''



           lowerCamelCase								=		self.model_tester.prepare_config_and_inputs()
           self.model_tester.create_and_check_dpr_context_encoder(*__a    )







     def 						_a      (self    ):






           '''simple docstring'''



           lowerCamelCase								=		self.model_tester.prepare_config_and_inputs()
           self.model_tester.create_and_check_dpr_question_encoder(*__a    )







     def 						_a      (self    ):






           '''simple docstring'''



           lowerCamelCase								=		self.model_tester.prepare_config_and_inputs()
           self.model_tester.create_and_check_dpr_reader(*__a    )







     @slow
     def 						_a      (self    ):






           '''simple docstring'''



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

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

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

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





@require_tf
class    lowerCamelCase__  (						unittest.TestCase):
     """simple docstring"""



     @slow
     def 						_a      (self    ):






           '''simple docstring'''



           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(__a    )[0]  # embedding shape = (1, 768)
           # compare the actual values for a slice.
           lowerCamelCase								=		tf.constant(
               [
                   [
                       0.0323_6253,
                       0.1275_3335,
                       0.1681_8509,
                       0.0027_9786,
                       0.389_6933,
                       0.2426_4945,
                       0.217_8971,
                       -0.0233_5227,
                       -0.0848_1959,
                       -0.1432_4117,
                   ]
               ]    )
           self.assertTrue(numpy.allclose(output[:, :10].numpy()				,			expected_slice.numpy()				,			atol=1E-4    )    )