




'''simple docstring'''






from __future__ import annotations

import os
import tempfile
import unittest

import numpy as np
from huggingface_hub import hf_hub_download

from transformers import is_tensorflow_text_available, is_tf_available
from transformers.testing_utils import require_tensorflow_text, require_tf, slow

from ..test_modeling_tf_common import floats_tensor
from .test_framework_agnostic import GenerationIntegrationTestsMixin


if is_tf_available():
      import tensorflow as tf

      from transformers import (
          AutoTokenizer,
          TFAutoModelForCausalLM,
          TFAutoModelForSeqaSeqLM,
          TFAutoModelForSpeechSeqaSeq,
          TFAutoModelForVisionaSeq,
          TFBartForConditionalGeneration,
          TFLogitsProcessorList,
          TFMinLengthLogitsProcessor,
          tf_top_k_top_p_filtering,
      )

if is_tensorflow_text_available():
      import tensorflow_text as text






@require_tf
class        lowercase_      (						unittest.TestCase							):





     def 			_lowerCAmelCase      (     self     :					List[Any]			):
           snake_case__       :   Dict	      =    tf.convert_to_tensor(
               [
                   [
                       8.2_2_2_0_9_9_1,  # 3rd highest value; idx. 0
                       -0.5_6_2_0_0_4_4,
                       5.2_3_2_2_9_7_5_2,
                       4.0_3_8_6_3_9_3,
                       -6.8_7_9_8_3_7_8,
                       -0.5_4_7_8_5_8_0_2,
                       -3.2_0_1_2_1_5_3,
                       2.9_2_7_7_7_1_7_6,
                       1.8_8_1_7_1_9_5_3,
                       7.3_5_3_4_1_2_7_6,  # 5th highest value; idx. 9
                       8.4_3_2_0_7_8_3_3,  # 2nd highest value; idx. 10
                       -9.8_5_7_1_1_8_3_6,
                       -5.9_6_2_0_9_2_3_6,
                       -1.1_3_0_3_9_1_6_1,
                       -7.1_1_1_5_2_9_4,
                       -0.8_3_6_9_6_3_3,
                       -5.3_1_8_6_4_0_8,
                       7.0_6_4_2_7_4_0_7,
                       0.8_1_3_6_9_3_4_4,
                       -0.8_2_0_2_3_8_1_7,
                       -5.9_1_7_9_7_9_6,
                       0.5_8_8_1_3_4_4_3,
                       -6.9_9_7_7_8_4_3_8,
                       4.7_1_5_5_1_1_8_9,
                       -0.1_8_7_7_1_6_3_7,
                       7.4_4_0_2_0_7_5_9,  # 4th highest value; idx. 25
                       9.3_8_4_5_0_9_8_7,  # 1st highest value; idx. 26
                       2.1_2_6_6_2_9_4_1,
                       -9.3_2_5_6_2_0_3_8,
                       2.3_5_6_5_2_5_2_2,
                   ],  # cummulative prob of 5 highest values <= 0.6
                   [
                       0.5_8_4_2_5_5_1_8,
                       4.5_3_1_3_9_2_3_8,
                       -5.5_7_5_1_0_4_6_4,
                       -6.2_8_0_3_0_6_9_9,
                       -7.1_9_5_2_9_5_0_3,
                       -4.0_2_1_2_2_5_5_1,
                       1.3_9_3_3_7_0_3_7,
                       -6.0_6_7_0_7_0_5_7,
                       1.5_9_4_8_0_5_1_7,
                       -9.6_4_3_1_1_9,
                       0.0_3_9_0_7_7_9_9,
                       0.6_7_2_3_1_7_6_2,
                       -8.8_8_2_0_6_7_2_6,
                       6.2_7_1_1_5_9_2_2,  # 4th highest value; idx. 13
                       2.2_8_5_2_0_7_2_3,
                       4.8_2_7_6_7_5_0_6,
                       4.3_0_4_2_1_3_6_8,
                       8.8_2_7_5_3_1_3,  # 2nd highest value; idx. 17
                       5.4_4_0_2_9_9_5_8,  # 5th highest value; idx. 18
                       -4.4_7_3_5_7_9_4,
                       7.3_8_5_7_9_5_3_6,  # 3rd highest value; idx. 20
                       -2.9_1_0_5_1_6_6_3,
                       2.6_1_9_4_6_0_7_7,
                       -2.5_6_7_4_7_6_2,
                       -9.4_8_9_5_9_3_0_2,
                       -4.0_2_9_2_2_6_4_5,
                       -1.3_5_4_1_6_9_1_8,
                       9.6_7_7_0_2_3_2_3,  # 1st highest value; idx. 27
                       -5.8_9_4_7_8_5_5_3,
                       1.8_5_3_7_0_4_6_7,
                   ],  # cummulative prob of 5 highest values <= 0.6
               ]     ,							dtype=tf.floataa     ,							)

           snake_case__       :   Any	      =    tf.convert_to_tensor(
               [[0, 0], [0, 9], [0, 10], [0, 25], [0, 26], [1, 13], [1, 17], [1, 18], [1, 20], [1, 27]]     ,							dtype=tf.intaa     ,							)  # expected non filtered idx as noted above

           snake_case__       :   Optional[int]	      =    tf.convert_to_tensor(
               [8.2_2_2_0_9_9, 7.3_5_3_4_1_2_6, 8.4_3_2_0_7_8, 7.4_4_0_2_0_7_5, 9.3_8_4_5_1, 6.2_7_1_1_5_9, 8.8_2_7_5_3_1, 5.4_4_0_2_9_9_5, 7.3_8_5_7_9_5_6, 9.6_7_7_0_2_3]     ,							dtype=tf.floataa     ,							)  # expected non filtered values as noted above

           snake_case__       :   Any	      =    tf_top_k_top_p_filtering(__lowerCamelCase     ,							top_k=10     ,							top_p=0.6     ,							min_tokens_to_keep=4			)

           snake_case__       :   int	      =    output[output != -float('inf'			)]
           snake_case__       :   Dict	      =    tf.cast(
               tf.where(tf.not_equal(__lowerCamelCase     ,							tf.constant(-float('inf'			)     ,							dtype=tf.floataa			)			)			)     ,							dtype=tf.intaa     ,							)

           tf.debugging.assert_near(__lowerCamelCase     ,							__lowerCamelCase     ,							rtol=1E-12			)
           tf.debugging.assert_equal(__lowerCamelCase     ,							__lowerCamelCase			)






@require_tf
class        lowercase_      (						unittest.TestCase						,       lowerCAmelCase_							):
     # setting framework_dependent_parameters needs to be gated, just like its contents' imports
     if is_tf_available():
          A_											=			{
              "AutoModelForCausalLM": TFAutoModelForCausalLM,
              "AutoModelForSpeechSeq2Seq": TFAutoModelForSpeechSeqaSeq,
              "AutoModelForSeq2SeqLM": TFAutoModelForSeqaSeqLM,
              "AutoModelForVision2Seq": TFAutoModelForVisionaSeq,
              "LogitsProcessorList": TFLogitsProcessorList,
              "MinLengthLogitsProcessor": TFMinLengthLogitsProcessor,
              "create_tensor_fn": tf.convert_to_tensor,
              "floats_tensor": floats_tensor,
              "return_tensors": "tf",
          }





     @slow
     def 			_lowerCAmelCase      (     self     :					Tuple			):
           # TF-only test: tf.saved_model export
           snake_case__       :   Optional[int]	      =    TFAutoModelForCausalLM.from_pretrained('hf-internal-testing/tiny-random-gpt2'			)
           snake_case__       :   Any	      =    2
           snake_case__       :   Tuple	      =    2






           class        lowercase_      (						tf.Module							):





                def __init__(     self     :					Union[str, Any]     ,							__lowerCamelCase     :					Optional[Any]			):
                      super(__lowerCamelCase     ,							self			).__init__()
                      snake_case__       :   List[str]	      =    model





                @tf.function(
                    input_signature=(
                        tf.TensorSpec((None, input_length)     ,							tf.intaa     ,							name='input_ids'			),
                        tf.TensorSpec((None, input_length)     ,							tf.intaa     ,							name='attention_mask'			),
                    )     ,							jit_compile=__lowerCamelCase     ,							)
                def 			_lowerCAmelCase      (     self     :					Tuple     ,							__lowerCamelCase     :					Optional[int]     ,							__lowerCamelCase     :					str			):
                      snake_case__       :   Optional[Any]	      =    self.model.generate(
                          input_ids=__lowerCamelCase     ,							attention_mask=__lowerCamelCase     ,							max_new_tokens=__lowerCamelCase     ,							return_dict_in_generate=__lowerCamelCase     ,							)
                      return {"sequences": outputs["sequences"]}



           snake_case__       :   Union[str, Any]	      =    [[2, 0], [102, 103]]
           snake_case__       :   int	      =    [[1, 0], [1, 1]]
           snake_case__       :   Union[str, Any]	      =    DummyModel(model=__lowerCamelCase			)
           with tempfile.TemporaryDirectory() as tmp_dir:
                 tf.saved_model.save(__lowerCamelCase     ,							__lowerCamelCase     ,							signatures={'serving_default': dummy_model.serving}			)
                 snake_case__       :   Optional[int]	      =    tf.saved_model.load(__lowerCamelCase			).signatures['serving_default']
                 for batch_size in range(1     ,							len(__lowerCamelCase			) + 1			):
                       snake_case__       :   int	      =    {
                           'input_ids': tf.constant(dummy_input_ids[:batch_size]			),
                           'attention_mask': tf.constant(dummy_attention_masks[:batch_size]			),
                       }
                       snake_case__       :   List[str]	      =    serving_func(**__lowerCamelCase			)['sequences']
                       snake_case__       :   Optional[int]	      =    test_model.generate(**__lowerCamelCase     ,							max_new_tokens=__lowerCamelCase			)
                       tf.debugging.assert_equal(__lowerCamelCase     ,							__lowerCamelCase			)





     @slow
     def 			_lowerCAmelCase      (     self     :					List[Any]			):
           # TF-only test: tf.saved_model export
           snake_case__       :   Tuple	      =    TFAutoModelForCausalLM.from_pretrained('hf-internal-testing/tiny-random-gpt2'			)
           snake_case__       :   List[Any]	      =    1
           snake_case__       :   Tuple	      =    2






           class        lowercase_      (						tf.Module							):





                def __init__(     self     :					List[Any]     ,							__lowerCamelCase     :					Dict			):
                      super(__lowerCamelCase     ,							self			).__init__()
                      snake_case__       :   Optional[Any]	      =    model





                @tf.function(
                    input_signature=(
                        tf.TensorSpec((batch_size, None)     ,							tf.intaa     ,							name='input_ids'			),
                        tf.TensorSpec((batch_size, None)     ,							tf.intaa     ,							name='attention_mask'			),
                    )     ,							jit_compile=__lowerCamelCase     ,							)
                def 			_lowerCAmelCase      (     self     :					Optional[int]     ,							__lowerCamelCase     :					Any     ,							__lowerCamelCase     :					Tuple			):
                      snake_case__       :   Any	      =    self.model.generate(
                          input_ids=__lowerCamelCase     ,							attention_mask=__lowerCamelCase     ,							max_new_tokens=__lowerCamelCase     ,							return_dict_in_generate=__lowerCamelCase     ,							)
                      return {"sequences": outputs["sequences"]}



           snake_case__       :   List[Any]	      =    [[2], [102, 103]]
           snake_case__       :   str	      =    [[1], [1, 1]]
           snake_case__       :   Union[str, Any]	      =    DummyModel(model=__lowerCamelCase			)
           with tempfile.TemporaryDirectory() as tmp_dir:
                 tf.saved_model.save(__lowerCamelCase     ,							__lowerCamelCase     ,							signatures={'serving_default': dummy_model.serving}			)
                 snake_case__       :   Any	      =    tf.saved_model.load(__lowerCamelCase			).signatures['serving_default']
                 for input_row in range(len(__lowerCamelCase			)			):
                       snake_case__       :   Union[str, Any]	      =    {
                           'input_ids': tf.constant([dummy_input_ids[input_row]]			),
                           'attention_mask': tf.constant([dummy_attention_masks[input_row]]			),
                       }
                       snake_case__       :   Any	      =    serving_func(**__lowerCamelCase			)['sequences']
                       snake_case__       :   Optional[int]	      =    test_model.generate(**__lowerCamelCase     ,							max_new_tokens=__lowerCamelCase			)
                       tf.debugging.assert_equal(__lowerCamelCase     ,							__lowerCamelCase			)





     @slow
     @require_tensorflow_text
     def 			_lowerCAmelCase      (     self     :					Any			):
           # TF-only test: tf.saved_model export
           with tempfile.TemporaryDirectory() as tmp_dir:
                 # file needed to load the TF tokenizer
                 hf_hub_download(repo_id='google/flan-t5-small'     ,							filename='spiece.model'     ,							local_dir=__lowerCamelCase			)






                 class        lowercase_      (						tf.keras.layers.Layer							):





                      def __init__(     self     :					int			):
                            super().__init__()
                            snake_case__       :   str	      =    text.SentencepieceTokenizer(
                                model=tf.io.gfile.GFile(os.path.join(__lowerCamelCase     ,							'spiece.model'			)     ,							'rb'			).read()			)
                            snake_case__       :   Optional[Any]	      =    TFAutoModelForSeqaSeqLM.from_pretrained('hf-internal-testing/tiny-random-t5'			)





                      def 			_lowerCAmelCase      (     self     :					str     ,							__lowerCamelCase     :					List[str]     ,							*__lowerCamelCase     :					List[str]     ,							**__lowerCamelCase     :					Dict			):
                            snake_case__       :   Optional[Any]	      =    self.tokenizer.tokenize(__lowerCamelCase			)
                            snake_case__      ,							snake_case__       :   Optional[int]	      =    text.pad_model_inputs(
                                __lowerCamelCase     ,							max_seq_length=64     ,							pad_value=self.model.config.pad_token_id			)
                            snake_case__       :   Dict	      =    self.model.generate(input_ids=__lowerCamelCase     ,							attention_mask=__lowerCamelCase			)
                            return self.tokenizer.detokenize(__lowerCamelCase			)



                 snake_case__       :   List[Any]	      =    CompleteSentenceTransformer()
                 snake_case__       :   Optional[int]	      =    tf.keras.layers.Input(shape=(1,)     ,							dtype=tf.string     ,							name='inputs'			)
                 snake_case__       :   int	      =    complete_model(__lowerCamelCase			)
                 snake_case__       :   List[Any]	      =    tf.keras.Model(__lowerCamelCase     ,							__lowerCamelCase			)
                 keras_model.save(__lowerCamelCase			)





     def 			_lowerCAmelCase      (     self     :					str			):
           # Has PT equivalent: this test relies on random sampling
           snake_case__       :   int	      =    {
               'do_sample': True,
               'num_beams': 1,
               'top_p': 0.7,
               'top_k': 10,
               'temperature': 0.7,
           }
           snake_case__       :   Union[str, Any]	      =    14

           snake_case__       :   str	      =    AutoTokenizer.from_pretrained('hf-internal-testing/tiny-random-gpt2'			)
           snake_case__       :   Tuple	      =    'Hello, my dog is cute and'
           snake_case__       :   Tuple	      =    tokenizer(__lowerCamelCase     ,							return_tensors='tf'			)
           snake_case__       :   Optional[Any]	      =    TFAutoModelForCausalLM.from_pretrained('hf-internal-testing/tiny-random-gpt2'			)

           snake_case__       :   List[str]	      =    638
           # forces the generation to happen on CPU, to avoid GPU-related quirks
           with tf.device(':/CPU:0'			):
                 tf.random.set_seed(0			)
                 snake_case__       :   List[str]	      =    model.generate(**__lowerCamelCase     ,							eos_token_id=__lowerCamelCase     ,							**__lowerCamelCase			)
           self.assertTrue(expectation == len(generated_tokens[0]			)			)

           snake_case__       :   Any	      =    [638, 198]
           with tf.device(':/CPU:0'			):
                 tf.random.set_seed(0			)
                 snake_case__       :   List[Any]	      =    model.generate(**__lowerCamelCase     ,							eos_token_id=__lowerCamelCase     ,							**__lowerCamelCase			)
           self.assertTrue(expectation == len(generated_tokens[0]			)			)





     def 			_lowerCAmelCase      (     self     :					Tuple			):
           # Has PT equivalent: ample use of framework-specific code
           snake_case__       :   List[Any]	      =    AutoTokenizer.from_pretrained('hf-internal-testing/tiny-random-bart'			)
           snake_case__       :   str	      =    'Hugging Face is a technology company based in New York and Paris.'
           snake_case__       :   List[Any]	      =    bart_tokenizer(__lowerCamelCase     ,							return_tensors='tf'			).input_ids
           snake_case__       :   Optional[Any]	      =    TFBartForConditionalGeneration.from_pretrained('hf-internal-testing/tiny-random-bart'			)
           snake_case__       :   Union[str, Any]	      =    bart_model.generate(__lowerCamelCase			).numpy()






           class        lowercase_      (						lowerCAmelCase_							):





                def 			_lowerCAmelCase      (     self     :					Optional[int]     ,							__lowerCamelCase     :					List[str]     ,							__lowerCamelCase     :					Dict=None     ,							**__lowerCamelCase     :					Optional[Any]			):
                      return super().call(__lowerCamelCase     ,							**__lowerCamelCase			)



           snake_case__       :   Union[str, Any]	      =    FakeBart.from_pretrained('hf-internal-testing/tiny-random-bart'			)
           snake_case__       :   int	      =    bart_model.generate(__lowerCamelCase     ,							foo='bar'			).numpy()
           self.assertTrue(np.array_equal(__lowerCamelCase     ,							__lowerCamelCase			)			)






           class        lowercase_      (						bart_model.model.encoder.__class__							):





                def 			_lowerCAmelCase      (     self     :					Optional[Any]     ,							__lowerCamelCase     :					int     ,							**__lowerCamelCase     :					Dict			):
                      return super().call(__lowerCamelCase     ,							**__lowerCamelCase			)



           snake_case__       :   str	      =    FakeEncoder(bart_model.config     ,							bart_model.model.shared			)
           snake_case__       :   List[str]	      =    fake_encoder

           # Normal generation still works (the output will be different because the encoder weights are different)
           snake_case__       :   Optional[int]	      =    bart_model.generate(__lowerCamelCase			).numpy()
           with self.assertRaises(__lowerCamelCase			):
                 # FakeEncoder.call() accepts **kwargs -> no filtering -> value error due to unexpected input "foo"
                 bart_model.generate(__lowerCamelCase     ,							foo='bar'			)






'''simple docstring'''






from ..utils import DummyObject, requires_backends






class        lowercase_      (						metaclass=lowerCAmelCase_							):
     A_											=			["flax"]





     def __init__(     self     :					Optional[Any]     ,							*__lowerCamelCase     :					Tuple     ,							**__lowerCamelCase     :					Optional[int]			):
           requires_backends(self     ,							['flax']			)





     @classmethod
     def 			_lowerCAmelCase      (     cls     :					Tuple     ,							*__lowerCamelCase     :					str     ,							**__lowerCamelCase     :					Optional[int]			):
           requires_backends(cls     ,							['flax']			)





     @classmethod
     def 			_lowerCAmelCase      (     cls     :					Any     ,							*__lowerCamelCase     :					Dict     ,							**__lowerCamelCase     :					List[str]			):
           requires_backends(cls     ,							['flax']			)






class        lowercase_      (						metaclass=lowerCAmelCase_							):
     A_											=			["flax"]





     def __init__(     self     :					int     ,							*__lowerCamelCase     :					str     ,							**__lowerCamelCase     :					Union[str, Any]			):
           requires_backends(self     ,							['flax']			)





     @classmethod
     def 			_lowerCAmelCase      (     cls     :					Optional[Any]     ,							*__lowerCamelCase     :					List[str]     ,							**__lowerCamelCase     :					Optional[int]			):
           requires_backends(cls     ,							['flax']			)





     @classmethod
     def 			_lowerCAmelCase      (     cls     :					Optional[Any]     ,							*__lowerCamelCase     :					Optional[Any]     ,							**__lowerCamelCase     :					Optional[int]			):
           requires_backends(cls     ,							['flax']			)






class        lowercase_      (						metaclass=lowerCAmelCase_							):
     A_											=			["flax"]





     def __init__(     self     :					List[str]     ,							*__lowerCamelCase     :					str     ,							**__lowerCamelCase     :					str			):
           requires_backends(self     ,							['flax']			)





     @classmethod
     def 			_lowerCAmelCase      (     cls     :					Union[str, Any]     ,							*__lowerCamelCase     :					str     ,							**__lowerCamelCase     :					str			):
           requires_backends(cls     ,							['flax']			)





     @classmethod
     def 			_lowerCAmelCase      (     cls     :					Any     ,							*__lowerCamelCase     :					Tuple     ,							**__lowerCamelCase     :					Optional[int]			):
           requires_backends(cls     ,							['flax']			)






class        lowercase_      (						metaclass=lowerCAmelCase_							):
     A_											=			["flax"]





     def __init__(     self     :					Optional[Any]     ,							*__lowerCamelCase     :					Optional[Any]     ,							**__lowerCamelCase     :					str			):
           requires_backends(self     ,							['flax']			)





     @classmethod
     def 			_lowerCAmelCase      (     cls     :					str     ,							*__lowerCamelCase     :					Dict     ,							**__lowerCamelCase     :					int			):
           requires_backends(cls     ,							['flax']			)





     @classmethod
     def 			_lowerCAmelCase      (     cls     :					Optional[Any]     ,							*__lowerCamelCase     :					Union[str, Any]     ,							**__lowerCamelCase     :					Union[str, Any]			):
           requires_backends(cls     ,							['flax']			)






class        lowercase_      (						metaclass=lowerCAmelCase_							):
     A_											=			["flax"]





     def __init__(     self     :					Optional[int]     ,							*__lowerCamelCase     :					Tuple     ,							**__lowerCamelCase     :					Optional[Any]			):
           requires_backends(self     ,							['flax']			)





     @classmethod
     def 			_lowerCAmelCase      (     cls     :					List[Any]     ,							*__lowerCamelCase     :					Dict     ,							**__lowerCamelCase     :					int			):
           requires_backends(cls     ,							['flax']			)





     @classmethod
     def 			_lowerCAmelCase      (     cls     :					Tuple     ,							*__lowerCamelCase     :					List[str]     ,							**__lowerCamelCase     :					str			):
           requires_backends(cls     ,							['flax']			)






class        lowercase_      (						metaclass=lowerCAmelCase_							):
     A_											=			["flax"]





     def __init__(     self     :					List[Any]     ,							*__lowerCamelCase     :					Dict     ,							**__lowerCamelCase     :					Union[str, Any]			):
           requires_backends(self     ,							['flax']			)





     @classmethod
     def 			_lowerCAmelCase      (     cls     :					Any     ,							*__lowerCamelCase     :					Union[str, Any]     ,							**__lowerCamelCase     :					Optional[int]			):
           requires_backends(cls     ,							['flax']			)





     @classmethod
     def 			_lowerCAmelCase      (     cls     :					List[Any]     ,							*__lowerCamelCase     :					Optional[Any]     ,							**__lowerCamelCase     :					Optional[int]			):
           requires_backends(cls     ,							['flax']			)






class        lowercase_      (						metaclass=lowerCAmelCase_							):
     A_											=			["flax"]





     def __init__(     self     :					Dict     ,							*__lowerCamelCase     :					Union[str, Any]     ,							**__lowerCamelCase     :					Any			):
           requires_backends(self     ,							['flax']			)





     @classmethod
     def 			_lowerCAmelCase      (     cls     :					List[Any]     ,							*__lowerCamelCase     :					Optional[int]     ,							**__lowerCamelCase     :					List[str]			):
           requires_backends(cls     ,							['flax']			)





     @classmethod
     def 			_lowerCAmelCase      (     cls     :					Union[str, Any]     ,							*__lowerCamelCase     :					str     ,							**__lowerCamelCase     :					Any			):
           requires_backends(cls     ,							['flax']			)






class        lowercase_      (						metaclass=lowerCAmelCase_							):
     A_											=			["flax"]





     def __init__(     self     :					Tuple     ,							*__lowerCamelCase     :					Union[str, Any]     ,							**__lowerCamelCase     :					Dict			):
           requires_backends(self     ,							['flax']			)





     @classmethod
     def 			_lowerCAmelCase      (     cls     :					List[Any]     ,							*__lowerCamelCase     :					Tuple     ,							**__lowerCamelCase     :					List[Any]			):
           requires_backends(cls     ,							['flax']			)





     @classmethod
     def 			_lowerCAmelCase      (     cls     :					int     ,							*__lowerCamelCase     :					Union[str, Any]     ,							**__lowerCamelCase     :					str			):
           requires_backends(cls     ,							['flax']			)






class        lowercase_      (						metaclass=lowerCAmelCase_							):
     A_											=			["flax"]





     def __init__(     self     :					Union[str, Any]     ,							*__lowerCamelCase     :					Optional[Any]     ,							**__lowerCamelCase     :					int			):
           requires_backends(self     ,							['flax']			)





     @classmethod
     def 			_lowerCAmelCase      (     cls     :					Any     ,							*__lowerCamelCase     :					List[str]     ,							**__lowerCamelCase     :					int			):
           requires_backends(cls     ,							['flax']			)





     @classmethod
     def 			_lowerCAmelCase      (     cls     :					List[str]     ,							*__lowerCamelCase     :					Optional[Any]     ,							**__lowerCamelCase     :					List[str]			):
           requires_backends(cls     ,							['flax']			)






class        lowercase_      (						metaclass=lowerCAmelCase_							):
     A_											=			["flax"]





     def __init__(     self     :					Union[str, Any]     ,							*__lowerCamelCase     :					Optional[Any]     ,							**__lowerCamelCase     :					List[Any]			):
           requires_backends(self     ,							['flax']			)





     @classmethod
     def 			_lowerCAmelCase      (     cls     :					Any     ,							*__lowerCamelCase     :					Optional[int]     ,							**__lowerCamelCase     :					int			):
           requires_backends(cls     ,							['flax']			)





     @classmethod
     def 			_lowerCAmelCase      (     cls     :					str     ,							*__lowerCamelCase     :					Tuple     ,							**__lowerCamelCase     :					List[Any]			):
           requires_backends(cls     ,							['flax']			)






class        lowercase_      (						metaclass=lowerCAmelCase_							):
     A_											=			["flax"]





     def __init__(     self     :					Optional[Any]     ,							*__lowerCamelCase     :					Union[str, Any]     ,							**__lowerCamelCase     :					Union[str, Any]			):
           requires_backends(self     ,							['flax']			)





     @classmethod
     def 			_lowerCAmelCase      (     cls     :					Union[str, Any]     ,							*__lowerCamelCase     :					Tuple     ,							**__lowerCamelCase     :					Optional[Any]			):
           requires_backends(cls     ,							['flax']			)





     @classmethod
     def 			_lowerCAmelCase      (     cls     :					str     ,							*__lowerCamelCase     :					Dict     ,							**__lowerCamelCase     :					Optional[int]			):
           requires_backends(cls     ,							['flax']			)






class        lowercase_      (						metaclass=lowerCAmelCase_							):
     A_											=			["flax"]





     def __init__(     self     :					Union[str, Any]     ,							*__lowerCamelCase     :					List[Any]     ,							**__lowerCamelCase     :					Optional[int]			):
           requires_backends(self     ,							['flax']			)





     @classmethod
     def 			_lowerCAmelCase      (     cls     :					Optional[int]     ,							*__lowerCamelCase     :					Tuple     ,							**__lowerCamelCase     :					Tuple			):
           requires_backends(cls     ,							['flax']			)





     @classmethod
     def 			_lowerCAmelCase      (     cls     :					Dict     ,							*__lowerCamelCase     :					Dict     ,							**__lowerCamelCase     :					Optional[Any]			):
           requires_backends(cls     ,							['flax']			)






class        lowercase_      (						metaclass=lowerCAmelCase_							):
     A_											=			["flax"]





     def __init__(     self     :					str     ,							*__lowerCamelCase     :					int     ,							**__lowerCamelCase     :					Dict			):
           requires_backends(self     ,							['flax']			)





     @classmethod
     def 			_lowerCAmelCase      (     cls     :					List[str]     ,							*__lowerCamelCase     :					Optional[int]     ,							**__lowerCamelCase     :					Tuple			):
           requires_backends(cls     ,							['flax']			)





     @classmethod
     def 			_lowerCAmelCase      (     cls     :					Dict     ,							*__lowerCamelCase     :					Optional[int]     ,							**__lowerCamelCase     :					Optional[Any]			):
           requires_backends(cls     ,							['flax']			)
