





from importlib import import_module

from .logging import get_logger


lowerCAmelCase							:       Tuple					 =	get_logger(__name__)





class 				a			:






				def __init__(  self			, _lowerCAmelCase			, _lowerCAmelCase=None					):

										"""simple docstring"""




										__SCREAMING_SNAKE_CASE:				Optional[Any]           =   attrs or []
										if module is not None:
																for key in module.__dict__:
																						if key in attrs or not key.startswith('''__'''					):
																												setattr(self			, _lowerCAmelCase			, getattr(_lowerCAmelCase			, _lowerCAmelCase					)					)
										__SCREAMING_SNAKE_CASE:				int           =   module._original_module if isinstance(_lowerCAmelCase			, _PatchedModuleObj					) else module





class 				a			:
				SCREAMING_SNAKE_CASE__     :   Optional[Any]		      =     []






				def __init__(  self			, _lowerCAmelCase			, _lowerCAmelCase			, _lowerCAmelCase			, _lowerCAmelCase=None					):

										"""simple docstring"""




										__SCREAMING_SNAKE_CASE:				Union[str, Any]           =   obj
										__SCREAMING_SNAKE_CASE:				List[Any]           =   target
										__SCREAMING_SNAKE_CASE:				List[Any]           =   new
										__SCREAMING_SNAKE_CASE:				Any           =   target.split('''.'''					)[0]
										__SCREAMING_SNAKE_CASE:				int           =   {}
										__SCREAMING_SNAKE_CASE:				List[str]           =   attrs or []






				def __enter__(  self					):

										"""simple docstring"""




										*__SCREAMING_SNAKE_CASE       ,__SCREAMING_SNAKE_CASE:				Any           =   self.target.split('''.'''					)

										# Patch modules:
										# it's used to patch attributes of submodules like "os.path.join";
										# in this case we need to patch "os" and "os.path"

										for i in range(len(_lowerCAmelCase					)					):
																try:
																						__SCREAMING_SNAKE_CASE:				Optional[int]           =   import_module('''.'''.join(submodules[: i + 1]					)					)
																except ModuleNotFoundError:
																						continue
																# We iterate over all the globals in self.obj in case we find "os" or "os.path"
																for attr in self.obj.__dir__():
																						__SCREAMING_SNAKE_CASE:				str           =   getattr(self.obj			, _lowerCAmelCase					)
																						# We don't check for the name of the global, but rather if its value *is* "os" or "os.path".
																						# This allows to patch renamed modules like "from os import path as ospath".
																						if obj_attr is submodule or (
																						    (isinstance(_lowerCAmelCase			, _PatchedModuleObj					) and obj_attr._original_module is submodule)
																						):
																												__SCREAMING_SNAKE_CASE:				int           =   obj_attr
																												# patch at top level
																												setattr(self.obj			, _lowerCAmelCase			, _PatchedModuleObj(_lowerCAmelCase			, attrs=self.attrs					)					)
																												__SCREAMING_SNAKE_CASE:				Tuple           =   getattr(self.obj			, _lowerCAmelCase					)
																												# construct lower levels patches
																												for key in submodules[i + 1 :]:
																																		setattr(_lowerCAmelCase			, _lowerCAmelCase			, _PatchedModuleObj(getattr(_lowerCAmelCase			, _lowerCAmelCase			, _lowerCAmelCase					)			, attrs=self.attrs					)					)
																																		__SCREAMING_SNAKE_CASE:				List[str]           =   getattr(_lowerCAmelCase			, _lowerCAmelCase					)
																												# finally set the target attribute
																												setattr(_lowerCAmelCase			, _lowerCAmelCase			, self.new					)

        # Patch attribute itself:
        # it's used for builtins like "open",
        # and also to patch "os.path.join" we may also need to patch "join"
        # itself if it was imported as "from os.path import join".

										if submodules:  # if it's an attribute of a submodule like "os.path.join"
																try:
																						__SCREAMING_SNAKE_CASE:				Any           =   getattr(import_module('''.'''.join(_lowerCAmelCase					)					)			, _lowerCAmelCase					)
																except (AttributeError, ModuleNotFoundError):
																						return
																# We iterate over all the globals in self.obj in case we find "os.path.join"
																for attr in self.obj.__dir__():
																						# We don't check for the name of the global, but rather if its value *is* "os.path.join".
																						# This allows to patch renamed attributes like "from os.path import join as pjoin".
																						if getattr(self.obj			, _lowerCAmelCase					) is attr_value:
																												__SCREAMING_SNAKE_CASE:				Optional[Any]           =   getattr(self.obj			, _lowerCAmelCase					)
																												setattr(self.obj			, _lowerCAmelCase			, self.new					)
										elif target_attr in globals()["__builtins__"]:  # if it'a s builtin like "open"
																__SCREAMING_SNAKE_CASE:				Optional[Any]           =   globals()['''__builtins__'''][target_attr]
																setattr(self.obj			, _lowerCAmelCase			, self.new					)
										else:
																raise RuntimeError(f"""Tried to patch attribute {target_attr} instead of a submodule."""					)






				def __exit__(  self			, *_lowerCAmelCase					):

										"""simple docstring"""




										for attr in list(self.original					):
																setattr(self.obj			, _lowerCAmelCase			, self.original.pop(_lowerCAmelCase					)					)






				def 			snake_case_    (  self					):

										"""simple docstring"""




										self.__enter__()
										self._active_patches.append(self					)






				def 			snake_case_    (  self					):

										"""simple docstring"""




										try:
																self._active_patches.remove(self					)
										except ValueError:
																# If the patch hasn't been started this will fail
																return None

										return self.__exit__()










from collections import OrderedDict
from typing import TYPE_CHECKING, Any, Mapping, Optional, Union

from ...configuration_utils import PretrainedConfig
from ...onnx import OnnxConfig
from ...utils import logging


if TYPE_CHECKING:
							from ... import FeatureExtractionMixin, PreTrainedTokenizerBase, TensorType


lowerCAmelCase							:       Tuple					 =	logging.get_logger(__name__)

lowerCAmelCase							:       List[Any]					 =	{
    """microsoft/deberta-v2-xlarge""": """https://huggingface.co/microsoft/deberta-v2-xlarge/resolve/main/config.json""",
    """microsoft/deberta-v2-xxlarge""": """https://huggingface.co/microsoft/deberta-v2-xxlarge/resolve/main/config.json""",
    """microsoft/deberta-v2-xlarge-mnli""": (
        """https://huggingface.co/microsoft/deberta-v2-xlarge-mnli/resolve/main/config.json"""
    ),
    """microsoft/deberta-v2-xxlarge-mnli""": (
        """https://huggingface.co/microsoft/deberta-v2-xxlarge-mnli/resolve/main/config.json"""
    ),
}





class 				a			(      __lowercase			):
				SCREAMING_SNAKE_CASE__     :   str		      =     '''deberta-v2'''






				def __init__(  self			, _lowerCAmelCase=128100			, _lowerCAmelCase=1536			, _lowerCAmelCase=24			, _lowerCAmelCase=24			, _lowerCAmelCase=6144			, _lowerCAmelCase="gelu"			, _lowerCAmelCase=0.1			, _lowerCAmelCase=0.1			, _lowerCAmelCase=512			, _lowerCAmelCase=0			, _lowerCAmelCase=0.02			, _lowerCAmelCase=1e-7			, _lowerCAmelCase=False			, _lowerCAmelCase=-1			, _lowerCAmelCase=0			, _lowerCAmelCase=True			, _lowerCAmelCase=None			, _lowerCAmelCase=0			, _lowerCAmelCase="gelu"			, **_lowerCAmelCase			, ):

										"""simple docstring"""




										super().__init__(**_lowerCAmelCase					)

										__SCREAMING_SNAKE_CASE:				Union[str, Any]           =   hidden_size
										__SCREAMING_SNAKE_CASE:				Tuple           =   num_hidden_layers
										__SCREAMING_SNAKE_CASE:				str           =   num_attention_heads
										__SCREAMING_SNAKE_CASE:				List[Any]           =   intermediate_size
										__SCREAMING_SNAKE_CASE:				str           =   hidden_act
										__SCREAMING_SNAKE_CASE:				Dict           =   hidden_dropout_prob
										__SCREAMING_SNAKE_CASE:				Optional[int]           =   attention_probs_dropout_prob
										__SCREAMING_SNAKE_CASE:				Dict           =   max_position_embeddings
										__SCREAMING_SNAKE_CASE:				Optional[int]           =   type_vocab_size
										__SCREAMING_SNAKE_CASE:				str           =   initializer_range
										__SCREAMING_SNAKE_CASE:				Any           =   relative_attention
										__SCREAMING_SNAKE_CASE:				Tuple           =   max_relative_positions
										__SCREAMING_SNAKE_CASE:				List[str]           =   pad_token_id
										__SCREAMING_SNAKE_CASE:				List[str]           =   position_biased_input

										# Backwards compatibility
										if type(_lowerCAmelCase					) == str:
																__SCREAMING_SNAKE_CASE:				str           =   [x.strip() for x in pos_att_type.lower().split('''|'''					)]

										__SCREAMING_SNAKE_CASE:				int           =   pos_att_type
										__SCREAMING_SNAKE_CASE:				List[Any]           =   vocab_size
										__SCREAMING_SNAKE_CASE:				List[str]           =   layer_norm_eps

										__SCREAMING_SNAKE_CASE:				Optional[int]           =   kwargs.get('''pooler_hidden_size'''			, _lowerCAmelCase					)
										__SCREAMING_SNAKE_CASE:				Dict           =   pooler_dropout
										__SCREAMING_SNAKE_CASE:				int           =   pooler_hidden_act





class 				a			(      __lowercase			):






				@property
				def 			snake_case_    (  self					):

										"""simple docstring"""




										if self.task == "multiple-choice":
																__SCREAMING_SNAKE_CASE:				Any           =   {0: '''batch''', 1: '''choice''', 2: '''sequence'''}
										else:
																__SCREAMING_SNAKE_CASE:				Any           =   {0: '''batch''', 1: '''sequence'''}
										if self._config.type_vocab_size > 0:
																return OrderedDict(
																    [('''input_ids''', dynamic_axis), ('''attention_mask''', dynamic_axis), ('''token_type_ids''', dynamic_axis)]					)
										else:
																return OrderedDict([('''input_ids''', dynamic_axis), ('''attention_mask''', dynamic_axis)]					)






				@property
				def 			snake_case_    (  self					):

										"""simple docstring"""




										return 12






				def 			snake_case_    (  self			, _lowerCAmelCase			, _lowerCAmelCase = -1			, _lowerCAmelCase = -1			, _lowerCAmelCase = -1			, _lowerCAmelCase = False			, _lowerCAmelCase = None			, _lowerCAmelCase = 3			, _lowerCAmelCase = 40			, _lowerCAmelCase = 40			, _lowerCAmelCase = None			, ):

										"""simple docstring"""




										__SCREAMING_SNAKE_CASE:				str           =   super().generate_dummy_inputs(preprocessor=_lowerCAmelCase			, framework=_lowerCAmelCase					)
										if self._config.type_vocab_size == 0 and "token_type_ids" in dummy_inputs:
																del dummy_inputs["token_type_ids"]
										return dummy_inputs



