



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			:




				def __init__(							self						,    _snake_case						,    _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=512						,    _snake_case=16						,    _snake_case=2						,    _snake_case=0.02						,    _snake_case=3						,    _snake_case=4						,    _snake_case=None						,    ):



									"""simple docstring"""





									_lowerCAmelCase      =   parent
									_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      =   512
									_lowerCAmelCase      =   16
									_lowerCAmelCase      =   False
									_lowerCAmelCase      =   -1
									_lowerCAmelCase      =   True
									_lowerCAmelCase      =   2
									_lowerCAmelCase      =   0.02
									_lowerCAmelCase      =   3
									_lowerCAmelCase      =   4
									_lowerCAmelCase      =   None




				def 							snake_case       (							self		):



									"""simple docstring"""





									_lowerCAmelCase      =   ids_tensor([self.batch_size, self.seq_length]						,    self.vocab_size		)

									_lowerCAmelCase      =   None
									if self.use_input_mask:
														_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      =   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=_snake_case						,    )

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




				def 							snake_case       (							self						,    _snake_case						,    _snake_case						,    _snake_case						,    _snake_case						,    _snake_case						,    _snake_case						,    _snake_case		):



									"""simple docstring"""





									_lowerCAmelCase      =   TFDebertaModel(config=_snake_case		)
									_lowerCAmelCase      =   {"""input_ids""": input_ids, """attention_mask""": input_mask, """token_type_ids""": token_type_ids}

									_lowerCAmelCase      =   [input_ids, input_mask]
									_lowerCAmelCase      =   model(_snake_case		)

									_lowerCAmelCase      =   model(_snake_case		)

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




				def 							snake_case       (							self						,    _snake_case						,    _snake_case						,    _snake_case						,    _snake_case						,    _snake_case						,    _snake_case						,    _snake_case		):



									"""simple docstring"""





									_lowerCAmelCase      =   TFDebertaForMaskedLM(config=_snake_case		)
									_lowerCAmelCase      =   {
									    """input_ids""": input_ids,
									    """attention_mask""": input_mask,
									    """token_type_ids""": token_type_ids,
									}
									_lowerCAmelCase      =   model(_snake_case		)
									self.parent.assertEqual(result.logits.shape						,    (self.batch_size, self.seq_length, self.vocab_size)		)




				def 							snake_case       (							self						,    _snake_case						,    _snake_case						,    _snake_case						,    _snake_case						,    _snake_case						,    _snake_case						,    _snake_case		):



									"""simple docstring"""





									_lowerCAmelCase      =   self.num_labels
									_lowerCAmelCase      =   TFDebertaForSequenceClassification(config=_snake_case		)
									_lowerCAmelCase      =   {
									    """input_ids""": input_ids,
									    """attention_mask""": input_mask,
									    """token_type_ids""": token_type_ids,
									}

									_lowerCAmelCase      =   model(_snake_case		)
									self.parent.assertEqual(result.logits.shape						,    (self.batch_size, self.num_labels)		)




				def 							snake_case       (							self						,    _snake_case						,    _snake_case						,    _snake_case						,    _snake_case						,    _snake_case						,    _snake_case						,    _snake_case		):



									"""simple docstring"""





									_lowerCAmelCase      =   self.num_labels
									_lowerCAmelCase      =   TFDebertaForTokenClassification(config=_snake_case		)
									_lowerCAmelCase      =   {
									    """input_ids""": input_ids,
									    """attention_mask""": input_mask,
									    """token_type_ids""": token_type_ids,
									}
									_lowerCAmelCase      =   model(_snake_case		)
									self.parent.assertEqual(result.logits.shape						,    (self.batch_size, self.seq_length, self.num_labels)		)




				def 							snake_case       (							self						,    _snake_case						,    _snake_case						,    _snake_case						,    _snake_case						,    _snake_case						,    _snake_case						,    _snake_case		):



									"""simple docstring"""





									_lowerCAmelCase      =   TFDebertaForQuestionAnswering(config=_snake_case		)
									_lowerCAmelCase      =   {
									    """input_ids""": input_ids,
									    """attention_mask""": input_mask,
									    """token_type_ids""": token_type_ids,
									}

									_lowerCAmelCase      =   model(_snake_case		)
									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 							snake_case       (							self		):



									"""simple docstring"""





									_lowerCAmelCase      =   self.prepare_config_and_inputs()
									(
									    (
									    _lowerCAmelCase
									)     ,     (
									    _lowerCAmelCase
									)     ,     (
									    _lowerCAmelCase
									)     ,     (
									    _lowerCAmelCase
									)     ,     (
									    _lowerCAmelCase
									)     ,     (
									    _lowerCAmelCase
									)     ,     (
									    _lowerCAmelCase
									)     ,     
									)      =   config_and_inputs
									_lowerCAmelCase      =   {"""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	):
				__lowerCamelCase			=    (
				    (
				        TFDebertaModel,
				        TFDebertaForMaskedLM,
				        TFDebertaForQuestionAnswering,
				        TFDebertaForSequenceClassification,
				        TFDebertaForTokenClassification,
				    )
				    if is_tf_available()
				    else ()
				)
				__lowerCamelCase			=    (
				    {
				        '''feature-extraction''': TFDebertaModel,
				        '''fill-mask''': TFDebertaForMaskedLM,
				        '''question-answering''': TFDebertaForQuestionAnswering,
				        '''text-classification''': TFDebertaForSequenceClassification,
				        '''token-classification''': TFDebertaForTokenClassification,
				        '''zero-shot''': TFDebertaForSequenceClassification,
				    }
				    if is_tf_available()
				    else {}
				)

				__lowerCamelCase			=    False
				__lowerCamelCase			=    False




				def 							snake_case       (							self		):



									"""simple docstring"""





									_lowerCAmelCase      =   TFDebertaModelTester(self		)
									_lowerCAmelCase      =   ConfigTester(self						,    config_class=_snake_case						,    hidden_size=37		)




				def 							snake_case       (							self		):



									"""simple docstring"""





									self.config_tester.run_common_tests()




				def 							snake_case       (							self		):



									"""simple docstring"""





									_lowerCAmelCase      =   self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_model(*_snake_case		)




				def 							snake_case       (							self		):



									"""simple docstring"""





									_lowerCAmelCase      =   self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_for_masked_lm(*_snake_case		)




				def 							snake_case       (							self		):



									"""simple docstring"""





									_lowerCAmelCase      =   self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_for_question_answering(*_snake_case		)




				def 							snake_case       (							self		):



									"""simple docstring"""





									_lowerCAmelCase      =   self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_for_sequence_classification(*_snake_case		)




				def 							snake_case       (							self		):



									"""simple docstring"""





									_lowerCAmelCase      =   self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_for_token_classification(*_snake_case		)




				@slow
				def 							snake_case       (							self		):



									"""simple docstring"""





									_lowerCAmelCase      =   TFDebertaModel.from_pretrained("""kamalkraj/deberta-base"""		)
									self.assertIsNotNone(_snake_case		)





@require_tf
class  __lowerCAmelCase			(					unittest.TestCase	):




				@unittest.skip(reason="""Model not available yet"""		)
				def 							snake_case       (							self		):



									"""simple docstring"""





									pass




				@slow
				def 							snake_case       (							self		):



									"""simple docstring"""





									_lowerCAmelCase      =   TFDebertaModel.from_pretrained("""kamalkraj/deberta-base"""		)
									_lowerCAmelCase      =   tf.constant([[0, 31414, 232, 328, 740, 1140, 12695, 69, 46078, 1588, 2]]		)
									_lowerCAmelCase      =   tf.constant([[0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]]		)
									_lowerCAmelCase      =   model(_snake_case						,    attention_mask=_snake_case		)[0]

									_lowerCAmelCase      =   tf.constant(
									    [
									        [
									            [-0.5985_5896, -0.8055_2566, -0.846_2135],
									            [1.448_4025, -0.9348_3794, -0.8059_3085],
									            [0.312_2741, 0.0031_6059, -1.413_1377],
									        ]
									    ]		)
									tf.debugging.assert_near(output[:, 1:4, 1:4]						,    _snake_case						,    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


A__     				=	get_logger(__name__)


def 		_UpperCAmelCase    (				snake_case      ):





					"""simple docstring"""

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



