
import shutil
import tempfile
import unittest

from transformers import (
    SPIECE_UNDERLINE,
    AddedToken,
    BatchEncoding,
    NllbTokenizer,
    NllbTokenizerFast,
    is_torch_available,
)
from transformers.testing_utils import (
    get_tests_dir,
    nested_simplify,
    require_sentencepiece,
    require_tokenizers,
    require_torch,
)

from ...test_tokenization_common import TokenizerTesterMixin


SCREAMING_SNAKE_CASE__  :     Tuple   				=       get_tests_dir("fixtures/test_sentencepiece.model")


if is_torch_available():
					from transformers.models.mam_aaa.modeling_mam_aaa import shift_tokens_right

SCREAMING_SNAKE_CASE__  :     Tuple   				=       256_047
SCREAMING_SNAKE_CASE__  :     Optional[int]   				=       256_145

@require_sentencepiece
@require_tokenizers
class   lowerCAmelCase__	(      lowercase__    ,      unittest.TestCase     ):
		a__			:		Union[str, Any]     =						NllbTokenizer
		a__			:		List[Any]     =						NllbTokenizerFast
		a__			:		Union[str, Any]     =						True
		a__			:		Any     =						True
		a__			:		Union[str, Any]     =						{}






		def 					__A			(						self						:				Any    )	->				Optional[int]:
						super().setUp()

						# We have a SentencePiece fixture for testing
						__lowerCamelCase          =      NllbTokenizer(SCREAMING_SNAKE_CASE_				,     keep_accents=SCREAMING_SNAKE_CASE_    )
						tokenizer.save_pretrained(self.tmpdirname    )






		def 					__A			(						self						:				List[Any]    )	->				Tuple:
						__lowerCamelCase          =      NllbTokenizer(SCREAMING_SNAKE_CASE_				,     keep_accents=SCREAMING_SNAKE_CASE_    )

						__lowerCamelCase          =      tokenizer.tokenize('''This is a test'''    )
						self.assertListEqual(SCREAMING_SNAKE_CASE_				,     ['''▁This''', '''▁is''', '''▁a''', '''▁t''', '''est''']    )

						self.assertListEqual(
						    tokenizer.convert_tokens_to_ids(SCREAMING_SNAKE_CASE_    )				,     [value + tokenizer.fairseq_offset for value in [2_85, 46, 10, 1_70, 3_82]]				,     )

						__lowerCamelCase          =      tokenizer.tokenize('''I was born in 92000, and this is falsé.'''    )
						self.assertListEqual(
						    SCREAMING_SNAKE_CASE_				,     [
						        SPIECE_UNDERLINE + '''I''',
						        SPIECE_UNDERLINE + '''was''',
						        SPIECE_UNDERLINE + '''b''',
						        '''or''',
						        '''n''',
						        SPIECE_UNDERLINE + '''in''',
						        SPIECE_UNDERLINE + '''''',
						        '''9''',
						        '''2''',
						        '''0''',
						        '''0''',
						        '''0''',
						        ''',''',
						        SPIECE_UNDERLINE + '''and''',
						        SPIECE_UNDERLINE + '''this''',
						        SPIECE_UNDERLINE + '''is''',
						        SPIECE_UNDERLINE + '''f''',
						        '''al''',
						        '''s''',
						        '''é''',
						        '''.''',
						    ]				,     )
						__lowerCamelCase          =      tokenizer.convert_tokens_to_ids(SCREAMING_SNAKE_CASE_    )
						self.assertListEqual(
						    SCREAMING_SNAKE_CASE_				,     [
						        value + tokenizer.fairseq_offset
						        for value in [8, 21, 84, 55, 24, 19, 7, 2, 6_02, 3_47, 3_47, 3_47, 3, 12, 66, 46, 72, 80, 6, 2, 4]
						    ]				,     )

						__lowerCamelCase          =      tokenizer.convert_ids_to_tokens(SCREAMING_SNAKE_CASE_    )
						self.assertListEqual(
						    SCREAMING_SNAKE_CASE_				,     [
						        SPIECE_UNDERLINE + '''I''',
						        SPIECE_UNDERLINE + '''was''',
						        SPIECE_UNDERLINE + '''b''',
						        '''or''',
						        '''n''',
						        SPIECE_UNDERLINE + '''in''',
						        SPIECE_UNDERLINE + '''''',
						        '''<unk>''',
						        '''2''',
						        '''0''',
						        '''0''',
						        '''0''',
						        ''',''',
						        SPIECE_UNDERLINE + '''and''',
						        SPIECE_UNDERLINE + '''this''',
						        SPIECE_UNDERLINE + '''is''',
						        SPIECE_UNDERLINE + '''f''',
						        '''al''',
						        '''s''',
						        '''<unk>''',
						        '''.''',
						    ]				,     )






		def 					__A			(						self						:				Tuple    )	->				Dict:
						__lowerCamelCase          =      (self.rust_tokenizer_class, '''hf-internal-testing/tiny-random-nllb''', {})
						for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
										with self.subTest(f'''{tokenizer.__class__.__name__} ({pretrained_name})'''    ):
														__lowerCamelCase          =      self.rust_tokenizer_class.from_pretrained(SCREAMING_SNAKE_CASE_				,     **SCREAMING_SNAKE_CASE_    )
														__lowerCamelCase          =      self.tokenizer_class.from_pretrained(SCREAMING_SNAKE_CASE_				,     **SCREAMING_SNAKE_CASE_    )

														__lowerCamelCase          =      tempfile.mkdtemp()

														__lowerCamelCase          =      tokenizer_r.save_pretrained(SCREAMING_SNAKE_CASE_    )
														__lowerCamelCase          =      tokenizer_p.save_pretrained(SCREAMING_SNAKE_CASE_    )

														# Checks it save with the same files + the tokenizer.json file for the fast one
														self.assertTrue(any('''tokenizer.json''' in f for f in tokenizer_r_files    )    )
														__lowerCamelCase          =      tuple(f for f in tokenizer_r_files if '''tokenizer.json''' not in f    )
														self.assertSequenceEqual(SCREAMING_SNAKE_CASE_				,     SCREAMING_SNAKE_CASE_    )

														# Checks everything loads correctly in the same way
														__lowerCamelCase          =      tokenizer_r.from_pretrained(SCREAMING_SNAKE_CASE_    )
														__lowerCamelCase          =      tokenizer_p.from_pretrained(SCREAMING_SNAKE_CASE_    )

														# Check special tokens are set accordingly on Rust and Python
														for key in tokenizer_pp.special_tokens_map:
																		self.assertTrue(hasattr(SCREAMING_SNAKE_CASE_				,     SCREAMING_SNAKE_CASE_    )    )

														shutil.rmtree(SCREAMING_SNAKE_CASE_    )

														# Save tokenizer rust, legacy_format=True
														__lowerCamelCase          =      tempfile.mkdtemp()

														__lowerCamelCase          =      tokenizer_r.save_pretrained(SCREAMING_SNAKE_CASE_				,     legacy_format=SCREAMING_SNAKE_CASE_    )
														__lowerCamelCase          =      tokenizer_p.save_pretrained(SCREAMING_SNAKE_CASE_    )

														# Checks it save with the same files
														self.assertSequenceEqual(SCREAMING_SNAKE_CASE_				,     SCREAMING_SNAKE_CASE_    )

														# Checks everything loads correctly in the same way
														__lowerCamelCase          =      tokenizer_r.from_pretrained(SCREAMING_SNAKE_CASE_    )
														__lowerCamelCase          =      tokenizer_p.from_pretrained(SCREAMING_SNAKE_CASE_    )

														# Check special tokens are set accordingly on Rust and Python
														for key in tokenizer_pp.special_tokens_map:
																		self.assertTrue(hasattr(SCREAMING_SNAKE_CASE_				,     SCREAMING_SNAKE_CASE_    )    )

														shutil.rmtree(SCREAMING_SNAKE_CASE_    )

														# Save tokenizer rust, legacy_format=False
														__lowerCamelCase          =      tempfile.mkdtemp()

														__lowerCamelCase          =      tokenizer_r.save_pretrained(SCREAMING_SNAKE_CASE_				,     legacy_format=SCREAMING_SNAKE_CASE_    )
														__lowerCamelCase          =      tokenizer_p.save_pretrained(SCREAMING_SNAKE_CASE_    )

														# Checks it saved the tokenizer.json file
														self.assertTrue(any('''tokenizer.json''' in f for f in tokenizer_r_files    )    )

														# Checks everything loads correctly in the same way
														__lowerCamelCase          =      tokenizer_r.from_pretrained(SCREAMING_SNAKE_CASE_    )
														__lowerCamelCase          =      tokenizer_p.from_pretrained(SCREAMING_SNAKE_CASE_    )

														# Check special tokens are set accordingly on Rust and Python
														for key in tokenizer_pp.special_tokens_map:
																		self.assertTrue(hasattr(SCREAMING_SNAKE_CASE_				,     SCREAMING_SNAKE_CASE_    )    )

														shutil.rmtree(SCREAMING_SNAKE_CASE_    )






		@require_torch
		def 					__A			(						self						:				List[str]    )	->				List[Any]:


						if not self.test_seqaseq:
										return

						__lowerCamelCase          =      self.get_tokenizers()
						for tokenizer in tokenizers:
										with self.subTest(f'''{tokenizer.__class__.__name__}'''    ):
														# Longer text that will definitely require truncation.
														__lowerCamelCase          =      [
														    ''' UN Chief Says There Is No Military Solution in Syria''',
														    ''' Secretary-General Ban Ki-moon says his response to Russia\'s stepped up military support for'''
														    ''' Syria is that \'there is no military solution\' to the nearly five-year conflict and more weapons'''
														    ''' will only worsen the violence and misery for millions of people.''',
														]
														__lowerCamelCase          =      [
														    '''Şeful ONU declară că nu există o soluţie militară în Siria''',
														    '''Secretarul General Ban Ki-moon declară că răspunsul său la intensificarea sprijinului militar al'''
														    ''' Rusiei pentru Siria este că "nu există o soluţie militară" la conflictul de aproape cinci ani şi'''
														    ''' că noi arme nu vor face decât să înrăutăţească violenţele şi mizeria pentru milioane de oameni.''',
														]
														try:
																		__lowerCamelCase          =      tokenizer.prepare_seqaseq_batch(
																		    src_texts=SCREAMING_SNAKE_CASE_				,     tgt_texts=SCREAMING_SNAKE_CASE_				,     max_length=3				,     max_target_length=10				,     return_tensors='''pt'''				,     src_lang='''eng_Latn'''				,     tgt_lang='''ron_Latn'''				,     )
														except NotImplementedError:
																		return
														self.assertEqual(batch.input_ids.shape[1]				,     3    )
														self.assertEqual(batch.labels.shape[1]				,     10    )
														# max_target_length will default to max_length if not specified
														__lowerCamelCase          =      tokenizer.prepare_seqaseq_batch(
														    SCREAMING_SNAKE_CASE_				,     tgt_texts=SCREAMING_SNAKE_CASE_				,     max_length=3				,     return_tensors='''pt'''    )
														self.assertEqual(batch.input_ids.shape[1]				,     3    )
														self.assertEqual(batch.labels.shape[1]				,     3    )

														__lowerCamelCase          =      tokenizer.prepare_seqaseq_batch(
														    src_texts=SCREAMING_SNAKE_CASE_				,     max_length=3				,     max_target_length=10				,     return_tensors='''pt'''    )
														self.assertEqual(batch_encoder_only.input_ids.shape[1]				,     3    )
														self.assertEqual(batch_encoder_only.attention_mask.shape[1]				,     3    )
														self.assertNotIn('''decoder_input_ids'''				,     SCREAMING_SNAKE_CASE_    )






		@unittest.skip('''Unfortunately way too slow to build a BPE with SentencePiece.'''    )
		def 					__A			(						self						:				List[Any]    )	->				Union[str, Any]:
						pass







		def 					__A			(						self						:				Optional[Any]    )	->				List[str]:


						for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
										with self.subTest(f'''{tokenizer.__class__.__name__} ({pretrained_name})'''    ):
														__lowerCamelCase          =      [AddedToken('''<special>'''				,     lstrip=SCREAMING_SNAKE_CASE_    )]

														__lowerCamelCase          =      self.rust_tokenizer_class.from_pretrained(
														    SCREAMING_SNAKE_CASE_				,     additional_special_tokens=SCREAMING_SNAKE_CASE_				,     **SCREAMING_SNAKE_CASE_    )
														__lowerCamelCase          =      tokenizer_r.encode('''Hey this is a <special> token'''    )

														__lowerCamelCase          =      tokenizer_r.encode('''<special>'''				,     add_special_tokens=SCREAMING_SNAKE_CASE_    )[0]

														self.assertTrue(special_token_id in r_output    )

														if self.test_slow_tokenizer:
																		__lowerCamelCase          =      self.rust_tokenizer_class.from_pretrained(
																		    SCREAMING_SNAKE_CASE_				,     additional_special_tokens=SCREAMING_SNAKE_CASE_				,     **SCREAMING_SNAKE_CASE_				,     )
																		__lowerCamelCase          =      self.tokenizer_class.from_pretrained(
																		    SCREAMING_SNAKE_CASE_				,     additional_special_tokens=SCREAMING_SNAKE_CASE_				,     **SCREAMING_SNAKE_CASE_    )

																		__lowerCamelCase          =      tokenizer_p.encode('''Hey this is a <special> token'''    )

																		__lowerCamelCase          =      tokenizer_cr.encode('''Hey this is a <special> token'''    )

																		self.assertEqual(SCREAMING_SNAKE_CASE_				,     SCREAMING_SNAKE_CASE_    )
																		self.assertEqual(SCREAMING_SNAKE_CASE_				,     SCREAMING_SNAKE_CASE_    )
																		self.assertTrue(special_token_id in p_output    )
																		self.assertTrue(special_token_id in cr_output    )





@require_torch
@require_sentencepiece
@require_tokenizers
class   lowerCAmelCase__	(      unittest.TestCase     ):
		a__			:		Tuple     =						"""facebook/nllb-200-distilled-600M"""
		a__			:		Union[str, Any]     =						[
		    """ UN Chief Says There Is No Military Solution in Syria""",
		    """ Secretary-General Ban Ki-moon says his response to Russia\'s stepped up military support for Syria is that \"there is no military solution\" to the nearly five-year conflict and more weapons will only worsen the violence and misery for millions of people.""",
		]
		a__			:		Any     =						[
		    """Şeful ONU declară că nu există o soluţie militară în Siria""",
		    """Secretarul General Ban Ki-moon declară că răspunsul său la intensificarea sprijinului militar al Rusiei"""
		    """ pentru Siria este că \"nu există o soluţie militară\" la conflictul de aproape cinci ani şi că noi arme nu vor"""
		    """ face decât să înrăutăţească violenţele şi mizeria pentru milioane de oameni.""",
		]
		a__			:		str     =						[
		    256_047,
		    16_297,
		    134_408,
		    8_165,
		    248_066,
		    14_734,
		    950,
		    1_135,
		    105_721,
		    3_573,
		    83,
		    27_352,
		    108,
		    49_486,
		    2,
		]






		@classmethod
		def 					__A			(						cls						:				Optional[Any]    )	->				str:
						__lowerCamelCase          =      NllbTokenizer.from_pretrained(
						    cls.checkpoint_name				,     src_lang='''eng_Latn'''				,     tgt_lang='''ron_Latn'''    )
						__lowerCamelCase          =      1
						return cls






		def 					__A			(						self						:				Union[str, Any]    )	->				Tuple:
						self.assertEqual(self.tokenizer.fairseq_tokens_to_ids['''ace_Arab''']				,     25_60_01    )
						self.assertEqual(self.tokenizer.fairseq_tokens_to_ids['''ace_Latn''']				,     25_60_02    )
						self.assertEqual(self.tokenizer.fairseq_tokens_to_ids['''fra_Latn''']				,     25_60_57    )






		def 					__A			(						self						:				List[Any]    )	->				Optional[Any]:
						__lowerCamelCase          =      self.tokenizer.batch_encode_plus(self.src_text    ).input_ids[0]
						self.assertListEqual(self.expected_src_tokens				,     SCREAMING_SNAKE_CASE_    )






		def 					__A			(						self						:				List[str]    )	->				Dict:
						self.assertIn(SCREAMING_SNAKE_CASE_				,     self.tokenizer.all_special_ids    )
						# fmt: off
						__lowerCamelCase          =      [RO_CODE, 42_54, 9_80_68, 11_29_23, 3_90_72, 39_09, 7_13, 10_27_67, 26, 1_73_14, 3_56_42, 1_46_83, 3_31_18, 20_22, 6_69_87, 2, 25_60_47]
						# fmt: on

						__lowerCamelCase          =      self.tokenizer.decode(SCREAMING_SNAKE_CASE_				,     skip_special_tokens=SCREAMING_SNAKE_CASE_    )
						__lowerCamelCase          =      self.tokenizer.decode(generated_ids[1:]				,     skip_special_tokens=SCREAMING_SNAKE_CASE_    )
						self.assertEqual(SCREAMING_SNAKE_CASE_				,     SCREAMING_SNAKE_CASE_    )
						self.assertNotIn(self.tokenizer.eos_token				,     SCREAMING_SNAKE_CASE_    )






		def 					__A			(						self						:				str    )	->				Tuple:
						__lowerCamelCase          =      ['''this is gunna be a long sentence ''' * 20]
						assert isinstance(src_text[0]				,     SCREAMING_SNAKE_CASE_    )
						__lowerCamelCase          =      10
						__lowerCamelCase          =      self.tokenizer(SCREAMING_SNAKE_CASE_				,     max_length=SCREAMING_SNAKE_CASE_				,     truncation=SCREAMING_SNAKE_CASE_    ).input_ids[0]
						self.assertEqual(ids[-1]				,     2    )
						self.assertEqual(ids[0]				,     SCREAMING_SNAKE_CASE_    )
						self.assertEqual(len(SCREAMING_SNAKE_CASE_    )				,     SCREAMING_SNAKE_CASE_    )






		def 					__A			(						self						:				List[Any]    )	->				str:
						self.assertListEqual(self.tokenizer.convert_tokens_to_ids(['''<mask>''', '''ar_AR''']    )				,     [25_62_03, 3]    )






		def 					__A			(						self						:				str    )	->				str:
						__lowerCamelCase          =      tempfile.mkdtemp()
						__lowerCamelCase          =      self.tokenizer.fairseq_tokens_to_ids
						self.tokenizer.save_pretrained(SCREAMING_SNAKE_CASE_    )
						__lowerCamelCase          =      NllbTokenizer.from_pretrained(SCREAMING_SNAKE_CASE_    )
						self.assertDictEqual(new_tok.fairseq_tokens_to_ids				,     SCREAMING_SNAKE_CASE_    )






		@require_torch
		def 					__A			(						self						:				Tuple    )	->				int:
						__lowerCamelCase          =      self.tokenizer(
						    self.src_text				,     text_target=self.tgt_text				,     padding=SCREAMING_SNAKE_CASE_				,     truncation=SCREAMING_SNAKE_CASE_				,     max_length=len(self.expected_src_tokens    )				,     return_tensors='''pt'''				,     )
						__lowerCamelCase          =      shift_tokens_right(
						    batch['''labels''']				,     self.tokenizer.pad_token_id				,     self.tokenizer.lang_code_to_id['''ron_Latn''']    )

						self.assertIsInstance(SCREAMING_SNAKE_CASE_				,     SCREAMING_SNAKE_CASE_    )

						self.assertEqual((2, 15)				,     batch.input_ids.shape    )
						self.assertEqual((2, 15)				,     batch.attention_mask.shape    )
						__lowerCamelCase          =      batch.input_ids.tolist()[0]
						self.assertListEqual(self.expected_src_tokens				,     SCREAMING_SNAKE_CASE_    )
						self.assertEqual(SCREAMING_SNAKE_CASE_				,     batch.decoder_input_ids[0, 0]    )  # EOS
						# Test that special tokens are reset
						self.assertEqual(self.tokenizer.prefix_tokens				,     [EN_CODE]    )
						self.assertEqual(self.tokenizer.suffix_tokens				,     [self.tokenizer.eos_token_id]    )






		def 					__A			(						self						:				Any    )	->				Union[str, Any]:
						__lowerCamelCase          =      self.tokenizer(self.src_text				,     padding=SCREAMING_SNAKE_CASE_				,     truncation=SCREAMING_SNAKE_CASE_				,     max_length=3				,     return_tensors='''pt'''    )
						__lowerCamelCase          =      self.tokenizer(
						    text_target=self.tgt_text				,     padding=SCREAMING_SNAKE_CASE_				,     truncation=SCREAMING_SNAKE_CASE_				,     max_length=10				,     return_tensors='''pt'''    )
						__lowerCamelCase          =      targets['''input_ids''']
						__lowerCamelCase          =      shift_tokens_right(
						    SCREAMING_SNAKE_CASE_				,     self.tokenizer.pad_token_id				,     decoder_start_token_id=self.tokenizer.lang_code_to_id[self.tokenizer.tgt_lang]				,     )

						self.assertEqual(batch.input_ids.shape[1]				,     3    )
						self.assertEqual(batch.decoder_input_ids.shape[1]				,     10    )






		@require_torch
		def 					__A			(						self						:				Tuple    )	->				Tuple:
						__lowerCamelCase          =      self.tokenizer._build_translation_inputs(
						    '''A test'''				,     return_tensors='''pt'''				,     src_lang='''eng_Latn'''				,     tgt_lang='''fra_Latn'''    )

						self.assertEqual(
						    nested_simplify(SCREAMING_SNAKE_CASE_    )				,     {
						        # A, test, EOS, en_XX
						        '''input_ids''': [[25_60_47, 70, 73_56, 2]],
						        '''attention_mask''': [[1, 1, 1, 1]],
						        # ar_AR
						        '''forced_bos_token_id''': 25_60_57,
						    }				,     )







		@require_torch
		def 					__A			(						self						:				Tuple    )	->				List[str]:
						__lowerCamelCase          =      True
						__lowerCamelCase          =      self.tokenizer(
						    '''UN Chief says there is no military solution in Syria'''				,     src_lang='''eng_Latn'''				,     tgt_lang='''fra_Latn'''    )
						self.assertEqual(
						    inputs.input_ids				,     [1_62_97, 13_44_08, 2_56_53, 63_70, 2_48, 2_54, 10_39_29, 9_49_95, 1_08, 4_94_86, 2, 25_60_47]    )

						__lowerCamelCase          =      False
						__lowerCamelCase          =      self.tokenizer(
						    '''UN Chief says there is no military solution in Syria'''				,     src_lang='''eng_Latn'''				,     tgt_lang='''fra_Latn'''    )
						self.assertEqual(
						    inputs.input_ids				,     [25_60_47, 1_62_97, 13_44_08, 2_56_53, 63_70, 2_48, 2_54, 10_39_29, 9_49_95, 1_08, 4_94_86, 2]    )





"""simple docstring"""






from ..utils import DummyObject, requires_backends



class 			lowercase					( metaclass=lowercase__		):
			lowercase        =     ['''flax''', '''transformers''']






			def __init__(self  :	List[Any]      ,*SCREAMING_SNAKE_CASE_  :	Union[str, Any]      ,**SCREAMING_SNAKE_CASE_  :	Union[str, Any]			)       ->	str:





				"""simple docstring"""


				requires_backends(self      ,['''flax''', '''transformers''']			)






			@classmethod
			def 					UpperCAmelCase							(cls  :	List[Any]      ,*SCREAMING_SNAKE_CASE_  :	List[Any]      ,**SCREAMING_SNAKE_CASE_  :	int			)       ->	Optional[int]:





				"""simple docstring"""


				requires_backends(cls      ,['''flax''', '''transformers''']			)






			@classmethod
			def 					UpperCAmelCase							(cls  :	List[Any]      ,*SCREAMING_SNAKE_CASE_  :	str      ,**SCREAMING_SNAKE_CASE_  :	Union[str, Any]			)       ->	Union[str, Any]:





				"""simple docstring"""


				requires_backends(cls      ,['''flax''', '''transformers''']			)





class 			lowercase					( metaclass=lowercase__		):
			lowercase        =     ['''flax''', '''transformers''']






			def __init__(self  :	int      ,*SCREAMING_SNAKE_CASE_  :	List[Any]      ,**SCREAMING_SNAKE_CASE_  :	Any			)       ->	Union[str, Any]:





				"""simple docstring"""


				requires_backends(self      ,['''flax''', '''transformers''']			)






			@classmethod
			def 					UpperCAmelCase							(cls  :	int      ,*SCREAMING_SNAKE_CASE_  :	str      ,**SCREAMING_SNAKE_CASE_  :	int			)       ->	Optional[Any]:





				"""simple docstring"""


				requires_backends(cls      ,['''flax''', '''transformers''']			)






			@classmethod
			def 					UpperCAmelCase							(cls  :	List[str]      ,*SCREAMING_SNAKE_CASE_  :	List[str]      ,**SCREAMING_SNAKE_CASE_  :	Optional[Any]			)       ->	Dict:





				"""simple docstring"""


				requires_backends(cls      ,['''flax''', '''transformers''']			)





class 			lowercase					( metaclass=lowercase__		):
			lowercase        =     ['''flax''', '''transformers''']






			def __init__(self  :	Tuple      ,*SCREAMING_SNAKE_CASE_  :	Optional[int]      ,**SCREAMING_SNAKE_CASE_  :	Dict			)       ->	List[str]:





				"""simple docstring"""


				requires_backends(self      ,['''flax''', '''transformers''']			)






			@classmethod
			def 					UpperCAmelCase							(cls  :	Tuple      ,*SCREAMING_SNAKE_CASE_  :	Dict      ,**SCREAMING_SNAKE_CASE_  :	Optional[Any]			)       ->	List[Any]:





				"""simple docstring"""


				requires_backends(cls      ,['''flax''', '''transformers''']			)






			@classmethod
			def 					UpperCAmelCase							(cls  :	Tuple      ,*SCREAMING_SNAKE_CASE_  :	Tuple      ,**SCREAMING_SNAKE_CASE_  :	Tuple			)       ->	Union[str, Any]:





				"""simple docstring"""


				requires_backends(cls      ,['''flax''', '''transformers''']			)





class 			lowercase					( metaclass=lowercase__		):
			lowercase        =     ['''flax''', '''transformers''']






			def __init__(self  :	Optional[Any]      ,*SCREAMING_SNAKE_CASE_  :	Any      ,**SCREAMING_SNAKE_CASE_  :	str			)       ->	Union[str, Any]:





				"""simple docstring"""


				requires_backends(self      ,['''flax''', '''transformers''']			)






			@classmethod
			def 					UpperCAmelCase							(cls  :	List[Any]      ,*SCREAMING_SNAKE_CASE_  :	Optional[Any]      ,**SCREAMING_SNAKE_CASE_  :	Optional[int]			)       ->	Union[str, Any]:





				"""simple docstring"""


				requires_backends(cls      ,['''flax''', '''transformers''']			)






			@classmethod
			def 					UpperCAmelCase							(cls  :	List[Any]      ,*SCREAMING_SNAKE_CASE_  :	List[Any]      ,**SCREAMING_SNAKE_CASE_  :	List[Any]			)       ->	Optional[Any]:





				"""simple docstring"""


				requires_backends(cls      ,['''flax''', '''transformers''']			)


