


from __future__ import annotations

import unittest

from transformers import DebertaConfig, 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 import (
       TFDebertaForMaskedLM,
       TFDebertaForQuestionAnswering,
       TFDebertaForSequenceClassification,
       TFDebertaForTokenClassification,
       TFDebertaModel,
   )







class lowerCAmelCase_						:

 '''simple docstring'''

 def __init__(	self		,      _UpperCAmelCase		,      _UpperCAmelCase=13		,      _UpperCAmelCase=7		,      _UpperCAmelCase=True		,      _UpperCAmelCase=True		,      _UpperCAmelCase=True		,      _UpperCAmelCase=True		,      _UpperCAmelCase=99		,      _UpperCAmelCase=32		,      _UpperCAmelCase=2		,      _UpperCAmelCase=4		,      _UpperCAmelCase=37		,      _UpperCAmelCase="gelu"		,      _UpperCAmelCase=0.1		,      _UpperCAmelCase=0.1		,      _UpperCAmelCase=5_12		,      _UpperCAmelCase=16		,      _UpperCAmelCase=2		,      _UpperCAmelCase=0.02		,      _UpperCAmelCase=3		,      _UpperCAmelCase=4		,      _UpperCAmelCase=None		,      ):
       snake_case_       =      parent
       snake_case_       =      13
       snake_case_       =      7
       snake_case_       =      True
       snake_case_       =      True
       snake_case_       =      True
       snake_case_       =      True
       snake_case_       =      99
       snake_case_       =      32
       snake_case_       =      2
       snake_case_       =      4
       snake_case_       =      37
       snake_case_       =      '''gelu'''
       snake_case_       =      0.1
       snake_case_       =      0.1
       snake_case_       =      5_12
       snake_case_       =      16
       snake_case_       =      False
       snake_case_       =      -1
       snake_case_       =      True
       snake_case_       =      2
       snake_case_       =      0.02
       snake_case_       =      3
       snake_case_       =      4
       snake_case_       =      None



 def 						UpperCamelCase__     (	self					):
       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
       if self.use_token_type_ids:
             snake_case_       =      ids_tensor([self.batch_size, self.seq_length]		,      self.type_vocab_size					)

       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_       =      DebertaConfig(
           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		,      relative_attention=self.relative_attention		,      max_relative_positions=self.max_relative_positions		,      position_biased_input=self.position_biased_input		,      initializer_range=self.initializer_range		,      return_dict=_UpperCAmelCase		,      )

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



 def 						UpperCamelCase__     (	self		,      _UpperCAmelCase		,      _UpperCAmelCase		,      _UpperCAmelCase		,      _UpperCAmelCase		,      _UpperCAmelCase		,      _UpperCAmelCase		,      _UpperCAmelCase					):
       snake_case_       =      TFDebertaModel(config=_UpperCAmelCase					)
       snake_case_       =      {'''input_ids''': input_ids, '''attention_mask''': input_mask, '''token_type_ids''': token_type_ids}

       snake_case_       =      [input_ids, input_mask]
       snake_case_       =      model(_UpperCAmelCase					)

       snake_case_       =      model(_UpperCAmelCase					)

       self.parent.assertEqual(result.last_hidden_state.shape		,      (self.batch_size, self.seq_length, self.hidden_size)					)



 def 						UpperCamelCase__     (	self		,      _UpperCAmelCase		,      _UpperCAmelCase		,      _UpperCAmelCase		,      _UpperCAmelCase		,      _UpperCAmelCase		,      _UpperCAmelCase		,      _UpperCAmelCase					):
       snake_case_       =      TFDebertaForMaskedLM(config=_UpperCAmelCase					)
       snake_case_       =      {
           '''input_ids''': input_ids,
           '''attention_mask''': input_mask,
           '''token_type_ids''': token_type_ids,
       }
       snake_case_       =      model(_UpperCAmelCase					)
       self.parent.assertEqual(result.logits.shape		,      (self.batch_size, self.seq_length, self.vocab_size)					)



 def 						UpperCamelCase__     (	self		,      _UpperCAmelCase		,      _UpperCAmelCase		,      _UpperCAmelCase		,      _UpperCAmelCase		,      _UpperCAmelCase		,      _UpperCAmelCase		,      _UpperCAmelCase					):
       snake_case_       =      self.num_labels
       snake_case_       =      TFDebertaForSequenceClassification(config=_UpperCAmelCase					)
       snake_case_       =      {
           '''input_ids''': input_ids,
           '''attention_mask''': input_mask,
           '''token_type_ids''': token_type_ids,
       }

       snake_case_       =      model(_UpperCAmelCase					)
       self.parent.assertEqual(result.logits.shape		,      (self.batch_size, self.num_labels)					)



 def 						UpperCamelCase__     (	self		,      _UpperCAmelCase		,      _UpperCAmelCase		,      _UpperCAmelCase		,      _UpperCAmelCase		,      _UpperCAmelCase		,      _UpperCAmelCase		,      _UpperCAmelCase					):
       snake_case_       =      self.num_labels
       snake_case_       =      TFDebertaForTokenClassification(config=_UpperCAmelCase					)
       snake_case_       =      {
           '''input_ids''': input_ids,
           '''attention_mask''': input_mask,
           '''token_type_ids''': token_type_ids,
       }
       snake_case_       =      model(_UpperCAmelCase					)
       self.parent.assertEqual(result.logits.shape		,      (self.batch_size, self.seq_length, self.num_labels)					)



 def 						UpperCamelCase__     (	self		,      _UpperCAmelCase		,      _UpperCAmelCase		,      _UpperCAmelCase		,      _UpperCAmelCase		,      _UpperCAmelCase		,      _UpperCAmelCase		,      _UpperCAmelCase					):
       snake_case_       =      TFDebertaForQuestionAnswering(config=_UpperCAmelCase					)
       snake_case_       =      {
           '''input_ids''': input_ids,
           '''attention_mask''': input_mask,
           '''token_type_ids''': token_type_ids,
       }

       snake_case_       =      model(_UpperCAmelCase					)
       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					):
       snake_case_       =      self.prepare_config_and_inputs()
       (
           (
           snake_case_
       )       ,    (
           snake_case_
       )       ,    (
           snake_case_
       )       ,    (
           snake_case_
       )       ,    (
           snake_case_
       )       ,    (
           snake_case_
       )       ,    (
           snake_case_
       )       ,    
       )       =      config_and_inputs
       snake_case_       =      {'''input_ids''': input_ids, '''token_type_ids''': token_type_ids, '''attention_mask''': input_mask}
       return config, inputs_dict







@require_tf
class lowerCAmelCase_						( lowerCamelCase__					,						lowerCamelCase__					,						unittest.TestCase       ):

 '''simple docstring'''

 __snake_case												=  (
     (
         TFDebertaModel,
         TFDebertaForMaskedLM,
         TFDebertaForQuestionAnswering,
         TFDebertaForSequenceClassification,
         TFDebertaForTokenClassification,
     )
     if is_tf_available()
     else ()
 )
 __snake_case												=  (
     {
         "feature-extraction": TFDebertaModel,
         "fill-mask": TFDebertaForMaskedLM,
         "question-answering": TFDebertaForQuestionAnswering,
         "text-classification": TFDebertaForSequenceClassification,
         "token-classification": TFDebertaForTokenClassification,
         "zero-shot": TFDebertaForSequenceClassification,
     }
     if is_tf_available()
     else {}
 )

 __snake_case												=  False
 __snake_case												=  False



 def 						UpperCamelCase__     (	self					):
       snake_case_       =      TFDebertaModelTester(self					)
       snake_case_       =      ConfigTester(self		,      config_class=_UpperCAmelCase		,      hidden_size=37					)



 def 						UpperCamelCase__     (	self					):
       self.config_tester.run_common_tests()



 def 						UpperCamelCase__     (	self					):
       snake_case_       =      self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_model(*_UpperCAmelCase					)



 def 						UpperCamelCase__     (	self					):
       snake_case_       =      self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_for_masked_lm(*_UpperCAmelCase					)



 def 						UpperCamelCase__     (	self					):
       snake_case_       =      self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_for_question_answering(*_UpperCAmelCase					)



 def 						UpperCamelCase__     (	self					):
       snake_case_       =      self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_for_sequence_classification(*_UpperCAmelCase					)



 def 						UpperCamelCase__     (	self					):
       snake_case_       =      self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_for_token_classification(*_UpperCAmelCase					)





 @slow
 def 						UpperCamelCase__     (	self					):
       snake_case_       =      TFDebertaModel.from_pretrained('''kamalkraj/deberta-base'''					)
       self.assertIsNotNone(_UpperCAmelCase					)







@require_tf
class lowerCAmelCase_						( unittest.TestCase       ):

 '''simple docstring'''

 @unittest.skip(reason='''Model not available yet'''					)
 def 						UpperCamelCase__     (	self					):
       pass





 @slow
 def 						UpperCamelCase__     (	self					):
       snake_case_       =      TFDebertaModel.from_pretrained('''kamalkraj/deberta-base'''					)
       snake_case_       =      tf.constant([[0, 3_14_14, 2_32, 3_28, 7_40, 11_40, 1_26_95, 69, 4_60_78, 15_88, 2]]					)
       snake_case_       =      tf.constant([[0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]]					)
       snake_case_       =      model(_UpperCAmelCase		,      attention_mask=_UpperCAmelCase					)[0]

       snake_case_       =      tf.constant(
           [
               [
                   [-0.59_855_896, -0.80_552_566, -0.8_462_135],
                   [1.4_484_025, -0.93_483_794, -0.80_593_085],
                   [0.3_122_741, 0.00_316_059, -1.4_131_377],
               ]
           ]					)
       tf.debugging.assert_near(output[:, 1:4, 1:4]		,      _UpperCAmelCase		,      atol=1E-4					)



import os

from packaging import version

from .. import __version__
from .accelerate_utils import apply_forward_hook
from .constants import (
    CONFIG_NAME,
    DEPRECATED_REVISION_ARGS,
    DIFFUSERS_CACHE,
    DIFFUSERS_DYNAMIC_MODULE_NAME,
    FLAX_WEIGHTS_NAME,
    HF_MODULES_CACHE,
    HUGGINGFACE_CO_RESOLVE_ENDPOINT,
    ONNX_EXTERNAL_WEIGHTS_NAME,
    ONNX_WEIGHTS_NAME,
    SAFETENSORS_WEIGHTS_NAME,
    TEXT_ENCODER_ATTN_MODULE,
    WEIGHTS_NAME,
)
from .deprecation_utils import deprecate
from .doc_utils import replace_example_docstring
from .dynamic_modules_utils import get_class_from_dynamic_module
from .hub_utils import (
    HF_HUB_OFFLINE,
    _add_variant,
    _get_model_file,
    extract_commit_hash,
    http_user_agent,
)
from .import_utils import (
    BACKENDS_MAPPING,
    ENV_VARS_TRUE_AND_AUTO_VALUES,
    ENV_VARS_TRUE_VALUES,
    USE_JAX,
    USE_TF,
    USE_TORCH,
    DummyObject,
    OptionalDependencyNotAvailable,
    is_accelerate_available,
    is_accelerate_version,
    is_bsa_available,
    is_flax_available,
    is_ftfy_available,
    is_inflect_available,
    is_invisible_watermark_available,
    is_k_diffusion_available,
    is_k_diffusion_version,
    is_librosa_available,
    is_note_seq_available,
    is_omegaconf_available,
    is_onnx_available,
    is_safetensors_available,
    is_scipy_available,
    is_tensorboard_available,
    is_tf_available,
    is_torch_available,
    is_torch_version,
    is_torchsde_available,
    is_transformers_available,
    is_transformers_version,
    is_unidecode_available,
    is_wandb_available,
    is_xformers_available,
    requires_backends,
)
from .logging import get_logger
from .outputs import BaseOutput
from .pil_utils import PIL_INTERPOLATION, numpy_to_pil, pt_to_pil
from .torch_utils import is_compiled_module, randn_tensor


if is_torch_available():
   from .testing_utils import (
       floats_tensor,
       load_hf_numpy,
       load_image,
       load_numpy,
       load_pt,
       nightly,
       parse_flag_from_env,
       print_tensor_test,
       require_torch_a,
       require_torch_gpu,
       skip_mps,
       slow,
       torch_all_close,
       torch_device,
   )
   from .torch_utils import maybe_allow_in_graph

from .testing_utils import export_to_gif, export_to_video


UpperCAmelCase			=    get_logger(__name__)






def        __lowerCAmelCase    (SCREAMING_SNAKE_CASE					)->  Tuple:




      """simple docstring"""

      if version.parse(SCREAMING_SNAKE_CASE					) < version.parse(SCREAMING_SNAKE_CASE					):
            if "dev" in min_version:
                  snake_case_       =      (
                      '''This example requires a source install from HuggingFace diffusers (see '''
                      '''`https://huggingface.co/docs/diffusers/installation#install-from-source`),'''
                  )
            else:
                  snake_case_       =      f'''This example requires a minimum version of {min_version},'''
            error_message += f''' but the version found is {__version__}.\n'''
            raise ImportError(SCREAMING_SNAKE_CASE					)