
import os
import tempfile
from functools import partial
from unittest import TestCase
from unittest.mock import patch

import numpy as np
import pytest

from datasets.arrow_dataset import Dataset
from datasets.search import ElasticSearchIndex, FaissIndex, MissingIndex

from .utils import require_elasticsearch, require_faiss


lowercase   =	pytest.mark.integration





@require_faiss
class    __A(					UpperCAmelCase							):

					def  lowercase__   (						self       :  int ):
												lowerCamelCase_					=       Dataset.from_dict({"""filename""": ["""my_name-train""" + """_""" + str(__UpperCamelCase ) for x in np.arange(3_0 ).tolist()]} )
												return dset

					def  lowercase__   (						self       :  Optional[int] ):
												import faiss

												lowerCamelCase_					=       self._create_dummy_dataset()
												lowerCamelCase_					=       dset.map(
												    lambda __UpperCamelCase ,       __UpperCamelCase : {"vecs": i * np.ones(5 ,       dtype=np.floataa )} ,       with_indices=__UpperCamelCase ,       keep_in_memory=__UpperCamelCase )
												lowerCamelCase_					=       dset.add_faiss_index("""vecs""" ,       batch_size=1_0_0 ,       metric_type=faiss.METRIC_INNER_PRODUCT )
												lowerCamelCase_	, lowerCamelCase_					=       dset.get_nearest_examples("""vecs""" ,       np.ones(5 ,       dtype=np.floataa ) )
												self.assertEqual(examples["""filename"""][0] ,       """my_name-train_29""" )
												dset.drop_index("""vecs""" )

					def  lowercase__   (						self       :  List[str] ):
												import faiss

												lowerCamelCase_					=       self._create_dummy_dataset()
												dset.add_faiss_index_from_external_arrays(
												    external_arrays=np.ones((3_0, 5) ) * np.arange(3_0 ).reshape(-1 ,       1 ) ,       index_name="""vecs""" ,       batch_size=1_0_0 ,       metric_type=faiss.METRIC_INNER_PRODUCT ,       )
												lowerCamelCase_	, lowerCamelCase_					=       dset.get_nearest_examples("""vecs""" ,       np.ones(5 ,       dtype=np.floataa ) )
												self.assertEqual(examples["""filename"""][0] ,       """my_name-train_29""" )

					def  lowercase__   (						self       :  Union[str, Any] ):
												import faiss

												lowerCamelCase_					=       self._create_dummy_dataset()
												dset.add_faiss_index_from_external_arrays(
												    external_arrays=np.ones((3_0, 5) ) * np.arange(3_0 ).reshape(-1 ,       1 ) ,       index_name="""vecs""" ,       metric_type=faiss.METRIC_INNER_PRODUCT ,       )

												# Setting delete=False and unlinking manually is not pretty... but it is required on Windows to
												# ensure somewhat stable behaviour. If we don't, we get PermissionErrors. This is an age-old issue.
												# see https://bugs.python.org/issue14243 and
												# https://stackoverflow.com/questions/23212435/permission-denied-to-write-to-my-temporary-file/23212515
												with tempfile.NamedTemporaryFile(delete=__UpperCamelCase ) as tmp_file:
																			dset.save_faiss_index("""vecs""" ,       tmp_file.name )
																			dset.load_faiss_index("""vecs2""" ,       tmp_file.name )
												os.unlink(tmp_file.name )

												lowerCamelCase_	, lowerCamelCase_					=       dset.get_nearest_examples("""vecs2""" ,       np.ones(5 ,       dtype=np.floataa ) )
												self.assertEqual(examples["""filename"""][0] ,       """my_name-train_29""" )

					def  lowercase__   (						self       :  List[Any] ):
												lowerCamelCase_					=       self._create_dummy_dataset()
												dset.add_faiss_index_from_external_arrays(
												    external_arrays=np.ones((3_0, 5) ) * np.arange(3_0 ).reshape(-1 ,       1 ) ,       index_name="""vecs""" )
												dset.drop_index("""vecs""" )
												self.assertRaises(__UpperCamelCase ,       partial(dset.get_nearest_examples ,       """vecs2""" ,       np.ones(5 ,       dtype=np.floataa ) ) )



					def  lowercase__   (						self       :  List[Any] ):
												from elasticsearch import Elasticsearch

												lowerCamelCase_					=       self._create_dummy_dataset()
												with patch("""elasticsearch.Elasticsearch.search""" ) as mocked_search, patch(
												    """elasticsearch.client.IndicesClient.create""" ) as mocked_index_create, patch("""elasticsearch.helpers.streaming_bulk""" ) as mocked_bulk:
																			lowerCamelCase_					=       {"""acknowledged""": True}
																			mocked_bulk.return_value([(True, None)] * 3_0 )
																			lowerCamelCase_					=       {"""hits""": {"""hits""": [{"""_score""": 1, """_id""": 2_9}]}}
																			lowerCamelCase_					=       Elasticsearch()

																			dset.add_elasticsearch_index("""filename""" ,       es_client=__UpperCamelCase )
																			lowerCamelCase_	, lowerCamelCase_					=       dset.get_nearest_examples("""filename""" ,       """my_name-train_29""" )
																			self.assertEqual(examples["""filename"""][0] ,       """my_name-train_29""" )





@require_faiss
class    __A(					UpperCAmelCase							):

					def  lowercase__   (						self       :  Union[str, Any] ):
												import faiss

												lowerCamelCase_					=       FaissIndex(metric_type=faiss.METRIC_INNER_PRODUCT )

												# add vectors
												index.add_vectors(np.eye(5 ,       dtype=np.floataa ) )
												self.assertIsNotNone(index.faiss_index )
												self.assertEqual(index.faiss_index.ntotal ,       5 )
												index.add_vectors(np.zeros((5, 5) ,       dtype=np.floataa ) )
												self.assertEqual(index.faiss_index.ntotal ,       1_0 )

												# single query
												lowerCamelCase_					=       np.zeros(5 ,       dtype=np.floataa )
												lowerCamelCase_					=       1
												lowerCamelCase_	, lowerCamelCase_					=       index.search(__UpperCamelCase )
												self.assertRaises(__UpperCamelCase ,       index.search ,       query.reshape(-1 ,       1 ) )
												self.assertGreater(scores[0] ,       0 )
												self.assertEqual(indices[0] ,       1 )

												# batched queries
												lowerCamelCase_					=       np.eye(5 ,       dtype=np.floataa )[::-1]
												lowerCamelCase_	, lowerCamelCase_					=       index.search_batch(__UpperCamelCase )
												self.assertRaises(__UpperCamelCase ,       index.search_batch ,       queries[0] )
												lowerCamelCase_					=       [scores[0] for scores in total_scores]
												lowerCamelCase_					=       [indices[0] for indices in total_indices]
												self.assertGreater(np.min(__UpperCamelCase ) ,       0 )
												self.assertListEqual([4, 3, 2, 1, 0] ,       __UpperCamelCase )

					def  lowercase__   (						self       :  Dict ):
												import faiss

												lowerCamelCase_					=       FaissIndex(string_factory="""Flat""" )
												index.add_vectors(np.eye(5 ,       dtype=np.floataa ) )
												self.assertIsInstance(index.faiss_index ,       faiss.IndexFlat )
												lowerCamelCase_					=       FaissIndex(string_factory="""LSH""" )
												index.add_vectors(np.eye(5 ,       dtype=np.floataa ) )
												self.assertIsInstance(index.faiss_index ,       faiss.IndexLSH )
												with self.assertRaises(__UpperCamelCase ):
																			lowerCamelCase_					=       FaissIndex(string_factory="""Flat""" ,       custom_index=faiss.IndexFlat(5 ) )

					def  lowercase__   (						self       :  List[Any] ):
												import faiss

												lowerCamelCase_					=       faiss.IndexFlat(5 )
												lowerCamelCase_					=       FaissIndex(custom_index=__UpperCamelCase )
												index.add_vectors(np.eye(5 ,       dtype=np.floataa ) )
												self.assertIsInstance(index.faiss_index ,       faiss.IndexFlat )



					def  lowercase__   (						self       :  Dict ):
												import faiss

												lowerCamelCase_					=       FaissIndex(metric_type=faiss.METRIC_INNER_PRODUCT )
												index.add_vectors(np.eye(5 ,       dtype=np.floataa ) )

												# Setting delete=False and unlinking manually is not pretty... but it is required on Windows to
												# ensure somewhat stable behaviour. If we don't, we get PermissionErrors. This is an age-old issue.
												# see https://bugs.python.org/issue14243 and
												# https://stackoverflow.com/questions/23212435/permission-denied-to-write-to-my-temporary-file/23212515
												with tempfile.NamedTemporaryFile(delete=__UpperCamelCase ) as tmp_file:
																			index.save(tmp_file.name )
																			lowerCamelCase_					=       FaissIndex.load(tmp_file.name )
												os.unlink(tmp_file.name )

												lowerCamelCase_					=       np.zeros(5 ,       dtype=np.floataa )
												lowerCamelCase_					=       1
												lowerCamelCase_	, lowerCamelCase_					=       index.search(__UpperCamelCase )
												self.assertGreater(scores[0] ,       0 )
												self.assertEqual(indices[0] ,       1 )



@require_faiss
def   __lowerCAmelCase    (				UpperCAmelCase__					:   Optional[Any]							)	->     List[Any]:
							import faiss

							lowerCamelCase_					=       FaissIndex(metric_type=faiss.METRIC_INNER_PRODUCT							)
							index.add_vectors(np.eye(5      ,					dtype=np.floataa							)							)

							lowerCamelCase_					=       """index.faiss"""
							lowerCamelCase_					=       F'''mock://{index_name}'''
							index.save(UpperCAmelCase__      ,					storage_options=mockfs.storage_options							)
							lowerCamelCase_					=       FaissIndex.load(UpperCAmelCase__      ,					storage_options=mockfs.storage_options							)

							lowerCamelCase_					=       np.zeros(5      ,					dtype=np.floataa							)
							lowerCamelCase_					=       1
							lowerCamelCase_	, lowerCamelCase_					=       index.search(UpperCAmelCase__							)
							assert scores[0] > 0
							assert indices[0] == 1





@require_elasticsearch
class    __A(					UpperCAmelCase							):

					def  lowercase__   (						self       :  Union[str, Any] ):
												from elasticsearch import Elasticsearch

												with patch("""elasticsearch.Elasticsearch.search""" ) as mocked_search, patch(
												    """elasticsearch.client.IndicesClient.create""" ) as mocked_index_create, patch("""elasticsearch.helpers.streaming_bulk""" ) as mocked_bulk:
																			lowerCamelCase_					=       Elasticsearch()
																			lowerCamelCase_					=       {"""acknowledged""": True}
																			lowerCamelCase_					=       ElasticSearchIndex(es_client=__UpperCamelCase )
																			mocked_bulk.return_value([(True, None)] * 3 )
																			index.add_documents(["""foo""", """bar""", """foobar"""] )

																			# single query
																			lowerCamelCase_					=       """foo"""
																			lowerCamelCase_					=       {"""hits""": {"""hits""": [{"""_score""": 1, """_id""": 0}]}}
																			lowerCamelCase_	, lowerCamelCase_					=       index.search(__UpperCamelCase )
																			self.assertEqual(scores[0] ,       1 )
																			self.assertEqual(indices[0] ,       0 )

																			# single query with timeout
																			lowerCamelCase_					=       """foo"""
																			lowerCamelCase_					=       {"""hits""": {"""hits""": [{"""_score""": 1, """_id""": 0}]}}
																			lowerCamelCase_	, lowerCamelCase_					=       index.search(__UpperCamelCase ,       request_timeout=3_0 )
																			self.assertEqual(scores[0] ,       1 )
																			self.assertEqual(indices[0] ,       0 )

																			# batched queries
																			lowerCamelCase_					=       ["""foo""", """bar""", """foobar"""]
																			lowerCamelCase_					=       {"""hits""": {"""hits""": [{"""_score""": 1, """_id""": 1}]}}
																			lowerCamelCase_	, lowerCamelCase_					=       index.search_batch(__UpperCamelCase )
																			lowerCamelCase_					=       [scores[0] for scores in total_scores]
																			lowerCamelCase_					=       [indices[0] for indices in total_indices]
																			self.assertGreater(np.min(__UpperCamelCase ) ,       0 )
																			self.assertListEqual([1, 1, 1] ,       __UpperCamelCase )

																			# batched queries with timeout
																			lowerCamelCase_					=       ["""foo""", """bar""", """foobar"""]
																			lowerCamelCase_					=       {"""hits""": {"""hits""": [{"""_score""": 1, """_id""": 1}]}}
																			lowerCamelCase_	, lowerCamelCase_					=       index.search_batch(__UpperCamelCase ,       request_timeout=3_0 )
																			lowerCamelCase_					=       [scores[0] for scores in total_scores]
																			lowerCamelCase_					=       [indices[0] for indices in total_indices]
																			self.assertGreater(np.min(__UpperCamelCase ) ,       0 )
																			self.assertListEqual([1, 1, 1] ,       __UpperCamelCase )







from __future__ import annotations

import unittest

from transformers import DebertaVaConfig, 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 (
		    TFDebertaVaForMaskedLM,
		    TFDebertaVaForQuestionAnswering,
		    TFDebertaVaForSequenceClassification,
		    TFDebertaVaForTokenClassification,
		    TFDebertaVaModel,
		)





class    __A:

					def __init__(						self       :  List[Any] ,       __UpperCamelCase       :  Tuple ,       __UpperCamelCase       :  Any=1_3 ,       __UpperCamelCase       :  Optional[int]=7 ,       __UpperCamelCase       :  Any=True ,       __UpperCamelCase       :  Dict=True ,       __UpperCamelCase       :  Optional[Any]=True ,       __UpperCamelCase       :  Dict=True ,       __UpperCamelCase       :  Union[str, Any]=9_9 ,       __UpperCamelCase       :  List[str]=3_2 ,       __UpperCamelCase       :  int=2 ,       __UpperCamelCase       :  Optional[Any]=4 ,       __UpperCamelCase       :  Optional[int]=3_7 ,       __UpperCamelCase       :  Optional[Any]="gelu" ,       __UpperCamelCase       :  int=0.1 ,       __UpperCamelCase       :  str=0.1 ,       __UpperCamelCase       :  Tuple=5_1_2 ,       __UpperCamelCase       :  Any=1_6 ,       __UpperCamelCase       :  Dict=2 ,       __UpperCamelCase       :  Optional[Any]=0.02 ,       __UpperCamelCase       :  Optional[Any]=False ,       __UpperCamelCase       :  Dict=True ,       __UpperCamelCase       :  Any="None" ,       __UpperCamelCase       :  List[Any]=3 ,       __UpperCamelCase       :  Optional[int]=4 ,       __UpperCamelCase       :  Dict=None ,       ):
												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_					=       relative_attention
												lowerCamelCase_					=       position_biased_input
												lowerCamelCase_					=       pos_att_type
												lowerCamelCase_					=       scope

					def  lowercase__   (						self       :  Optional[Any] ):
												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_					=       DebertaVaConfig(
												    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 ,       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  lowercase__   (						self       :  str ,       __UpperCamelCase       :  Union[str, Any] ,       __UpperCamelCase       :  Optional[int] ,       __UpperCamelCase       :  Optional[Any] ,       __UpperCamelCase       :  Optional[int] ,       __UpperCamelCase       :  Any ,       __UpperCamelCase       :  int ,       __UpperCamelCase       :  List[str] ):
												lowerCamelCase_					=       TFDebertaVaModel(config=__UpperCamelCase )
												lowerCamelCase_					=       {"""input_ids""": input_ids, """attention_mask""": input_mask, """token_type_ids""": token_type_ids}

												lowerCamelCase_					=       [input_ids, input_mask]
												lowerCamelCase_					=       model(__UpperCamelCase )

												lowerCamelCase_					=       model(__UpperCamelCase )

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

					def  lowercase__   (						self       :  Optional[int] ,       __UpperCamelCase       :  List[str] ,       __UpperCamelCase       :  str ,       __UpperCamelCase       :  Dict ,       __UpperCamelCase       :  str ,       __UpperCamelCase       :  List[str] ,       __UpperCamelCase       :  Tuple ,       __UpperCamelCase       :  int ):
												lowerCamelCase_					=       TFDebertaVaForMaskedLM(config=__UpperCamelCase )
												lowerCamelCase_					=       {
												    """input_ids""": input_ids,
												    """attention_mask""": input_mask,
												    """token_type_ids""": token_type_ids,
												}
												lowerCamelCase_					=       model(__UpperCamelCase )
												self.parent.assertEqual(result.logits.shape ,       (self.batch_size, self.seq_length, self.vocab_size) )

					def  lowercase__   (						self       :  List[Any] ,       __UpperCamelCase       :  Union[str, Any] ,       __UpperCamelCase       :  str ,       __UpperCamelCase       :  int ,       __UpperCamelCase       :  Optional[int] ,       __UpperCamelCase       :  List[Any] ,       __UpperCamelCase       :  str ,       __UpperCamelCase       :  List[Any] ):
												lowerCamelCase_					=       self.num_labels
												lowerCamelCase_					=       TFDebertaVaForSequenceClassification(config=__UpperCamelCase )
												lowerCamelCase_					=       {
												    """input_ids""": input_ids,
												    """attention_mask""": input_mask,
												    """token_type_ids""": token_type_ids,
												}

												lowerCamelCase_					=       model(__UpperCamelCase )
												self.parent.assertEqual(result.logits.shape ,       (self.batch_size, self.num_labels) )

					def  lowercase__   (						self       :  int ,       __UpperCamelCase       :  Tuple ,       __UpperCamelCase       :  Any ,       __UpperCamelCase       :  str ,       __UpperCamelCase       :  Optional[int] ,       __UpperCamelCase       :  List[str] ,       __UpperCamelCase       :  List[Any] ,       __UpperCamelCase       :  List[Any] ):
												lowerCamelCase_					=       self.num_labels
												lowerCamelCase_					=       TFDebertaVaForTokenClassification(config=__UpperCamelCase )
												lowerCamelCase_					=       {
												    """input_ids""": input_ids,
												    """attention_mask""": input_mask,
												    """token_type_ids""": token_type_ids,
												}
												lowerCamelCase_					=       model(__UpperCamelCase )
												self.parent.assertEqual(result.logits.shape ,       (self.batch_size, self.seq_length, self.num_labels) )

					def  lowercase__   (						self       :  List[Any] ,       __UpperCamelCase       :  Optional[int] ,       __UpperCamelCase       :  Optional[Any] ,       __UpperCamelCase       :  Optional[int] ,       __UpperCamelCase       :  str ,       __UpperCamelCase       :  Optional[Any] ,       __UpperCamelCase       :  List[str] ,       __UpperCamelCase       :  int ):
												lowerCamelCase_					=       TFDebertaVaForQuestionAnswering(config=__UpperCamelCase )
												lowerCamelCase_					=       {
												    """input_ids""": input_ids,
												    """attention_mask""": input_mask,
												    """token_type_ids""": token_type_ids,
												}

												lowerCamelCase_					=       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  lowercase__   (						self       :  Dict ):
												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    __A(					UpperCAmelCase  ,		UpperCAmelCase  ,		unittest.TestCase							):
					SCREAMING_SNAKE_CASE           =     (
					    (
					        TFDebertaVaModel,
					        TFDebertaVaForMaskedLM,
					        TFDebertaVaForQuestionAnswering,
					        TFDebertaVaForSequenceClassification,
					        TFDebertaVaForTokenClassification,
					    )
					    if is_tf_available()
					    else ()
					)
					SCREAMING_SNAKE_CASE           =     (
					    {
					        '''feature-extraction''': TFDebertaVaModel,
					        '''fill-mask''': TFDebertaVaForMaskedLM,
					        '''question-answering''': TFDebertaVaForQuestionAnswering,
					        '''text-classification''': TFDebertaVaForSequenceClassification,
					        '''token-classification''': TFDebertaVaForTokenClassification,
					        '''zero-shot''': TFDebertaVaForSequenceClassification,
					    }
					    if is_tf_available()
					    else {}
					)

					SCREAMING_SNAKE_CASE           =     False
					SCREAMING_SNAKE_CASE           =     False

					def  lowercase__   (						self       :  Dict ):
												lowerCamelCase_					=       TFDebertaVaModelTester(self )
												lowerCamelCase_					=       ConfigTester(self ,       config_class=__UpperCamelCase ,       hidden_size=3_7 )

					def  lowercase__   (						self       :  Dict ):
												self.config_tester.run_common_tests()

					def  lowercase__   (						self       :  Optional[Any] ):
												lowerCamelCase_					=       self.model_tester.prepare_config_and_inputs()
												self.model_tester.create_and_check_model(*__UpperCamelCase )

					def  lowercase__   (						self       :  Dict ):
												lowerCamelCase_					=       self.model_tester.prepare_config_and_inputs()
												self.model_tester.create_and_check_for_masked_lm(*__UpperCamelCase )

					def  lowercase__   (						self       :  List[Any] ):
												lowerCamelCase_					=       self.model_tester.prepare_config_and_inputs()
												self.model_tester.create_and_check_for_question_answering(*__UpperCamelCase )

					def  lowercase__   (						self       :  Tuple ):
												lowerCamelCase_					=       self.model_tester.prepare_config_and_inputs()
												self.model_tester.create_and_check_for_sequence_classification(*__UpperCamelCase )

					def  lowercase__   (						self       :  Any ):
												lowerCamelCase_					=       self.model_tester.prepare_config_and_inputs()
												self.model_tester.create_and_check_for_token_classification(*__UpperCamelCase )



					@slow
					def  lowercase__   (						self       :  int ):
												lowerCamelCase_					=       TFDebertaVaModel.from_pretrained("""kamalkraj/deberta-v2-xlarge""" )
												self.assertIsNotNone(__UpperCamelCase )





@require_tf
class    __A(					unittest.TestCase							):

					@unittest.skip(reason="""Model not available yet""" )
					def  lowercase__   (						self       :  Optional[int] ):
												pass



					@slow
					def  lowercase__   (						self       :  Any ):
												lowerCamelCase_					=       TFDebertaVaModel.from_pretrained("""kamalkraj/deberta-v2-xlarge""" )
												lowerCamelCase_					=       tf.constant([[0, 3_1_4_1_4, 2_3_2, 3_2_8, 7_4_0, 1_1_4_0, 1_2_6_9_5, 6_9, 4_6_0_7_8, 1_5_8_8, 2]] )
												lowerCamelCase_					=       tf.constant([[0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]] )
												lowerCamelCase_					=       model(__UpperCamelCase ,       attention_mask=__UpperCamelCase )[0]

												lowerCamelCase_					=       tf.constant(
												    [[[0.2356, 0.1948, 0.0369], [-0.1063, 0.3586, -0.5152], [-0.6399, -0.0259, -0.2525]]] )
												tf.debugging.assert_near(output[:, 1:4, 1:4] ,       __UpperCamelCase ,       atol=1E-4 )





