'''simple docstring'''





# Copyright 2023 The HuggingFace Inc. team. All rights reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
from ..models.auto import AutoModelForSeqaSeqLM, AutoTokenizer
from .base import PipelineTool


SCREAMING_SNAKE_CASE_:	Union[str, Any]    ={
    '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 			__A (					UpperCamelCase__      ):
    a__			:		Any			  =    """facebook/nllb-200-distilled-600M"""
    a__			:		Union[str, Any]			  =    (
        """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__			:		int			  =    """translator"""
    a__			:		Optional[Any]			  =    AutoTokenizer
    a__			:		Optional[Any]			  =    AutoModelForSeqaSeqLM
    a__			:		Dict			  =    LANGUAGE_CODES

    a__			:		Union[str, Any]			  =    ["""text""", """text""", """text"""]
    a__			:		Union[str, Any]			  =    ["""text"""]



    def    _lowercase		(self       :       int  ,     __a       :       int  ,     __a       :       Dict  ,     __a       :       int					):
         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(
             __a  ,     return_tensors="pt"  ,     src_lang=__a  ,     tgt_lang=__a					)



    def    _lowercase		(self       :       Optional[Any]  ,     __a       :       List[str]					):
         return self.model.generate(**__a					)






    def    _lowercase		(self       :       Any  ,     __a       :       Tuple					):
         return self.post_processor.decode(outputs[0].tolist()  ,     skip_special_tokens=__a					)





'''simple docstring'''

from __future__ import annotations

import unittest

from transformers import RoFormerConfig, 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 (
      TFRoFormerForCausalLM,
      TFRoFormerForMaskedLM,
      TFRoFormerForMultipleChoice,
      TFRoFormerForQuestionAnswering,
      TFRoFormerForSequenceClassification,
      TFRoFormerForTokenClassification,
      TFRoFormerModel,
  )
  from transformers.models.roformer.modeling_tf_roformer import (
      TFRoFormerSelfAttention,
      TFRoFormerSinusoidalPositionalEmbedding,
  )


class 					_lowercase						:
      '''simple docstring'''


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



         '''simple docstring'''



         UpperCAmelCase__				:					Any 					=	parent
         UpperCAmelCase__				:					str 					=	13
         UpperCAmelCase__				:					Any 					=	7
         UpperCAmelCase__				:					str 					=	True
         UpperCAmelCase__				:					List[Any] 					=	True
         UpperCAmelCase__				:					Tuple 					=	True
         UpperCAmelCase__				:					List[str] 					=	True
         UpperCAmelCase__				:					List[Any] 					=	99
         UpperCAmelCase__				:					str 					=	32
         UpperCAmelCase__				:					Dict 					=	2
         UpperCAmelCase__				:					Union[str, Any] 					=	4
         UpperCAmelCase__				:					Dict 					=	37
         UpperCAmelCase__				:					Dict 					=	'''gelu'''
         UpperCAmelCase__				:					List[str] 					=	0.1
         UpperCAmelCase__				:					List[str] 					=	0.1
         UpperCAmelCase__				:					Optional[int] 					=	512
         UpperCAmelCase__				:					Any 					=	16
         UpperCAmelCase__				:					List[Any] 					=	2
         UpperCAmelCase__				:					Optional[Any] 					=	0.02
         UpperCAmelCase__				:					Optional[int] 					=	3
         UpperCAmelCase__				:					Optional[int] 					=	4
         UpperCAmelCase__				:					Optional[int] 					=	None




      def 		lowerCAmelCase__       (					self				)      ->      Optional[int]:



         '''simple docstring'''



         UpperCAmelCase__				:					Tuple 					=	ids_tensor([self.batch_size, self.seq_length]       ,self.vocab_size				)

         UpperCAmelCase__				:					List[str] 					=	None
         if self.use_input_mask:
            UpperCAmelCase__				:					int 					=	random_attention_mask([self.batch_size, self.seq_length]				)

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

         UpperCAmelCase__				:					List[str] 					=	None
         UpperCAmelCase__				:					Any 					=	None
         UpperCAmelCase__				:					Dict 					=	None
         if self.use_labels:
            UpperCAmelCase__				:					Optional[Any] 					=	ids_tensor([self.batch_size]       ,self.type_sequence_label_size				)
            UpperCAmelCase__				:					Dict 					=	ids_tensor([self.batch_size, self.seq_length]       ,self.num_labels				)
            UpperCAmelCase__				:					List[str] 					=	ids_tensor([self.batch_size]       ,self.num_choices				)

         UpperCAmelCase__				:					Union[str, Any] 					=	RoFormerConfig(
             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=lowerCamelCase_       ,)

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




      def 		lowerCAmelCase__       (					self       ,lowerCamelCase_       ,lowerCamelCase_       ,lowerCamelCase_       ,lowerCamelCase_       ,lowerCamelCase_       ,lowerCamelCase_       ,lowerCamelCase_				)      ->      int:



         '''simple docstring'''



         UpperCAmelCase__				:					List[str] 					=	TFRoFormerModel(config=lowerCamelCase_				)
         UpperCAmelCase__				:					str 					=	{'''input_ids''': input_ids, '''attention_mask''': input_mask, '''token_type_ids''': token_type_ids}

         UpperCAmelCase__				:					str 					=	[input_ids, input_mask]
         UpperCAmelCase__				:					Any 					=	model(lowerCamelCase_				)

         UpperCAmelCase__				:					List[Any] 					=	model(lowerCamelCase_				)

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




      def 		lowerCAmelCase__       (					self       ,lowerCamelCase_       ,lowerCamelCase_       ,lowerCamelCase_       ,lowerCamelCase_       ,lowerCamelCase_       ,lowerCamelCase_       ,lowerCamelCase_				)      ->      Tuple:



         '''simple docstring'''



         UpperCAmelCase__				:					Optional[int] 					=	True
         UpperCAmelCase__				:					Any 					=	TFRoFormerForCausalLM(config=lowerCamelCase_				)
         UpperCAmelCase__				:					List[str] 					=	{
             '''input_ids''': input_ids,
             '''attention_mask''': input_mask,
             '''token_type_ids''': token_type_ids,
         }
         UpperCAmelCase__				:					int 					=	model(lowerCamelCase_				)['''logits''']
         self.parent.assertListEqual(
             list(prediction_scores.numpy().shape				)       ,[self.batch_size, self.seq_length, self.vocab_size]				)




      def 		lowerCAmelCase__       (					self       ,lowerCamelCase_       ,lowerCamelCase_       ,lowerCamelCase_       ,lowerCamelCase_       ,lowerCamelCase_       ,lowerCamelCase_       ,lowerCamelCase_				)      ->      List[str]:



         '''simple docstring'''



         UpperCAmelCase__				:					Union[str, Any] 					=	TFRoFormerForMaskedLM(config=lowerCamelCase_				)
         UpperCAmelCase__				:					Dict 					=	{
             '''input_ids''': input_ids,
             '''attention_mask''': input_mask,
             '''token_type_ids''': token_type_ids,
         }
         UpperCAmelCase__				:					Dict 					=	model(lowerCamelCase_				)
         self.parent.assertEqual(result.logits.shape       ,(self.batch_size, self.seq_length, self.vocab_size)				)




      def 		lowerCAmelCase__       (					self       ,lowerCamelCase_       ,lowerCamelCase_       ,lowerCamelCase_       ,lowerCamelCase_       ,lowerCamelCase_       ,lowerCamelCase_       ,lowerCamelCase_				)      ->      Union[str, Any]:



         '''simple docstring'''



         UpperCAmelCase__				:					Optional[Any] 					=	self.num_labels
         UpperCAmelCase__				:					List[Any] 					=	TFRoFormerForSequenceClassification(config=lowerCamelCase_				)
         UpperCAmelCase__				:					List[Any] 					=	{
             '''input_ids''': input_ids,
             '''attention_mask''': input_mask,
             '''token_type_ids''': token_type_ids,
         }

         UpperCAmelCase__				:					Union[str, Any] 					=	model(lowerCamelCase_				)
         self.parent.assertEqual(result.logits.shape       ,(self.batch_size, self.num_labels)				)




      def 		lowerCAmelCase__       (					self       ,lowerCamelCase_       ,lowerCamelCase_       ,lowerCamelCase_       ,lowerCamelCase_       ,lowerCamelCase_       ,lowerCamelCase_       ,lowerCamelCase_				)      ->      Dict:



         '''simple docstring'''



         UpperCAmelCase__				:					int 					=	self.num_choices
         UpperCAmelCase__				:					Optional[int] 					=	TFRoFormerForMultipleChoice(config=lowerCamelCase_				)
         UpperCAmelCase__				:					Tuple 					=	tf.tile(tf.expand_dims(lowerCamelCase_       ,1				)       ,(1, self.num_choices, 1)				)
         UpperCAmelCase__				:					Optional[Any] 					=	tf.tile(tf.expand_dims(lowerCamelCase_       ,1				)       ,(1, self.num_choices, 1)				)
         UpperCAmelCase__				:					Dict 					=	tf.tile(tf.expand_dims(lowerCamelCase_       ,1				)       ,(1, self.num_choices, 1)				)
         UpperCAmelCase__				:					Optional[int] 					=	{
             '''input_ids''': multiple_choice_inputs_ids,
             '''attention_mask''': multiple_choice_input_mask,
             '''token_type_ids''': multiple_choice_token_type_ids,
         }
         UpperCAmelCase__				:					str 					=	model(lowerCamelCase_				)
         self.parent.assertEqual(result.logits.shape       ,(self.batch_size, self.num_choices)				)




      def 		lowerCAmelCase__       (					self       ,lowerCamelCase_       ,lowerCamelCase_       ,lowerCamelCase_       ,lowerCamelCase_       ,lowerCamelCase_       ,lowerCamelCase_       ,lowerCamelCase_				)      ->      Any:



         '''simple docstring'''



         UpperCAmelCase__				:					Dict 					=	self.num_labels
         UpperCAmelCase__				:					Optional[Any] 					=	TFRoFormerForTokenClassification(config=lowerCamelCase_				)
         UpperCAmelCase__				:					Dict 					=	{
             '''input_ids''': input_ids,
             '''attention_mask''': input_mask,
             '''token_type_ids''': token_type_ids,
         }
         UpperCAmelCase__				:					Optional[int] 					=	model(lowerCamelCase_				)
         self.parent.assertEqual(result.logits.shape       ,(self.batch_size, self.seq_length, self.num_labels)				)




      def 		lowerCAmelCase__       (					self       ,lowerCamelCase_       ,lowerCamelCase_       ,lowerCamelCase_       ,lowerCamelCase_       ,lowerCamelCase_       ,lowerCamelCase_       ,lowerCamelCase_				)      ->      Optional[int]:



         '''simple docstring'''



         UpperCAmelCase__				:					Optional[Any] 					=	TFRoFormerForQuestionAnswering(config=lowerCamelCase_				)
         UpperCAmelCase__				:					Any 					=	{
             '''input_ids''': input_ids,
             '''attention_mask''': input_mask,
             '''token_type_ids''': token_type_ids,
         }

         UpperCAmelCase__				:					int 					=	model(lowerCamelCase_				)
         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 		lowerCAmelCase__       (					self				)      ->      Any:



         '''simple docstring'''



         UpperCAmelCase__				:					Optional[Any] 					=	self.prepare_config_and_inputs()
         (
             (
             UpperCAmelCase__
         )					,   (
             UpperCAmelCase__
         )					,   (
             UpperCAmelCase__
         )					,   (
             UpperCAmelCase__
         )					,   (
             UpperCAmelCase__
         )					,   (
             UpperCAmelCase__
         )					,   (
             UpperCAmelCase__
         )					,   
         )				:					List[Any] 					=	config_and_inputs
         UpperCAmelCase__				:					Optional[int] 					=	{'''input_ids''': input_ids, '''token_type_ids''': token_type_ids, '''attention_mask''': input_mask}
         return config, inputs_dict




@require_tf
class 					_lowercase						(   lowerCAmelCase		,lowerCAmelCase		,unittest.TestCase ):
      '''simple docstring'''


      UpperCAmelCase_   :   List[str]   				= (
          (
              TFRoFormerModel,
              TFRoFormerForCausalLM,
              TFRoFormerForMaskedLM,
              TFRoFormerForQuestionAnswering,
              TFRoFormerForSequenceClassification,
              TFRoFormerForTokenClassification,
              TFRoFormerForMultipleChoice,
          )
          if is_tf_available()
          else ()
      )
      UpperCAmelCase_   :   int   				= (
          {
              '''feature-extraction''': TFRoFormerModel,
              '''fill-mask''': TFRoFormerForMaskedLM,
              '''question-answering''': TFRoFormerForQuestionAnswering,
              '''text-classification''': TFRoFormerForSequenceClassification,
              '''text-generation''': TFRoFormerForCausalLM,
              '''token-classification''': TFRoFormerForTokenClassification,
              '''zero-shot''': TFRoFormerForSequenceClassification,
          }
          if is_tf_available()
          else {}
      )

      UpperCAmelCase_   :   Optional[int]   				= False
      UpperCAmelCase_   :   Optional[int]   				= False




      def 		lowerCAmelCase__       (					self       ,lowerCamelCase_       ,lowerCamelCase_       ,lowerCamelCase_       ,lowerCamelCase_       ,lowerCamelCase_				)      ->      Any:



         '''simple docstring'''



         if pipeline_test_casse_name == "TextGenerationPipelineTests":
            return True

         return False




      def 		lowerCAmelCase__       (					self				)      ->      Union[str, Any]:



         '''simple docstring'''



         UpperCAmelCase__				:					List[Any] 					=	TFRoFormerModelTester(self				)
         UpperCAmelCase__				:					int 					=	ConfigTester(self       ,config_class=lowerCamelCase_       ,hidden_size=37				)




      def 		lowerCAmelCase__       (					self				)      ->      Dict:



         '''simple docstring'''



         self.config_tester.run_common_tests()




      def 		lowerCAmelCase__       (					self				)      ->      List[Any]:



         '''simple docstring'''



         UpperCAmelCase__				:					Any 					=	self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_model(*lowerCamelCase_				)




      def 		lowerCAmelCase__       (					self				)      ->      Optional[Any]:



         '''simple docstring'''



         UpperCAmelCase__				:					Tuple 					=	self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_for_masked_lm(*lowerCamelCase_				)




      def 		lowerCAmelCase__       (					self				)      ->      List[Any]:



         '''simple docstring'''



         UpperCAmelCase__				:					str 					=	self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_lm_head(*lowerCamelCase_				)




      def 		lowerCAmelCase__       (					self				)      ->      Optional[Any]:



         '''simple docstring'''



         UpperCAmelCase__				:					Optional[int] 					=	self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_for_multiple_choice(*lowerCamelCase_				)




      def 		lowerCAmelCase__       (					self				)      ->      Any:



         '''simple docstring'''



         UpperCAmelCase__				:					List[str] 					=	self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_for_question_answering(*lowerCamelCase_				)




      def 		lowerCAmelCase__       (					self				)      ->      str:



         '''simple docstring'''



         UpperCAmelCase__				:					Optional[int] 					=	self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_for_sequence_classification(*lowerCamelCase_				)




      def 		lowerCAmelCase__       (					self				)      ->      List[Any]:



         '''simple docstring'''



         UpperCAmelCase__				:					str 					=	self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_for_token_classification(*lowerCamelCase_				)




      @slow
      def 		lowerCAmelCase__       (					self				)      ->      Union[str, Any]:



         '''simple docstring'''



         UpperCAmelCase__				:					List[str] 					=	TFRoFormerModel.from_pretrained('''junnyu/roformer_chinese_base'''				)
         self.assertIsNotNone(lowerCamelCase_				)




@require_tf
class 					_lowercase						(   unittest.TestCase ):
      '''simple docstring'''


      @slow
      def 		lowerCAmelCase__       (					self				)      ->      Dict:



         '''simple docstring'''



         UpperCAmelCase__				:					List[Any] 					=	TFRoFormerForMaskedLM.from_pretrained('''junnyu/roformer_chinese_base'''				)
         UpperCAmelCase__				:					Dict 					=	tf.constant([[0, 1, 2, 3, 4, 5]]				)
         UpperCAmelCase__				:					Union[str, Any] 					=	model(lowerCamelCase_				)[0]

         # TODO Replace vocab size
         UpperCAmelCase__				:					List[str] 					=	50000

         UpperCAmelCase__				:					int 					=	[1, 6, vocab_size]
         self.assertEqual(output.shape       ,lowerCamelCase_				)

         print(output[:, :3, :3]				)

         # TODO Replace values below with what was printed above.
         UpperCAmelCase__				:					Tuple 					=	tf.constant(
             [
                 [
                     [-0.1205_3341, -1.026_4901, 0.2922_1946],
                     [-1.513_3783, 0.19_7433, 0.1519_0607],
                     [-5.013_5403, -3.90_0256, -0.8403_8764],
                 ]
             ]				)
         tf.debugging.assert_near(output[:, :3, :3]       ,lowerCamelCase_       ,atol=1e-4				)




@require_tf
class 					_lowercase						(   unittest.TestCase ):
      '''simple docstring'''


      UpperCAmelCase_   :   int   				= 1E-4




      def 		lowerCAmelCase__       (					self				)      ->      Optional[Any]:



         '''simple docstring'''



         UpperCAmelCase__				:					Union[str, Any] 					=	tf.constant([[4, 10]]				)
         UpperCAmelCase__				:					List[str] 					=	TFRoFormerSinusoidalPositionalEmbedding(num_positions=6       ,embedding_dim=6				)

         UpperCAmelCase__				:					Optional[Any] 					=	emba(input_ids.shape				)
         UpperCAmelCase__				:					List[str] 					=	tf.constant(
             [[0.0000, 0.0000, 0.0000, 1.0000, 1.0000, 1.0000], [0.8415, 0.0464, 0.0022, 0.5403, 0.9989, 1.0000]]				)

         tf.debugging.assert_near(lowerCamelCase_       ,lowerCamelCase_       ,atol=self.tolerance				)




      def 		lowerCAmelCase__       (					self				)      ->      List[str]:



         '''simple docstring'''



         UpperCAmelCase__				:					Any 					=	tf.constant(
             [
                 [0.0000, 0.0000, 0.0000, 0.0000, 0.0000],
                 [0.8415, 0.8219, 0.8020, 0.7819, 0.7617],
                 [0.9093, 0.9364, 0.9581, 0.9749, 0.9870],
             ]				)
         UpperCAmelCase__				:					Dict 					=	TFRoFormerSinusoidalPositionalEmbedding(num_positions=512       ,embedding_dim=512				)
         emba([2, 16, 512]				)
         UpperCAmelCase__				:					Optional[int] 					=	emba.weight[:3, :5]

         tf.debugging.assert_near(lowerCamelCase_       ,lowerCamelCase_       ,atol=self.tolerance				)




@require_tf
class 					_lowercase						(   unittest.TestCase ):
      '''simple docstring'''


      UpperCAmelCase_   :   Optional[int]   				= 1E-4




      def 		lowerCAmelCase__       (					self				)      ->      List[str]:



         '''simple docstring'''



         UpperCAmelCase__				:					Optional[int] 					=	tf.reshape(tf.range(2 * 12 * 16 * 64       ,dtype=tf.floataa				)       ,shape=(2, 12, 16, 64)				) / 100

         UpperCAmelCase__				:					int 					=	-tf.reshape(tf.range(2 * 12 * 16 * 64       ,dtype=tf.floataa				)       ,shape=(2, 12, 16, 64)				) / 100

         UpperCAmelCase__				:					Optional[Any] 					=	TFRoFormerSinusoidalPositionalEmbedding(num_positions=32       ,embedding_dim=64				)
         UpperCAmelCase__				:					int 					=	embed_positions([2, 16, 768]				)[None, None, :, :]

         UpperCAmelCase__					,   UpperCAmelCase__				:					Dict 					=	TFRoFormerSelfAttention.apply_rotary_position_embeddings(
             lowerCamelCase_       ,lowerCamelCase_       ,lowerCamelCase_				)

         UpperCAmelCase__				:					Any 					=	tf.constant(
             [
                 [0.0000, 0.0100, 0.0200, 0.0300, 0.0400, 0.0500, 0.0600, 0.0700],
                 [-0.2012, 0.8897, 0.0263, 0.9401, 0.2074, 0.9463, 0.3481, 0.9343],
                 [-1.7057, 0.6271, -1.2145, 1.3897, -0.6303, 1.7647, -0.1173, 1.8985],
                 [-2.1731, -1.6397, -2.7358, 0.2854, -2.1840, 1.7183, -1.3018, 2.4871],
                 [0.2717, -3.6173, -2.9206, -2.1988, -3.6638, 0.3858, -2.9155, 2.2980],
                 [3.9859, -2.1580, -0.7984, -4.4904, -4.1181, -2.0252, -4.4782, 1.1253],
             ]				)
         UpperCAmelCase__				:					List[str] 					=	tf.constant(
             [
                 [0.0000, -0.0100, -0.0200, -0.0300, -0.0400, -0.0500, -0.0600, -0.0700],
                 [0.2012, -0.8897, -0.0263, -0.9401, -0.2074, -0.9463, -0.3481, -0.9343],
                 [1.7057, -0.6271, 1.2145, -1.3897, 0.6303, -1.7647, 0.1173, -1.8985],
                 [2.1731, 1.6397, 2.7358, -0.2854, 2.1840, -1.7183, 1.3018, -2.4871],
                 [-0.2717, 3.6173, 2.9206, 2.1988, 3.6638, -0.3858, 2.9155, -2.2980],
                 [-3.9859, 2.1580, 0.7984, 4.4904, 4.1181, 2.0252, 4.4782, -1.1253],
             ]				)

         tf.debugging.assert_near(query_layer[0, 0, :6, :8]       ,lowerCamelCase_       ,atol=self.tolerance				)
         tf.debugging.assert_near(key_layer[0, 0, :6, :8]       ,lowerCamelCase_       ,atol=self.tolerance				)




