



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


__UpperCAmelCase			  =			get_tests_dir('''fixtures/test_sentencepiece.model''')


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

__UpperCAmelCase			  =			256_047
__UpperCAmelCase			  =			256_145



@require_sentencepiece
@require_tokenizers
class 							lowerCAmelCase_						(    a__			,       unittest.TestCase				):
       UpperCAmelCase__							:   List[str]  	=    NllbTokenizer
       UpperCAmelCase__							:   List[str]  	=    NllbTokenizerFast
       UpperCAmelCase__							:   Any  	=    True
       UpperCAmelCase__							:   Optional[Any]  	=    True
       UpperCAmelCase__							:   Union[str, Any]  	=    {}
       def    snake_case_			(     self			)	->						Union[str, Any]:
          super().setUp()

          # We have a SentencePiece fixture for testing
          UpperCamelCase       :    str		      =      NllbTokenizer(SCREAMING_SNAKE_CASE_,     keep_accents=SCREAMING_SNAKE_CASE_			)
          tokenizer.save_pretrained(self.tmpdirname			)
       def    snake_case_			(     self			)	->						int:
          UpperCamelCase       :    int		      =      NllbTokenizer(SCREAMING_SNAKE_CASE_,     keep_accents=SCREAMING_SNAKE_CASE_			)

          UpperCamelCase       :    List[Any]		      =      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 [285, 46, 10, 170, 382]],     )

          UpperCamelCase       :    Any		      =      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',
                  'é',
                  '.',
              ],     )
          UpperCamelCase       :    Optional[int]		      =      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, 602, 347, 347, 347, 3, 12, 66, 46, 72, 80, 6, 2, 4]
              ],     )

          UpperCamelCase       :    int		      =      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    snake_case_			(     self			)	->						Dict:
          UpperCamelCase       :    Tuple		      =      (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})"""			):
                UpperCamelCase       :    Any		      =      self.rust_tokenizer_class.from_pretrained(SCREAMING_SNAKE_CASE_,     **SCREAMING_SNAKE_CASE_			)
                UpperCamelCase       :    str		      =      self.tokenizer_class.from_pretrained(SCREAMING_SNAKE_CASE_,     **SCREAMING_SNAKE_CASE_			)

                UpperCamelCase       :    Optional[Any]		      =      tempfile.mkdtemp()

                UpperCamelCase       :    Optional[int]		      =      tokenizer_r.save_pretrained(SCREAMING_SNAKE_CASE_			)
                UpperCamelCase       :    List[str]		      =      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			)			)
                UpperCamelCase       :    Optional[Any]		      =      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
                UpperCamelCase       :    List[str]		      =      tokenizer_r.from_pretrained(SCREAMING_SNAKE_CASE_			)
                UpperCamelCase       :    Optional[int]		      =      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
                UpperCamelCase       :    Tuple		      =      tempfile.mkdtemp()

                UpperCamelCase       :    int		      =      tokenizer_r.save_pretrained(SCREAMING_SNAKE_CASE_,     legacy_format=SCREAMING_SNAKE_CASE_			)
                UpperCamelCase       :    Dict		      =      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
                UpperCamelCase       :    str		      =      tokenizer_r.from_pretrained(SCREAMING_SNAKE_CASE_			)
                UpperCamelCase       :    int		      =      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
                UpperCamelCase       :    Optional[Any]		      =      tempfile.mkdtemp()

                UpperCamelCase       :    Optional[Any]		      =      tokenizer_r.save_pretrained(SCREAMING_SNAKE_CASE_,     legacy_format=SCREAMING_SNAKE_CASE_			)
                UpperCamelCase       :    str		      =      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
                UpperCamelCase       :    Union[str, Any]		      =      tokenizer_r.from_pretrained(SCREAMING_SNAKE_CASE_			)
                UpperCamelCase       :    List[Any]		      =      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    snake_case_			(     self			)	->						Optional[Any]:
          if not self.test_seqaseq:
             return

          UpperCamelCase       :    int		      =      self.get_tokenizers()
          for tokenizer in tokenizers:
             with self.subTest(F"""{tokenizer.__class__.__name__}"""			):
                # Longer text that will definitely require truncation.
                UpperCamelCase       :    List[str]		      =      [
                    ' 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.',
                ]
                UpperCamelCase       :    Optional[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.',
                ]
                try:
                   UpperCamelCase       :    List[str]		      =      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
                UpperCamelCase       :    Any		      =      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			)

                UpperCamelCase       :    Optional[int]		      =      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    snake_case_			(     self			)	->						Tuple:
          pass






       def    snake_case_			(     self			)	->						Any:
          for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
             with self.subTest(F"""{tokenizer.__class__.__name__} ({pretrained_name})"""			):
                UpperCamelCase       :    int		      =      [AddedToken('<special>',     lstrip=SCREAMING_SNAKE_CASE_			)]

                UpperCamelCase       :    List[str]		      =      self.rust_tokenizer_class.from_pretrained(
                    SCREAMING_SNAKE_CASE_,     additional_special_tokens=SCREAMING_SNAKE_CASE_,     **SCREAMING_SNAKE_CASE_			)
                UpperCamelCase       :    Tuple		      =      tokenizer_r.encode('Hey this is a <special> token'			)

                UpperCamelCase       :    Optional[int]		      =      tokenizer_r.encode('<special>',     add_special_tokens=SCREAMING_SNAKE_CASE_			)[0]

                self.assertTrue(special_token_id in r_output			)

                if self.test_slow_tokenizer:
                   UpperCamelCase       :    Dict		      =      self.rust_tokenizer_class.from_pretrained(
                       SCREAMING_SNAKE_CASE_,     additional_special_tokens=SCREAMING_SNAKE_CASE_,     **SCREAMING_SNAKE_CASE_,     )
                   UpperCamelCase       :    Optional[int]		      =      self.tokenizer_class.from_pretrained(
                       SCREAMING_SNAKE_CASE_,     additional_special_tokens=SCREAMING_SNAKE_CASE_,     **SCREAMING_SNAKE_CASE_			)

                   UpperCamelCase       :    int		      =      tokenizer_p.encode('Hey this is a <special> token'			)

                   UpperCamelCase       :    Any		      =      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				):
       UpperCAmelCase__							:   Any  	=    "facebook/nllb-200-distilled-600M"
       UpperCAmelCase__							:   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.",
       ]
       UpperCAmelCase__							:   int  	=    [
           "Ş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.",
       ]
       UpperCAmelCase__							:   List[str]  	=    [
           25_6047,
           1_6297,
           13_4408,
           8165,
           24_8066,
           1_4734,
           950,
           1135,
           10_5721,
           3573,
           83,
           2_7352,
           108,
           4_9486,
           2,
       ]
       @classmethod
       def    snake_case_			(     cls			)	->						str:
          UpperCamelCase       :    NllbTokenizer		      =      NllbTokenizer.from_pretrained(
              cls.checkpoint_name,     src_lang='eng_Latn',     tgt_lang='ron_Latn'			)
          UpperCamelCase       :    List[Any]		      =      1
          return cls
       def    snake_case_			(     self			)	->						Optional[int]:
          self.assertEqual(self.tokenizer.fairseq_tokens_to_ids['ace_Arab'],     25_6001			)
          self.assertEqual(self.tokenizer.fairseq_tokens_to_ids['ace_Latn'],     25_6002			)
          self.assertEqual(self.tokenizer.fairseq_tokens_to_ids['fra_Latn'],     25_6057			)
       def    snake_case_			(     self			)	->						Optional[int]:
          UpperCamelCase       :    Any		      =      self.tokenizer.batch_encode_plus(self.src_text			).input_ids[0]
          self.assertListEqual(self.expected_src_tokens,     SCREAMING_SNAKE_CASE_			)
       def    snake_case_			(     self			)	->						List[Any]:
          self.assertIn(SCREAMING_SNAKE_CASE_,     self.tokenizer.all_special_ids			)
          # fmt: off
          UpperCamelCase       :    Optional[Any]		      =      [RO_CODE, 4254, 9_8068, 11_2923, 3_9072, 3909, 713, 10_2767, 26, 1_7314, 3_5642, 1_4683, 3_3118, 2022, 6_6987, 2, 25_6047]
          # fmt: on

          UpperCamelCase       :    Optional[Any]		      =      self.tokenizer.decode(SCREAMING_SNAKE_CASE_,     skip_special_tokens=SCREAMING_SNAKE_CASE_			)
          UpperCamelCase       :    Optional[Any]		      =      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    snake_case_			(     self			)	->						Tuple:
          UpperCamelCase       :    Union[str, Any]		      =      ['this is gunna be a long sentence ' * 20]
          assert isinstance(src_text[0],     SCREAMING_SNAKE_CASE_			)
          UpperCamelCase       :    int		      =      10
          UpperCamelCase       :    List[str]		      =      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    snake_case_			(     self			)	->						Dict:
          self.assertListEqual(self.tokenizer.convert_tokens_to_ids(['<mask>', 'ar_AR']			),     [25_6203, 3]			)
       def    snake_case_			(     self			)	->						List[Any]:
          UpperCamelCase       :    Any		      =      tempfile.mkdtemp()
          UpperCamelCase       :    Optional[int]		      =      self.tokenizer.fairseq_tokens_to_ids
          self.tokenizer.save_pretrained(SCREAMING_SNAKE_CASE_			)
          UpperCamelCase       :    Dict		      =      NllbTokenizer.from_pretrained(SCREAMING_SNAKE_CASE_			)
          self.assertDictEqual(new_tok.fairseq_tokens_to_ids,     SCREAMING_SNAKE_CASE_			)
       @require_torch
       def    snake_case_			(     self			)	->						List[str]:
          UpperCamelCase       :    Optional[Any]		      =      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',     )
          UpperCamelCase       :    List[str]		      =      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			)
          UpperCamelCase       :    List[Any]		      =      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    snake_case_			(     self			)	->						Optional[Any]:
          UpperCamelCase       :    Tuple		      =      self.tokenizer(self.src_text,     padding=SCREAMING_SNAKE_CASE_,     truncation=SCREAMING_SNAKE_CASE_,     max_length=3,     return_tensors='pt'			)
          UpperCamelCase       :    Tuple		      =      self.tokenizer(
              text_target=self.tgt_text,     padding=SCREAMING_SNAKE_CASE_,     truncation=SCREAMING_SNAKE_CASE_,     max_length=10,     return_tensors='pt'			)
          UpperCamelCase       :    Dict		      =      targets['input_ids']
          UpperCamelCase       :    List[str]		      =      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    snake_case_			(     self			)	->						Tuple:
          UpperCamelCase       :    List[Any]		      =      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_6047, 70, 7356, 2]],
                  'attention_mask': [[1, 1, 1, 1]],
                  # ar_AR
                  'forced_bos_token_id': 25_6057,
              },     )






       @require_torch
       def    snake_case_			(     self			)	->						str:
          UpperCamelCase       :    Any		      =      True
          UpperCamelCase       :    int		      =      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_6297, 13_4408, 2_5653, 6370, 248, 254, 10_3929, 9_4995, 108, 4_9486, 2, 25_6047]			)

          UpperCamelCase       :    int		      =      False
          UpperCamelCase       :    Dict		      =      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_6047, 1_6297, 13_4408, 2_5653, 6370, 248, 254, 10_3929, 9_4995, 108, 4_9486, 2]			)







from ..utils import DummyObject, requires_backends







class        __lowercase       (							metaclass=a_  ):



		"""simple docstring"""

		UpperCamelCase     :					Tuple			       =		["flax"]







		def __init__( self		,      *A		,      **A	)  -> str:







					'''simple docstring'''







					requires_backends(self		,      ["""flax"""]	)







		@classmethod
		def 					__A   ( cls		,      *A		,      **A	)  -> int:







					'''simple docstring'''







					requires_backends(cls		,      ["""flax"""]	)







		@classmethod
		def 					__A   ( cls		,      *A		,      **A	)  -> str:







					'''simple docstring'''







					requires_backends(cls		,      ["""flax"""]	)







class        __lowercase       (							metaclass=a_  ):



		"""simple docstring"""

		UpperCamelCase     :					Optional[Any]			       =		["flax"]







		def __init__( self		,      *A		,      **A	)  -> Dict:







					'''simple docstring'''







					requires_backends(self		,      ["""flax"""]	)







		@classmethod
		def 					__A   ( cls		,      *A		,      **A	)  -> List[str]:







					'''simple docstring'''







					requires_backends(cls		,      ["""flax"""]	)







		@classmethod
		def 					__A   ( cls		,      *A		,      **A	)  -> Dict:







					'''simple docstring'''







					requires_backends(cls		,      ["""flax"""]	)







class        __lowercase       (							metaclass=a_  ):



		"""simple docstring"""

		UpperCamelCase     :					str			       =		["flax"]







		def __init__( self		,      *A		,      **A	)  -> Dict:







					'''simple docstring'''







					requires_backends(self		,      ["""flax"""]	)







		@classmethod
		def 					__A   ( cls		,      *A		,      **A	)  -> Union[str, Any]:







					'''simple docstring'''







					requires_backends(cls		,      ["""flax"""]	)







		@classmethod
		def 					__A   ( cls		,      *A		,      **A	)  -> Optional[int]:







					'''simple docstring'''







					requires_backends(cls		,      ["""flax"""]	)







class        __lowercase       (							metaclass=a_  ):



		"""simple docstring"""

		UpperCamelCase     :					str			       =		["flax"]







		def __init__( self		,      *A		,      **A	)  -> List[Any]:







					'''simple docstring'''







					requires_backends(self		,      ["""flax"""]	)







		@classmethod
		def 					__A   ( cls		,      *A		,      **A	)  -> Any:







					'''simple docstring'''







					requires_backends(cls		,      ["""flax"""]	)







		@classmethod
		def 					__A   ( cls		,      *A		,      **A	)  -> Union[str, Any]:







					'''simple docstring'''







					requires_backends(cls		,      ["""flax"""]	)







class        __lowercase       (							metaclass=a_  ):



		"""simple docstring"""

		UpperCamelCase     :					Dict			       =		["flax"]







		def __init__( self		,      *A		,      **A	)  -> Optional[Any]:







					'''simple docstring'''







					requires_backends(self		,      ["""flax"""]	)







		@classmethod
		def 					__A   ( cls		,      *A		,      **A	)  -> Optional[Any]:







					'''simple docstring'''







					requires_backends(cls		,      ["""flax"""]	)







		@classmethod
		def 					__A   ( cls		,      *A		,      **A	)  -> Any:







					'''simple docstring'''







					requires_backends(cls		,      ["""flax"""]	)







class        __lowercase       (							metaclass=a_  ):



		"""simple docstring"""

		UpperCamelCase     :					Optional[int]			       =		["flax"]







		def __init__( self		,      *A		,      **A	)  -> int:







					'''simple docstring'''







					requires_backends(self		,      ["""flax"""]	)







		@classmethod
		def 					__A   ( cls		,      *A		,      **A	)  -> int:







					'''simple docstring'''







					requires_backends(cls		,      ["""flax"""]	)







		@classmethod
		def 					__A   ( cls		,      *A		,      **A	)  -> str:







					'''simple docstring'''







					requires_backends(cls		,      ["""flax"""]	)







class        __lowercase       (							metaclass=a_  ):



		"""simple docstring"""

		UpperCamelCase     :					Union[str, Any]			       =		["flax"]







		def __init__( self		,      *A		,      **A	)  -> List[Any]:







					'''simple docstring'''







					requires_backends(self		,      ["""flax"""]	)







		@classmethod
		def 					__A   ( cls		,      *A		,      **A	)  -> Tuple:







					'''simple docstring'''







					requires_backends(cls		,      ["""flax"""]	)







		@classmethod
		def 					__A   ( cls		,      *A		,      **A	)  -> Optional[int]:







					'''simple docstring'''







					requires_backends(cls		,      ["""flax"""]	)







class        __lowercase       (							metaclass=a_  ):



		"""simple docstring"""

		UpperCamelCase     :					Optional[Any]			       =		["flax"]







		def __init__( self		,      *A		,      **A	)  -> Optional[Any]:







					'''simple docstring'''







					requires_backends(self		,      ["""flax"""]	)







		@classmethod
		def 					__A   ( cls		,      *A		,      **A	)  -> int:







					'''simple docstring'''







					requires_backends(cls		,      ["""flax"""]	)







		@classmethod
		def 					__A   ( cls		,      *A		,      **A	)  -> int:







					'''simple docstring'''







					requires_backends(cls		,      ["""flax"""]	)







class        __lowercase       (							metaclass=a_  ):



		"""simple docstring"""

		UpperCamelCase     :					Tuple			       =		["flax"]







		def __init__( self		,      *A		,      **A	)  -> str:







					'''simple docstring'''







					requires_backends(self		,      ["""flax"""]	)







		@classmethod
		def 					__A   ( cls		,      *A		,      **A	)  -> List[Any]:







					'''simple docstring'''







					requires_backends(cls		,      ["""flax"""]	)







		@classmethod
		def 					__A   ( cls		,      *A		,      **A	)  -> str:







					'''simple docstring'''







					requires_backends(cls		,      ["""flax"""]	)







class        __lowercase       (							metaclass=a_  ):



		"""simple docstring"""

		UpperCamelCase     :					Any			       =		["flax"]







		def __init__( self		,      *A		,      **A	)  -> List[str]:







					'''simple docstring'''







					requires_backends(self		,      ["""flax"""]	)







		@classmethod
		def 					__A   ( cls		,      *A		,      **A	)  -> int:







					'''simple docstring'''







					requires_backends(cls		,      ["""flax"""]	)







		@classmethod
		def 					__A   ( cls		,      *A		,      **A	)  -> str:







					'''simple docstring'''







					requires_backends(cls		,      ["""flax"""]	)







class        __lowercase       (							metaclass=a_  ):



		"""simple docstring"""

		UpperCamelCase     :					str			       =		["flax"]







		def __init__( self		,      *A		,      **A	)  -> Dict:







					'''simple docstring'''







					requires_backends(self		,      ["""flax"""]	)







		@classmethod
		def 					__A   ( cls		,      *A		,      **A	)  -> Optional[int]:







					'''simple docstring'''







					requires_backends(cls		,      ["""flax"""]	)







		@classmethod
		def 					__A   ( cls		,      *A		,      **A	)  -> Dict:







					'''simple docstring'''







					requires_backends(cls		,      ["""flax"""]	)







class        __lowercase       (							metaclass=a_  ):



		"""simple docstring"""

		UpperCamelCase     :					Optional[int]			       =		["flax"]







		def __init__( self		,      *A		,      **A	)  -> List[str]:







					'''simple docstring'''







					requires_backends(self		,      ["""flax"""]	)







		@classmethod
		def 					__A   ( cls		,      *A		,      **A	)  -> Any:







					'''simple docstring'''







					requires_backends(cls		,      ["""flax"""]	)







		@classmethod
		def 					__A   ( cls		,      *A		,      **A	)  -> Any:







					'''simple docstring'''







					requires_backends(cls		,      ["""flax"""]	)







class        __lowercase       (							metaclass=a_  ):



		"""simple docstring"""

		UpperCamelCase     :					Tuple			       =		["flax"]







		def __init__( self		,      *A		,      **A	)  -> str:







					'''simple docstring'''







					requires_backends(self		,      ["""flax"""]	)







		@classmethod
		def 					__A   ( cls		,      *A		,      **A	)  -> Dict:







					'''simple docstring'''







					requires_backends(cls		,      ["""flax"""]	)







		@classmethod
		def 					__A   ( cls		,      *A		,      **A	)  -> Union[str, Any]:







					'''simple docstring'''







					requires_backends(cls		,      ["""flax"""]	)

