


'''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      ,					) ->							Union[str, 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 						__SCREAMING_SNAKE_CASE							(	self     ) ->							Any:
														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_     ) ->							int:
														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_     ) ->							List[Any]:
														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_     ) ->							List[Any]:
														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     ) ->							Any:
														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__    :     str					=   (
							    (
							        TFDPRContextEncoder,
							        TFDPRQuestionEncoder,
							        TFDPRReader,
							    )
							    if is_tf_available()
							    else ()
							)
							lowercase__    :     Tuple					=   {"feature-extraction": TFDPRQuestionEncoder} if is_tf_available() else {}

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







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







							def 						__SCREAMING_SNAKE_CASE							(	self     ) ->							List[str]:
														self.config_tester.run_common_tests()







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







							def 						__SCREAMING_SNAKE_CASE							(	self     ) ->							Union[str, Any]:
														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     ) ->							str:
														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     ) ->							List[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'''






import json
from typing import List, Optional, Tuple

from tokenizers import pre_tokenizers, processors

from ...tokenization_utils_base import AddedToken, BatchEncoding
from ...tokenization_utils_fast import PreTrainedTokenizerFast
from ...utils import logging
from .tokenization_roberta import RobertaTokenizer


__UpperCAmelCase					       =							logging.get_logger(__name__)

__UpperCAmelCase					       =							{'''vocab_file''': '''vocab.json''', '''merges_file''': '''merges.txt''', '''tokenizer_file''': '''tokenizer.json'''}

__UpperCAmelCase					       =							{
    '''vocab_file''': {
        '''roberta-base''': '''https://huggingface.co/roberta-base/resolve/main/vocab.json''',
        '''roberta-large''': '''https://huggingface.co/roberta-large/resolve/main/vocab.json''',
        '''roberta-large-mnli''': '''https://huggingface.co/roberta-large-mnli/resolve/main/vocab.json''',
        '''distilroberta-base''': '''https://huggingface.co/distilroberta-base/resolve/main/vocab.json''',
        '''roberta-base-openai-detector''': '''https://huggingface.co/roberta-base-openai-detector/resolve/main/vocab.json''',
        '''roberta-large-openai-detector''': (
            '''https://huggingface.co/roberta-large-openai-detector/resolve/main/vocab.json'''
        ),
    },
    '''merges_file''': {
        '''roberta-base''': '''https://huggingface.co/roberta-base/resolve/main/merges.txt''',
        '''roberta-large''': '''https://huggingface.co/roberta-large/resolve/main/merges.txt''',
        '''roberta-large-mnli''': '''https://huggingface.co/roberta-large-mnli/resolve/main/merges.txt''',
        '''distilroberta-base''': '''https://huggingface.co/distilroberta-base/resolve/main/merges.txt''',
        '''roberta-base-openai-detector''': '''https://huggingface.co/roberta-base-openai-detector/resolve/main/merges.txt''',
        '''roberta-large-openai-detector''': (
            '''https://huggingface.co/roberta-large-openai-detector/resolve/main/merges.txt'''
        ),
    },
    '''tokenizer_file''': {
        '''roberta-base''': '''https://huggingface.co/roberta-base/resolve/main/tokenizer.json''',
        '''roberta-large''': '''https://huggingface.co/roberta-large/resolve/main/tokenizer.json''',
        '''roberta-large-mnli''': '''https://huggingface.co/roberta-large-mnli/resolve/main/tokenizer.json''',
        '''distilroberta-base''': '''https://huggingface.co/distilroberta-base/resolve/main/tokenizer.json''',
        '''roberta-base-openai-detector''': (
            '''https://huggingface.co/roberta-base-openai-detector/resolve/main/tokenizer.json'''
        ),
        '''roberta-large-openai-detector''': (
            '''https://huggingface.co/roberta-large-openai-detector/resolve/main/tokenizer.json'''
        ),
    },
}

__UpperCAmelCase					       =							{
    '''roberta-base''': 512,
    '''roberta-large''': 512,
    '''roberta-large-mnli''': 512,
    '''distilroberta-base''': 512,
    '''roberta-base-openai-detector''': 512,
    '''roberta-large-openai-detector''': 512,
}




class 	a__       (							a__						):





							'''simple docstring'''






							lowercase__    :     Optional[Any]					=   VOCAB_FILES_NAMES
							lowercase__    :     int					=   PRETRAINED_VOCAB_FILES_MAP
							lowercase__    :     Any					=   PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
							lowercase__    :     List[Any]					=   ["input_ids", "attention_mask"]
							lowercase__    :     Dict					=   RobertaTokenizer







							def __init__(	self      ,					lowerCamelCase_=None      ,					lowerCamelCase_=None      ,					lowerCamelCase_=None      ,					lowerCamelCase_="replace"      ,					lowerCamelCase_="<s>"      ,					lowerCamelCase_="</s>"      ,					lowerCamelCase_="</s>"      ,					lowerCamelCase_="<s>"      ,					lowerCamelCase_="<unk>"      ,					lowerCamelCase_="<pad>"      ,					lowerCamelCase_="<mask>"      ,					lowerCamelCase_=False      ,					lowerCamelCase_=True      ,					**lowerCamelCase_      ,					) ->							Tuple:
														super().__init__(
														    lowerCamelCase_      ,					lowerCamelCase_      ,					tokenizer_file=lowerCamelCase_      ,					errors=lowerCamelCase_      ,					bos_token=lowerCamelCase_      ,					eos_token=lowerCamelCase_      ,					sep_token=lowerCamelCase_      ,					cls_token=lowerCamelCase_      ,					unk_token=lowerCamelCase_      ,					pad_token=lowerCamelCase_      ,					mask_token=lowerCamelCase_      ,					add_prefix_space=lowerCamelCase_      ,					trim_offsets=lowerCamelCase_      ,					**lowerCamelCase_      ,					)

														lowerCAmelCase__      =			json.loads(self.backend_tokenizer.pre_tokenizer.__getstate__()     )
														if pre_tok_state.get('''add_prefix_space'''      ,					lowerCamelCase_     ) != add_prefix_space:
																					lowerCAmelCase__      =			getattr(lowerCamelCase_      ,					pre_tok_state.pop('''type'''     )     )
																					lowerCAmelCase__      =			add_prefix_space
																					lowerCAmelCase__      =			pre_tok_class(**lowerCamelCase_     )

														lowerCAmelCase__      =			add_prefix_space

														lowerCAmelCase__      =			'''post_processor'''
														lowerCAmelCase__      =			getattr(self.backend_tokenizer      ,					lowerCamelCase_      ,					lowerCamelCase_     )
														if tokenizer_component_instance:
																					lowerCAmelCase__      =			json.loads(tokenizer_component_instance.__getstate__()     )

																					# The lists 'sep' and 'cls' must be cased in tuples for the object `post_processor_class`
																					if "sep" in state:
																												lowerCAmelCase__      =			tuple(state['''sep''']     )
																					if "cls" in state:
																												lowerCAmelCase__      =			tuple(state['''cls''']     )

																					lowerCAmelCase__      =			False

																					if state.get('''add_prefix_space'''      ,					lowerCamelCase_     ) != add_prefix_space:
																												lowerCAmelCase__      =			add_prefix_space
																												lowerCAmelCase__      =			True

																					if state.get('''trim_offsets'''      ,					lowerCamelCase_     ) != trim_offsets:
																												lowerCAmelCase__      =			trim_offsets
																												lowerCAmelCase__      =			True

																					if changes_to_apply:
																												lowerCAmelCase__      =			getattr(lowerCamelCase_      ,					state.pop('''type'''     )     )
																												lowerCAmelCase__      =			component_class(**lowerCamelCase_     )
																												setattr(self.backend_tokenizer      ,					lowerCamelCase_      ,					lowerCamelCase_     )







							@property
							def 						__SCREAMING_SNAKE_CASE							(	self     ) ->							str:
														if self._mask_token is None:
																					if self.verbose:
																												logger.error('''Using mask_token, but it is not set yet.'''     )
																					return None
														return str(self._mask_token     )







							@mask_token.setter
							def 						__SCREAMING_SNAKE_CASE							(	self      ,					lowerCamelCase_     ) ->							Optional[Any]:
														lowerCAmelCase__      =			AddedToken(lowerCamelCase_      ,					lstrip=lowerCamelCase_      ,					rstrip=lowerCamelCase_     ) if isinstance(lowerCamelCase_      ,					lowerCamelCase_     ) else value
														lowerCAmelCase__      =			value







							def 						__SCREAMING_SNAKE_CASE							(	self      ,					*lowerCamelCase_      ,					**lowerCamelCase_     ) ->							BatchEncoding:
														lowerCAmelCase__      =			kwargs.get('''is_split_into_words'''      ,					lowerCamelCase_     )
														assert self.add_prefix_space or not is_split_into_words, (
														    F"""You need to instantiate {self.__class__.__name__} with add_prefix_space=True """
														    "to use it with pretokenized inputs."
														)

														return super()._batch_encode_plus(*lowerCamelCase_      ,					**lowerCamelCase_     )







							def 						__SCREAMING_SNAKE_CASE							(	self      ,					*lowerCamelCase_      ,					**lowerCamelCase_     ) ->							BatchEncoding:
														lowerCAmelCase__      =			kwargs.get('''is_split_into_words'''      ,					lowerCamelCase_     )

														assert self.add_prefix_space or not is_split_into_words, (
														    F"""You need to instantiate {self.__class__.__name__} with add_prefix_space=True """
														    "to use it with pretokenized inputs."
														)

														return super()._encode_plus(*lowerCamelCase_      ,					**lowerCamelCase_     )







							def 						__SCREAMING_SNAKE_CASE							(	self      ,					lowerCamelCase_      ,					lowerCamelCase_ = None     ) ->							Tuple[str]:
														lowerCAmelCase__      =			self._tokenizer.model.save(lowerCamelCase_      ,					name=lowerCamelCase_     )
														return tuple(lowerCamelCase_     )







							def 						__SCREAMING_SNAKE_CASE							(	self      ,					lowerCamelCase_      ,					lowerCamelCase_=None     ) ->							Tuple:
														lowerCAmelCase__      =			[self.bos_token_id] + token_ids_a + [self.eos_token_id]
														if token_ids_a is None:
																					return output

														return output + [self.eos_token_id] + token_ids_a + [self.eos_token_id]







							def 						__SCREAMING_SNAKE_CASE							(	self      ,					lowerCamelCase_      ,					lowerCamelCase_ = None     ) ->							List[int]:
														lowerCAmelCase__      =			[self.sep_token_id]
														lowerCAmelCase__      =			[self.cls_token_id]

														if token_ids_a is None:
																					return len(cls + token_ids_a + sep     ) * [0]
														return len(cls + token_ids_a + sep + sep + token_ids_a + sep     ) * [0]