






"""simple docstring"""





from ..models.auto import AutoModelForSeqaSeqLM, AutoTokenizer
from .base import PipelineTool


A__=	{
    "Acehnese Arabic": "ace_Arab",
    "Acehnese Latin": "ace_Latn",
    "Mesopotamian Arabic": "acm_Arab",
    "Ta'izzi-Adeni Arabic": "acq_Arab",
    "Tunisian Arabic": "aeb_Arab",
    "Afrikaans": "afr_Latn",
    "South Levantine Arabic": "ajp_Arab",
    "Akan": "aka_Latn",
    "Amharic": "amh_Ethi",
    "North Levantine Arabic": "apc_Arab",
    "Modern Standard Arabic": "arb_Arab",
    "Modern Standard Arabic Romanized": "arb_Latn",
    "Najdi Arabic": "ars_Arab",
    "Moroccan Arabic": "ary_Arab",
    "Egyptian Arabic": "arz_Arab",
    "Assamese": "asm_Beng",
    "Asturian": "ast_Latn",
    "Awadhi": "awa_Deva",
    "Central Aymara": "ayr_Latn",
    "South Azerbaijani": "azb_Arab",
    "North Azerbaijani": "azj_Latn",
    "Bashkir": "bak_Cyrl",
    "Bambara": "bam_Latn",
    "Balinese": "ban_Latn",
    "Belarusian": "bel_Cyrl",
    "Bemba": "bem_Latn",
    "Bengali": "ben_Beng",
    "Bhojpuri": "bho_Deva",
    "Banjar Arabic": "bjn_Arab",
    "Banjar Latin": "bjn_Latn",
    "Standard Tibetan": "bod_Tibt",
    "Bosnian": "bos_Latn",
    "Buginese": "bug_Latn",
    "Bulgarian": "bul_Cyrl",
    "Catalan": "cat_Latn",
    "Cebuano": "ceb_Latn",
    "Czech": "ces_Latn",
    "Chokwe": "cjk_Latn",
    "Central Kurdish": "ckb_Arab",
    "Crimean Tatar": "crh_Latn",
    "Welsh": "cym_Latn",
    "Danish": "dan_Latn",
    "German": "deu_Latn",
    "Southwestern Dinka": "dik_Latn",
    "Dyula": "dyu_Latn",
    "Dzongkha": "dzo_Tibt",
    "Greek": "ell_Grek",
    "English": "eng_Latn",
    "Esperanto": "epo_Latn",
    "Estonian": "est_Latn",
    "Basque": "eus_Latn",
    "Ewe": "ewe_Latn",
    "Faroese": "fao_Latn",
    "Fijian": "fij_Latn",
    "Finnish": "fin_Latn",
    "Fon": "fon_Latn",
    "French": "fra_Latn",
    "Friulian": "fur_Latn",
    "Nigerian Fulfulde": "fuv_Latn",
    "Scottish Gaelic": "gla_Latn",
    "Irish": "gle_Latn",
    "Galician": "glg_Latn",
    "Guarani": "grn_Latn",
    "Gujarati": "guj_Gujr",
    "Haitian Creole": "hat_Latn",
    "Hausa": "hau_Latn",
    "Hebrew": "heb_Hebr",
    "Hindi": "hin_Deva",
    "Chhattisgarhi": "hne_Deva",
    "Croatian": "hrv_Latn",
    "Hungarian": "hun_Latn",
    "Armenian": "hye_Armn",
    "Igbo": "ibo_Latn",
    "Ilocano": "ilo_Latn",
    "Indonesian": "ind_Latn",
    "Icelandic": "isl_Latn",
    "Italian": "ita_Latn",
    "Javanese": "jav_Latn",
    "Japanese": "jpn_Jpan",
    "Kabyle": "kab_Latn",
    "Jingpho": "kac_Latn",
    "Kamba": "kam_Latn",
    "Kannada": "kan_Knda",
    "Kashmiri Arabic": "kas_Arab",
    "Kashmiri Devanagari": "kas_Deva",
    "Georgian": "kat_Geor",
    "Central Kanuri Arabic": "knc_Arab",
    "Central Kanuri Latin": "knc_Latn",
    "Kazakh": "kaz_Cyrl",
    "Kabiyè": "kbp_Latn",
    "Kabuverdianu": "kea_Latn",
    "Khmer": "khm_Khmr",
    "Kikuyu": "kik_Latn",
    "Kinyarwanda": "kin_Latn",
    "Kyrgyz": "kir_Cyrl",
    "Kimbundu": "kmb_Latn",
    "Northern Kurdish": "kmr_Latn",
    "Kikongo": "kon_Latn",
    "Korean": "kor_Hang",
    "Lao": "lao_Laoo",
    "Ligurian": "lij_Latn",
    "Limburgish": "lim_Latn",
    "Lingala": "lin_Latn",
    "Lithuanian": "lit_Latn",
    "Lombard": "lmo_Latn",
    "Latgalian": "ltg_Latn",
    "Luxembourgish": "ltz_Latn",
    "Luba-Kasai": "lua_Latn",
    "Ganda": "lug_Latn",
    "Luo": "luo_Latn",
    "Mizo": "lus_Latn",
    "Standard Latvian": "lvs_Latn",
    "Magahi": "mag_Deva",
    "Maithili": "mai_Deva",
    "Malayalam": "mal_Mlym",
    "Marathi": "mar_Deva",
    "Minangkabau Arabic ": "min_Arab",
    "Minangkabau Latin": "min_Latn",
    "Macedonian": "mkd_Cyrl",
    "Plateau Malagasy": "plt_Latn",
    "Maltese": "mlt_Latn",
    "Meitei Bengali": "mni_Beng",
    "Halh Mongolian": "khk_Cyrl",
    "Mossi": "mos_Latn",
    "Maori": "mri_Latn",
    "Burmese": "mya_Mymr",
    "Dutch": "nld_Latn",
    "Norwegian Nynorsk": "nno_Latn",
    "Norwegian Bokmål": "nob_Latn",
    "Nepali": "npi_Deva",
    "Northern Sotho": "nso_Latn",
    "Nuer": "nus_Latn",
    "Nyanja": "nya_Latn",
    "Occitan": "oci_Latn",
    "West Central Oromo": "gaz_Latn",
    "Odia": "ory_Orya",
    "Pangasinan": "pag_Latn",
    "Eastern Panjabi": "pan_Guru",
    "Papiamento": "pap_Latn",
    "Western Persian": "pes_Arab",
    "Polish": "pol_Latn",
    "Portuguese": "por_Latn",
    "Dari": "prs_Arab",
    "Southern Pashto": "pbt_Arab",
    "Ayacucho Quechua": "quy_Latn",
    "Romanian": "ron_Latn",
    "Rundi": "run_Latn",
    "Russian": "rus_Cyrl",
    "Sango": "sag_Latn",
    "Sanskrit": "san_Deva",
    "Santali": "sat_Olck",
    "Sicilian": "scn_Latn",
    "Shan": "shn_Mymr",
    "Sinhala": "sin_Sinh",
    "Slovak": "slk_Latn",
    "Slovenian": "slv_Latn",
    "Samoan": "smo_Latn",
    "Shona": "sna_Latn",
    "Sindhi": "snd_Arab",
    "Somali": "som_Latn",
    "Southern Sotho": "sot_Latn",
    "Spanish": "spa_Latn",
    "Tosk Albanian": "als_Latn",
    "Sardinian": "srd_Latn",
    "Serbian": "srp_Cyrl",
    "Swati": "ssw_Latn",
    "Sundanese": "sun_Latn",
    "Swedish": "swe_Latn",
    "Swahili": "swh_Latn",
    "Silesian": "szl_Latn",
    "Tamil": "tam_Taml",
    "Tatar": "tat_Cyrl",
    "Telugu": "tel_Telu",
    "Tajik": "tgk_Cyrl",
    "Tagalog": "tgl_Latn",
    "Thai": "tha_Thai",
    "Tigrinya": "tir_Ethi",
    "Tamasheq Latin": "taq_Latn",
    "Tamasheq Tifinagh": "taq_Tfng",
    "Tok Pisin": "tpi_Latn",
    "Tswana": "tsn_Latn",
    "Tsonga": "tso_Latn",
    "Turkmen": "tuk_Latn",
    "Tumbuka": "tum_Latn",
    "Turkish": "tur_Latn",
    "Twi": "twi_Latn",
    "Central Atlas Tamazight": "tzm_Tfng",
    "Uyghur": "uig_Arab",
    "Ukrainian": "ukr_Cyrl",
    "Umbundu": "umb_Latn",
    "Urdu": "urd_Arab",
    "Northern Uzbek": "uzn_Latn",
    "Venetian": "vec_Latn",
    "Vietnamese": "vie_Latn",
    "Waray": "war_Latn",
    "Wolof": "wol_Latn",
    "Xhosa": "xho_Latn",
    "Eastern Yiddish": "ydd_Hebr",
    "Yoruba": "yor_Latn",
    "Yue Chinese": "yue_Hant",
    "Chinese Simplified": "zho_Hans",
    "Chinese Traditional": "zho_Hant",
    "Standard Malay": "zsm_Latn",
    "Zulu": "zul_Latn",
}
class    __lowerCamelCase    (  __UpperCAmelCase  ):
   a      :				Dict 						="""facebook/nllb-200-distilled-600M"""
   a      :				Tuple 						=(
       """This is a tool that translates text from a language to another. It takes three inputs: `text`, which should """
       """be the text to translate, `src_lang`, which should be the language of the text to translate and `tgt_lang`, """
       """which should be the language for the desired ouput language. Both `src_lang` and `tgt_lang` are written in """
       """plain English, such as 'Romanian', or 'Albanian'. It returns the text translated in `tgt_lang`."""
   )
   a      :				Optional[Any] 						="""translator"""
   a      :				Any 						=AutoTokenizer
   a      :				Any 						=AutoModelForSeqaSeqLM
   a      :				Dict 						=LANGUAGE_CODES

   a      :				Dict 						=["""text""", """text""", """text"""]
   a      :				Dict 						=["""text"""]

   def 						SCREAMING_SNAKE_CASE__ (					self ,				snake_case_ ,				snake_case_ ,				snake_case_      )		->       Tuple:







       if src_lang not in self.lang_to_code:
           raise ValueError(F'{src_lang} is not a supported language.'      )
       if tgt_lang not in self.lang_to_code:
           raise ValueError(F'{tgt_lang} is not a supported language.'      )
       UpperCamelCase__         =    self.lang_to_code[src_lang]
       UpperCamelCase__         =    self.lang_to_code[tgt_lang]
       return self.pre_processor._build_translation_inputs(
           lowerCAmelCase_ ,				return_tensors='pt' ,				src_lang=lowerCAmelCase_ ,				tgt_lang=lowerCAmelCase_      )

   def 						SCREAMING_SNAKE_CASE__ (					self ,				snake_case_      )		->       Tuple:
       return self.model.generate(**lowerCAmelCase_      )







   def 						SCREAMING_SNAKE_CASE__ (					self ,				snake_case_      )		->       str:
       return self.post_processor.decode(outputs[0].tolist() ,				skip_special_tokens=lowerCAmelCase_      )












"""simple docstring"""





from __future__ import annotations

import os
import tempfile
import unittest

from transformers import ConvBertConfig, 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 (
      TFConvBertForMaskedLM,
      TFConvBertForMultipleChoice,
      TFConvBertForQuestionAnswering,
      TFConvBertForSequenceClassification,
      TFConvBertForTokenClassification,
      TFConvBertModel,
  )
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 ,				)		->       Tuple:
       UpperCamelCase__         =    parent
       UpperCamelCase__         =    13
       UpperCamelCase__         =    7
       UpperCamelCase__         =    True
       UpperCamelCase__         =    True
       UpperCamelCase__         =    True
       UpperCamelCase__         =    True
       UpperCamelCase__         =    99
       UpperCamelCase__         =    384
       UpperCamelCase__         =    2
       UpperCamelCase__         =    4
       UpperCamelCase__         =    37
       UpperCamelCase__         =    'gelu'
       UpperCamelCase__         =    0.1
       UpperCamelCase__         =    0.1
       UpperCamelCase__         =    512
       UpperCamelCase__         =    16
       UpperCamelCase__         =    2
       UpperCamelCase__         =    0.02
       UpperCamelCase__         =    3
       UpperCamelCase__         =    4
       UpperCamelCase__         =    128
       UpperCamelCase__         =    2
       UpperCamelCase__         =    9
       UpperCamelCase__         =    1
       UpperCamelCase__         =    None

   def 						SCREAMING_SNAKE_CASE__ (					self      )		->       int:
       UpperCamelCase__         =    ids_tensor([self.batch_size, self.seq_length] ,				self.vocab_size      )

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

       UpperCamelCase__         =    None
       if self.use_token_type_ids:
           UpperCamelCase__         =    ids_tensor([self.batch_size, self.seq_length] ,				self.type_vocab_size      )

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

       UpperCamelCase__         =    ConvBertConfig(
           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 ,				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 						SCREAMING_SNAKE_CASE__ (					self ,				snake_case_ ,				snake_case_ ,				snake_case_ ,				snake_case_ ,				snake_case_ ,				snake_case_ ,				snake_case_      )		->       int:
       UpperCamelCase__         =    TFConvBertModel(config=snake_case_      )
       UpperCamelCase__         =    {'input_ids': input_ids, 'attention_mask': input_mask, 'token_type_ids': token_type_ids}

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

       UpperCamelCase__         =    model(snake_case_      )

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

   def 						SCREAMING_SNAKE_CASE__ (					self ,				snake_case_ ,				snake_case_ ,				snake_case_ ,				snake_case_ ,				snake_case_ ,				snake_case_ ,				snake_case_      )		->       int:
       UpperCamelCase__         =    TFConvBertForMaskedLM(config=snake_case_      )
       UpperCamelCase__         =    {
           'input_ids': input_ids,
           'attention_mask': input_mask,
           'token_type_ids': token_type_ids,
       }
       UpperCamelCase__         =    model(snake_case_      )
       self.parent.assertEqual(result.logits.shape ,				(self.batch_size, self.seq_length, self.vocab_size)      )

   def 						SCREAMING_SNAKE_CASE__ (					self ,				snake_case_ ,				snake_case_ ,				snake_case_ ,				snake_case_ ,				snake_case_ ,				snake_case_ ,				snake_case_      )		->       List[str]:
       UpperCamelCase__         =    self.num_labels
       UpperCamelCase__         =    TFConvBertForSequenceClassification(config=snake_case_      )
       UpperCamelCase__         =    {
           'input_ids': input_ids,
           'attention_mask': input_mask,
           'token_type_ids': token_type_ids,
       }

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

   def 						SCREAMING_SNAKE_CASE__ (					self ,				snake_case_ ,				snake_case_ ,				snake_case_ ,				snake_case_ ,				snake_case_ ,				snake_case_ ,				snake_case_      )		->       Tuple:
       UpperCamelCase__         =    self.num_choices
       UpperCamelCase__         =    TFConvBertForMultipleChoice(config=snake_case_      )
       UpperCamelCase__         =    tf.tile(tf.expand_dims(snake_case_ ,				1      ) ,				(1, self.num_choices, 1)      )
       UpperCamelCase__         =    tf.tile(tf.expand_dims(snake_case_ ,				1      ) ,				(1, self.num_choices, 1)      )
       UpperCamelCase__         =    tf.tile(tf.expand_dims(snake_case_ ,				1      ) ,				(1, self.num_choices, 1)      )
       UpperCamelCase__         =    {
           'input_ids': multiple_choice_inputs_ids,
           'attention_mask': multiple_choice_input_mask,
           'token_type_ids': multiple_choice_token_type_ids,
       }
       UpperCamelCase__         =    model(snake_case_      )
       self.parent.assertEqual(result.logits.shape ,				(self.batch_size, self.num_choices)      )

   def 						SCREAMING_SNAKE_CASE__ (					self ,				snake_case_ ,				snake_case_ ,				snake_case_ ,				snake_case_ ,				snake_case_ ,				snake_case_ ,				snake_case_      )		->       List[str]:
       UpperCamelCase__         =    self.num_labels
       UpperCamelCase__         =    TFConvBertForTokenClassification(config=snake_case_      )
       UpperCamelCase__         =    {
           'input_ids': input_ids,
           'attention_mask': input_mask,
           'token_type_ids': token_type_ids,
       }
       UpperCamelCase__         =    model(snake_case_      )
       self.parent.assertEqual(result.logits.shape ,				(self.batch_size, self.seq_length, self.num_labels)      )

   def 						SCREAMING_SNAKE_CASE__ (					self ,				snake_case_ ,				snake_case_ ,				snake_case_ ,				snake_case_ ,				snake_case_ ,				snake_case_ ,				snake_case_      )		->       List[Any]:
       UpperCamelCase__         =    TFConvBertForQuestionAnswering(config=snake_case_      )
       UpperCamelCase__         =    {
           'input_ids': input_ids,
           'attention_mask': input_mask,
           'token_type_ids': token_type_ids,
       }

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







@require_tf
class    __lowerCamelCase    (  _a							,	_a							,	unittest.TestCase  ):
   a      :				Any 						=(
       (
           TFConvBertModel,
           TFConvBertForMaskedLM,
           TFConvBertForQuestionAnswering,
           TFConvBertForSequenceClassification,
           TFConvBertForTokenClassification,
           TFConvBertForMultipleChoice,
       )
       if is_tf_available()
       else ()
   )
   a      :				str 						=(
       {
           """feature-extraction""": TFConvBertModel,
           """fill-mask""": TFConvBertForMaskedLM,
           """question-answering""": TFConvBertForQuestionAnswering,
           """text-classification""": TFConvBertForSequenceClassification,
           """token-classification""": TFConvBertForTokenClassification,
           """zero-shot""": TFConvBertForSequenceClassification,
       }
       if is_tf_available()
       else {}
   )
   a      :				Any 						=False
   a      :				Dict 						=False
   a      :				str 						=False

   def 						SCREAMING_SNAKE_CASE__ (					self      )		->       Dict:
       UpperCamelCase__         =    TFConvBertModelTester(self      )
       UpperCamelCase__         =    ConfigTester(self ,				config_class=snake_case_ ,				hidden_size=37      )

   def 						SCREAMING_SNAKE_CASE__ (					self      )		->       int:
       self.config_tester.run_common_tests()

   def 						SCREAMING_SNAKE_CASE__ (					self      )		->       int:
       UpperCamelCase__         =    self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_model(*snake_case_      )

   def 						SCREAMING_SNAKE_CASE__ (					self      )		->       Dict:
       UpperCamelCase__         =    self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_for_masked_lm(*snake_case_      )

   def 						SCREAMING_SNAKE_CASE__ (					self      )		->       Optional[int]:
       UpperCamelCase__         =    self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_for_multiple_choice(*snake_case_      )

   def 						SCREAMING_SNAKE_CASE__ (					self      )		->       Dict:
       UpperCamelCase__         =    self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_for_question_answering(*snake_case_      )

   def 						SCREAMING_SNAKE_CASE__ (					self      )		->       int:
       UpperCamelCase__         =    self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_for_sequence_classification(*snake_case_      )

   def 						SCREAMING_SNAKE_CASE__ (					self      )		->       List[str]:
       UpperCamelCase__         =    self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_for_token_classification(*snake_case_      )

   @slow
   def 						SCREAMING_SNAKE_CASE__ (					self      )		->       List[Any]:
       UpperCamelCase__       ,						UpperCamelCase__         =    self.model_tester.prepare_config_and_inputs_for_common()
       UpperCamelCase__         =    True
       UpperCamelCase__         =    True

       if hasattr(snake_case_ ,				'use_cache'      ):
           UpperCamelCase__         =    True

       UpperCamelCase__         =    getattr(self.model_tester ,				'encoder_seq_length' ,				self.model_tester.seq_length      )
       UpperCamelCase__         =    getattr(self.model_tester ,				'key_length' ,				snake_case_      )

       for model_class in self.all_model_classes:
           UpperCamelCase__         =    self._prepare_for_class(snake_case_ ,				snake_case_      )
           UpperCamelCase__         =    model_class(snake_case_      )
           UpperCamelCase__         =    len(model(snake_case_      )      )

           with tempfile.TemporaryDirectory() as tmpdirname:
               model.save_pretrained(snake_case_ ,				saved_model=snake_case_      )
               UpperCamelCase__         =    os.path.join(snake_case_ ,				'saved_model' ,				'1'      )
               UpperCamelCase__         =    tf.keras.models.load_model(snake_case_      )
               UpperCamelCase__         =    model(snake_case_      )

               if self.is_encoder_decoder:
                   UpperCamelCase__         =    outputs['encoder_hidden_states']
                   UpperCamelCase__         =    outputs['encoder_attentions']
               else:
                   UpperCamelCase__         =    outputs['hidden_states']
                   UpperCamelCase__         =    outputs['attentions']

               self.assertEqual(len(snake_case_      ) ,				snake_case_      )

               UpperCamelCase__         =    getattr(
                   self.model_tester ,				'expected_num_hidden_layers' ,				self.model_tester.num_hidden_layers + 1      )

               self.assertEqual(len(snake_case_      ) ,				snake_case_      )
               self.assertListEqual(
                   list(output_hidden_states[0].shape[-2:]      ) ,				[self.model_tester.seq_length, self.model_tester.hidden_size] ,				)

               self.assertEqual(len(snake_case_      ) ,				self.model_tester.num_hidden_layers      )
               self.assertListEqual(
                   list(output_attentions[0].shape[-3:]      ) ,				[self.model_tester.num_attention_heads / 2, encoder_seq_length, encoder_key_length] ,				)

   @slow
   def 						SCREAMING_SNAKE_CASE__ (					self      )		->       Union[str, Any]:
       UpperCamelCase__         =    TFConvBertModel.from_pretrained('YituTech/conv-bert-base'      )
       self.assertIsNotNone(snake_case_      )







   def 						SCREAMING_SNAKE_CASE__ (					self      )		->       Dict:
       UpperCamelCase__       ,						UpperCamelCase__         =    self.model_tester.prepare_config_and_inputs_for_common()
       UpperCamelCase__         =    True
       UpperCamelCase__         =    getattr(self.model_tester ,				'decoder_seq_length' ,				self.model_tester.seq_length      )
       UpperCamelCase__         =    getattr(self.model_tester ,				'encoder_seq_length' ,				self.model_tester.seq_length      )
       UpperCamelCase__         =    getattr(self.model_tester ,				'key_length' ,				snake_case_      )
       UpperCamelCase__         =    getattr(self.model_tester ,				'key_length' ,				snake_case_      )

       def check_decoder_attentions_output(snake_case_      ):
           UpperCamelCase__         =    len(snake_case_      )
           self.assertEqual(out_len % 2 ,				0      )
           UpperCamelCase__         =    outputs.decoder_attentions
           self.assertEqual(len(snake_case_      ) ,				self.model_tester.num_hidden_layers      )
           self.assertListEqual(
               list(decoder_attentions[0].shape[-3:]      ) ,				[self.model_tester.num_attention_heads / 2, decoder_seq_length, decoder_key_length] ,				)

       def check_encoder_attentions_output(snake_case_      ):
           UpperCamelCase__         =    [
               t.numpy() for t in (outputs.encoder_attentions if config.is_encoder_decoder else outputs.attentions)
           ]
           self.assertEqual(len(snake_case_      ) ,				self.model_tester.num_hidden_layers      )
           self.assertListEqual(
               list(attentions[0].shape[-3:]      ) ,				[self.model_tester.num_attention_heads / 2, encoder_seq_length, encoder_key_length] ,				)

       for model_class in self.all_model_classes:
           UpperCamelCase__         =    True
           UpperCamelCase__         =    False
           UpperCamelCase__         =    model_class(snake_case_      )
           UpperCamelCase__         =    model(self._prepare_for_class(snake_case_ ,				snake_case_      )      )
           UpperCamelCase__         =    len(snake_case_      )
           self.assertEqual(config.output_hidden_states ,				snake_case_      )
           check_encoder_attentions_output(snake_case_      )

           if self.is_encoder_decoder:
               UpperCamelCase__         =    model_class(snake_case_      )
               UpperCamelCase__         =    model(self._prepare_for_class(snake_case_ ,				snake_case_      )      )
               self.assertEqual(config.output_hidden_states ,				snake_case_      )
               check_decoder_attentions_output(snake_case_      )

           # Check that output attentions can also be changed via the config
           del inputs_dict["output_attentions"]
           UpperCamelCase__         =    True
           UpperCamelCase__         =    model_class(snake_case_      )
           UpperCamelCase__         =    model(self._prepare_for_class(snake_case_ ,				snake_case_      )      )
           self.assertEqual(config.output_hidden_states ,				snake_case_      )
           check_encoder_attentions_output(snake_case_      )

           # Check attention is always last and order is fine
           UpperCamelCase__         =    True
           UpperCamelCase__         =    True
           UpperCamelCase__         =    model_class(snake_case_      )
           UpperCamelCase__         =    model(self._prepare_for_class(snake_case_ ,				snake_case_      )      )

           self.assertEqual(out_len + (2 if self.is_encoder_decoder else 1) ,				len(snake_case_      )      )
           self.assertEqual(model.config.output_hidden_states ,				snake_case_      )
           check_encoder_attentions_output(snake_case_      )







@require_tf
class    __lowerCamelCase    (  unittest.TestCase  ):

   @slow
   def 						SCREAMING_SNAKE_CASE__ (					self      )		->       List[Any]:
       UpperCamelCase__         =    TFConvBertModel.from_pretrained('YituTech/conv-bert-base'      )
       UpperCamelCase__         =    tf.constant([[0, 1, 2, 3, 4, 5]]      )
       UpperCamelCase__         =    model(snake_case_      )[0]

       UpperCamelCase__         =    [1, 6, 768]
       self.assertEqual(output.shape ,				snake_case_      )

       UpperCamelCase__         =    tf.constant(
           [
               [
                   [-0.03_475_493, -0.4_686_034, -0.30_638_832],
                   [0.22_637_248, -0.26_988_646, -0.7_423_424],
                   [0.10_324_868, -0.45_013_508, -0.58_280_784],
               ]
           ]      )
       tf.debugging.assert_near(output[:, :3, :3] ,				snake_case_ ,				atol=1E-4      )




