



import os
from shutil import copyfile
from typing import Optional, Tuple

from ...file_utils import is_sentencepiece_available
from ...tokenization_utils_fast import PreTrainedTokenizerFast
from ...utils import logging


if is_sentencepiece_available():
	from .tokenization_deberta_va import DebertaVaTokenizer
else:
	UpperCAmelCase							       =    None

UpperCAmelCase							       =    logging.get_logger(__name__)

UpperCAmelCase							       =    {"""vocab_file""": """spm.model""", """tokenizer_file""": """tokenizer.json"""}

UpperCAmelCase							       =    {
    """vocab_file""": {
        """microsoft/deberta-v2-xlarge""": """https://huggingface.co/microsoft/deberta-v2-xlarge/resolve/main/spm.model""",
        """microsoft/deberta-v2-xxlarge""": """https://huggingface.co/microsoft/deberta-v2-xxlarge/resolve/main/spm.model""",
        """microsoft/deberta-v2-xlarge-mnli""": (
            """https://huggingface.co/microsoft/deberta-v2-xlarge-mnli/resolve/main/spm.model"""
        ),
        """microsoft/deberta-v2-xxlarge-mnli""": (
            """https://huggingface.co/microsoft/deberta-v2-xxlarge-mnli/resolve/main/spm.model"""
        ),
    }
}

UpperCAmelCase							       =    {
    """microsoft/deberta-v2-xlarge""": 512,
    """microsoft/deberta-v2-xxlarge""": 512,
    """microsoft/deberta-v2-xlarge-mnli""": 512,
    """microsoft/deberta-v2-xxlarge-mnli""": 512,
}

UpperCAmelCase							       =    {
    """microsoft/deberta-v2-xlarge""": {"""do_lower_case""": False},
    """microsoft/deberta-v2-xxlarge""": {"""do_lower_case""": False},
    """microsoft/deberta-v2-xlarge-mnli""": {"""do_lower_case""": False},
    """microsoft/deberta-v2-xxlarge-mnli""": {"""do_lower_case""": False},
}

class        __snake_case					(      A_):







							'''simple docstring'''






							UpperCamelCase__ :					List[Any]			   =    VOCAB_FILES_NAMES
							UpperCamelCase__ :					Tuple			   =    PRETRAINED_VOCAB_FILES_MAP
							UpperCamelCase__ :					Optional[Any]			   =    PRETRAINED_INIT_CONFIGURATION
							UpperCamelCase__ :					int			   =    PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
							UpperCamelCase__ :					List[Any]			   =    DebertaVaTokenizer


							def __init__(							self     ,     a_=None     ,     a_=None     ,     a_=False     ,     a_=False     ,     a_="[CLS]"     ,     a_="[SEP]"     ,     a_="[UNK]"     ,     a_="[SEP]"     ,     a_="[PAD]"     ,     a_="[CLS]"     ,     a_="[MASK]"     ,     **a_     ,     ):
											super().__init__(
											    _A     ,     tokenizer_file=_A     ,     do_lower_case=_A     ,     bos_token=_A     ,     eos_token=_A     ,     unk_token=_A     ,     sep_token=_A     ,     pad_token=_A     ,     cls_token=_A     ,     mask_token=_A     ,     split_by_punct=_A     ,     **_A     ,     )

											a__ 					=						do_lower_case
											a__ 					=						split_by_punct
											a__ 					=						vocab_file
											a__ 					=						False if not self.vocab_file else True


							def _a					(							self     ,     a_     ,     a_=None						):

											if token_ids_a is None:
															return [self.cls_token_id] + token_ids_a + [self.sep_token_id]
											a__ 					=						[self.cls_token_id]
											a__ 					=						[self.sep_token_id]
											return cls + token_ids_a + sep + token_ids_a + sep


							def _a					(							self     ,     a_     ,     a_=None     ,     a_=False						):

											if already_has_special_tokens:
															return super().get_special_tokens_mask(
															    token_ids_a=_A     ,     token_ids_a=_A     ,     already_has_special_tokens=_A						)

											if token_ids_a is not None:
															return [1] + ([0] * len(_A						)) + [1] + ([0] * len(_A						)) + [1]
											return [1] + ([0] * len(_A						)) + [1]


							def _a					(							self     ,     a_     ,     a_=None						):
											a__ 					=						[self.sep_token_id]
											a__ 					=						[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						) * [0] + len(token_ids_a + sep						) * [1]







							def _a					(							self     ,     a_     ,     a_ = None						):
											if not self.can_save_slow_tokenizer:
															raise ValueError(
															    """Your fast tokenizer does not have the necessary information to save the vocabulary for a slow """
															    """tokenizer."""						)

											if not os.path.isdir(_A						):
															logger.error(F'''Vocabulary path ({save_directory}) should be a directory'''						)
															return
											a__ 					=						os.path.join(
											    _A     ,     (filename_prefix + """-""" if filename_prefix else """""") + VOCAB_FILES_NAMES["""vocab_file"""]						)

											if os.path.abspath(self.vocab_file						) != os.path.abspath(_A						):
															copyfile(self.vocab_file     ,     _A						)

											return (out_vocab_file,)



from __future__ import annotations

import unittest

from transformers import MPNetConfig, 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 tensorflow as tf

   from transformers.models.mpnet.modeling_tf_mpnet import (
       TFMPNetForMaskedLM,
       TFMPNetForMultipleChoice,
       TFMPNetForQuestionAnswering,
       TFMPNetForSequenceClassification,
       TFMPNetForTokenClassification,
       TFMPNetModel,
   )







class      lowerCamelCase		:





     def __init__(self      :    Optional[Any]				,    _A      :    int				,    _A      :    Tuple=1_3				,    _A      :    List[str]=7				,    _A      :    Any=True				,    _A      :    Union[str, Any]=True				,    _A      :    Optional[Any]=False				,    _A      :    Tuple=True				,    _A      :    str=9_9				,    _A      :    Optional[Any]=6_4				,    _A      :    Optional[int]=2				,    _A      :    Union[str, Any]=4				,    _A      :    Any=6_4				,    _A      :    Any="gelu"				,    _A      :    str=0.1				,    _A      :    Union[str, Any]=0.1				,    _A      :    Optional[Any]=5_1_2				,    _A      :    int=1_6				,    _A      :    List[str]=2				,    _A      :    Optional[int]=0.02				,    _A      :    Optional[Any]=3				,    _A      :    List[str]=4				,    _A      :    int=None				,    )						->						List[Any]:
         snake_case      =					parent
         snake_case      =					batch_size
         snake_case      =					seq_length
         snake_case      =					is_training
         snake_case      =					use_input_mask
         snake_case      =					use_token_type_ids
         snake_case      =					use_labels
         snake_case      =					vocab_size
         snake_case      =					hidden_size
         snake_case      =					num_hidden_layers
         snake_case      =					num_attention_heads
         snake_case      =					intermediate_size
         snake_case      =					hidden_act
         snake_case      =					hidden_dropout_prob
         snake_case      =					attention_probs_dropout_prob
         snake_case      =					max_position_embeddings
         snake_case      =					type_vocab_size
         snake_case      =					type_sequence_label_size
         snake_case      =					initializer_range
         snake_case      =					num_labels
         snake_case      =					num_choices
         snake_case      =					scope





     def 		UpperCAmelCase(self      :    List[str]   )						->						Dict:
         snake_case      =					ids_tensor([self.batch_size, self.seq_length]				,    self.vocab_size   )

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

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

         snake_case      =					MPNetConfig(
             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				,    initializer_range=self.initializer_range				,    )
         return config, input_ids, input_mask, sequence_labels, token_labels, choice_labels





     def 		UpperCAmelCase(self      :    Tuple				,    _A      :    str				,    _A      :    Dict				,    _A      :    Optional[Any]				,    _A      :    Optional[Any]				,    _A      :    List[str]				,    _A      :    int   )						->						List[Any]:
         snake_case      =					TFMPNetModel(config=_A   )
         snake_case      =					{"input_ids": input_ids, "attention_mask": input_mask}
         snake_case      =					model(_A   )
         snake_case      =					[input_ids, input_mask]
         snake_case      =					model(_A   )
         self.parent.assertEqual(result.last_hidden_state.shape				,    (self.batch_size, self.seq_length, self.hidden_size)   )





     def 		UpperCAmelCase(self      :    int				,    _A      :    str				,    _A      :    Optional[Any]				,    _A      :    Optional[Any]				,    _A      :    Union[str, Any]				,    _A      :    Optional[Any]				,    _A      :    Any   )						->						int:
         snake_case      =					TFMPNetForMaskedLM(config=_A   )
         snake_case      =					{"input_ids": input_ids, "attention_mask": input_mask}
         snake_case      =					model(_A   )
         self.parent.assertEqual(result.logits.shape				,    (self.batch_size, self.seq_length, self.vocab_size)   )





     def 		UpperCAmelCase(self      :    Dict				,    _A      :    Optional[int]				,    _A      :    int				,    _A      :    int				,    _A      :    List[str]				,    _A      :    Union[str, Any]				,    _A      :    Union[str, Any]   )						->						int:
         snake_case      =					TFMPNetForQuestionAnswering(config=_A   )
         snake_case      =					{
             "input_ids": input_ids,
             "attention_mask": input_mask,
         }
         snake_case      =					model(_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)   )





     def 		UpperCAmelCase(self      :    Optional[int]				,    _A      :    List[Any]				,    _A      :    Dict				,    _A      :    Dict				,    _A      :    Optional[int]				,    _A      :    str				,    _A      :    Optional[Any]   )						->						Dict:
         snake_case      =					self.num_labels
         snake_case      =					TFMPNetForSequenceClassification(_A   )
         snake_case      =					{"input_ids": input_ids, "attention_mask": input_mask}
         snake_case      =					model(_A   )
         self.parent.assertEqual(result.logits.shape				,    (self.batch_size, self.num_labels)   )





     def 		UpperCAmelCase(self      :    Union[str, Any]				,    _A      :    List[str]				,    _A      :    int				,    _A      :    Optional[int]				,    _A      :    Union[str, Any]				,    _A      :    Any				,    _A      :    int   )						->						Optional[Any]:
         snake_case      =					self.num_choices
         snake_case      =					TFMPNetForMultipleChoice(_A   )
         snake_case      =					tf.tile(tf.expand_dims(_A				,    1   )				,    (1, self.num_choices, 1)   )
         snake_case      =					tf.tile(tf.expand_dims(_A				,    1   )				,    (1, self.num_choices, 1)   )
         snake_case      =					{
             "input_ids": multiple_choice_inputs_ids,
             "attention_mask": multiple_choice_input_mask,
         }
         snake_case      =					model(_A   )
         self.parent.assertEqual(result.logits.shape				,    (self.batch_size, self.num_choices)   )





     def 		UpperCAmelCase(self      :    List[Any]				,    _A      :    Union[str, Any]				,    _A      :    Dict				,    _A      :    Optional[Any]				,    _A      :    int				,    _A      :    int				,    _A      :    Tuple   )						->						Tuple:
         snake_case      =					self.num_labels
         snake_case      =					TFMPNetForTokenClassification(_A   )
         snake_case      =					{"input_ids": input_ids, "attention_mask": input_mask}
         snake_case      =					model(_A   )
         self.parent.assertEqual(result.logits.shape				,    (self.batch_size, self.seq_length, self.num_labels)   )





     def 		UpperCAmelCase(self      :    List[Any]   )						->						List[str]:
         snake_case      =					self.prepare_config_and_inputs()
         ((snake_case)     ,							(snake_case)     ,							(snake_case)     ,							(snake_case)     ,							(snake_case)     ,							(snake_case))      =					config_and_inputs
         snake_case      =					{"input_ids": input_ids, "attention_mask": input_mask}
         return config, inputs_dict







@require_tf
class      lowerCamelCase		(  A_							, A_							, unittest.TestCase  ):
     UpperCAmelCase__				:							List[Any]           =		(
         (
             TFMPNetForMaskedLM,
             TFMPNetForMultipleChoice,
             TFMPNetForQuestionAnswering,
             TFMPNetForSequenceClassification,
             TFMPNetForTokenClassification,
             TFMPNetModel,
         )
         if is_tf_available()
         else ()
     )
     UpperCAmelCase__				:							Optional[int]           =		(
         {
             "feature-extraction": TFMPNetModel,
             "fill-mask": TFMPNetForMaskedLM,
             "question-answering": TFMPNetForQuestionAnswering,
             "text-classification": TFMPNetForSequenceClassification,
             "token-classification": TFMPNetForTokenClassification,
             "zero-shot": TFMPNetForSequenceClassification,
         }
         if is_tf_available()
         else {}
     )
     UpperCAmelCase__				:							int           =		False
     UpperCAmelCase__				:							str           =		False





     def 		UpperCAmelCase(self      :    List[Any]   )						->						str:
         snake_case      =					TFMPNetModelTester(self   )
         snake_case      =					ConfigTester(self				,    config_class=_A				,    hidden_size=3_7   )





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





     def 		UpperCAmelCase(self      :    Optional[int]   )						->						str:
         snake_case      =					self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_mpnet_model(*_A   )





     def 		UpperCAmelCase(self      :    List[str]   )						->						List[str]:
         snake_case      =					self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_mpnet_for_masked_lm(*_A   )





     def 		UpperCAmelCase(self      :    Optional[Any]   )						->						str:
         snake_case      =					self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_mpnet_for_question_answering(*_A   )





     def 		UpperCAmelCase(self      :    Dict   )						->						Tuple:
         snake_case      =					self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_mpnet_for_sequence_classification(*_A   )





     def 		UpperCAmelCase(self      :    int   )						->						List[Any]:
         snake_case      =					self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_mpnet_for_multiple_choice(*_A   )





     def 		UpperCAmelCase(self      :    Union[str, Any]   )						->						int:
         snake_case      =					self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_mpnet_for_token_classification(*_A   )





     @slow
     def 		UpperCAmelCase(self      :    Optional[int]   )						->						Union[str, Any]:
         for model_name in ["microsoft/mpnet-base"]:
             snake_case      =					TFMPNetModel.from_pretrained(_A   )
             self.assertIsNotNone(_A   )







@require_tf
class      lowerCamelCase		(  unittest.TestCase  ):





     @slow
     def 		UpperCAmelCase(self      :    Optional[Any]   )						->						List[Any]:
         snake_case      =					TFMPNetModel.from_pretrained("microsoft/mpnet-base"   )
         snake_case      =					tf.constant([[0, 1, 2, 3, 4, 5]]   )
         snake_case      =					model(_A   )[0]

         snake_case      =					[1, 6, 7_6_8]
         self.assertEqual(output.shape				,    _A   )

         snake_case      =					tf.constant(
             [
                 [
                     [-0.1_06_71_72, 0.08_21_64_73, 0.0_02_45_43],
                     [-0.03_46_58_79, 0.8_35_41_18, -0.03_25_22_88],
                     [-0.06_56_94_76, -0.12_42_41_11, -0.0_49_44_36],
                 ]
             ]   )
         tf.debugging.assert_near(output[:, :3, :3]				,    _A				,    atol=1E-4   )

