



"""simple docstring"""







import unittest

from transformers import (
    MODEL_FOR_CAUSAL_LM_MAPPING,
    TF_MODEL_FOR_CAUSAL_LM_MAPPING,
    TextGenerationPipeline,
    logging,
    pipeline,
)
from transformers.testing_utils import (
    CaptureLogger,
    is_pipeline_test,
    require_accelerate,
    require_tf,
    require_torch,
    require_torch_gpu,
    require_torch_or_tf,
)

from .test_pipelines_common import ANY







@is_pipeline_test
@require_torch_or_tf
class       UpperCamelCase__   (	unittest.TestCase  ):




      """simple docstring"""




      _SCREAMING_SNAKE_CASE  				=     MODEL_FOR_CAUSAL_LM_MAPPING
      _SCREAMING_SNAKE_CASE  				=     TF_MODEL_FOR_CAUSAL_LM_MAPPING



      @require_torch
      def      SCREAMING_SNAKE_CASE__ (      self				:      List[Any]       ):
        lowerCAmelCase_   :				Dict								= pipeline(task='text-generation'    ,			model='sshleifer/tiny-ctrl'    ,			framework='pt'       )
        # Using `do_sample=False` to force deterministic output
        lowerCAmelCase_   :				Optional[Any]								= text_generator('This is a test'    ,			do_sample=SCREAMING_SNAKE_CASE_       )
        self.assertEqual(
            SCREAMING_SNAKE_CASE_    ,			[
                {
                    'generated_text': (
                        'This is a test ☃ ☃ segmental segmental segmental 议议eski eski flutter flutter Lacy oscope.'
                        ' oscope. FiliFili@@'
                    )
                }
            ]    ,			)

        lowerCAmelCase_   :				List[str]								= text_generator(['This is a test', 'This is a second test']       )
        self.assertEqual(
            SCREAMING_SNAKE_CASE_    ,			[
                [
                    {
                        'generated_text': (
                            'This is a test ☃ ☃ segmental segmental segmental 议议eski eski flutter flutter Lacy oscope.'
                            ' oscope. FiliFili@@'
                        )
                    }
                ],
                [
                    {
                        'generated_text': (
                            'This is a second test ☃ segmental segmental segmental 议议eski eski flutter flutter Lacy'
                            ' oscope. oscope. FiliFili@@'
                        )
                    }
                ],
            ]    ,			)

        lowerCAmelCase_   :				List[Any]								= text_generator('This is a test'    ,			do_sample=SCREAMING_SNAKE_CASE_    ,			num_return_sequences=2    ,			return_tensors=SCREAMING_SNAKE_CASE_       )
        self.assertEqual(
            SCREAMING_SNAKE_CASE_    ,			[
                {'generated_token_ids': ANY(SCREAMING_SNAKE_CASE_       )},
                {'generated_token_ids': ANY(SCREAMING_SNAKE_CASE_       )},
            ]    ,			)
        lowerCAmelCase_   :				List[str]								= text_generator.model.config.eos_token_id
        lowerCAmelCase_   :				List[Any]								= '<pad>'
        lowerCAmelCase_   :				Dict								= text_generator(
            ['This is a test', 'This is a second test']    ,			do_sample=SCREAMING_SNAKE_CASE_    ,			num_return_sequences=2    ,			batch_size=2    ,			return_tensors=SCREAMING_SNAKE_CASE_    ,			)
        self.assertEqual(
            SCREAMING_SNAKE_CASE_    ,			[
                [
                    {'generated_token_ids': ANY(SCREAMING_SNAKE_CASE_       )},
                    {'generated_token_ids': ANY(SCREAMING_SNAKE_CASE_       )},
                ],
                [
                    {'generated_token_ids': ANY(SCREAMING_SNAKE_CASE_       )},
                    {'generated_token_ids': ANY(SCREAMING_SNAKE_CASE_       )},
                ],
            ]    ,			)



      @require_tf
      def      SCREAMING_SNAKE_CASE__ (      self				:      Dict       ):
        lowerCAmelCase_   :				Dict								= pipeline(task='text-generation'    ,			model='sshleifer/tiny-ctrl'    ,			framework='tf'       )

        # Using `do_sample=False` to force deterministic output
        lowerCAmelCase_   :				Tuple								= text_generator('This is a test'    ,			do_sample=SCREAMING_SNAKE_CASE_       )
        self.assertEqual(
            SCREAMING_SNAKE_CASE_    ,			[
                {
                    'generated_text': (
                        'This is a test FeyFeyFey(Croatis.), s.), Cannes Cannes Cannes 閲閲Cannes Cannes Cannes 攵'
                        ' please,'
                    )
                }
            ]    ,			)

        lowerCAmelCase_   :				Union[str, Any]								= text_generator(['This is a test', 'This is a second test']    ,			do_sample=SCREAMING_SNAKE_CASE_       )
        self.assertEqual(
            SCREAMING_SNAKE_CASE_    ,			[
                [
                    {
                        'generated_text': (
                            'This is a test FeyFeyFey(Croatis.), s.), Cannes Cannes Cannes 閲閲Cannes Cannes Cannes 攵'
                            ' please,'
                        )
                    }
                ],
                [
                    {
                        'generated_text': (
                            'This is a second test Chieftain Chieftain prefecture prefecture prefecture Cannes Cannes'
                            ' Cannes 閲閲Cannes Cannes Cannes 攵 please,'
                        )
                    }
                ],
            ]    ,			)



      def      SCREAMING_SNAKE_CASE__ (      self				:      int    ,			SCREAMING_SNAKE_CASE_				:      List[str]    ,			SCREAMING_SNAKE_CASE_				:      Any    ,			SCREAMING_SNAKE_CASE_				:      int       ):
        lowerCAmelCase_   :				int								= TextGenerationPipeline(model=SCREAMING_SNAKE_CASE_    ,			tokenizer=SCREAMING_SNAKE_CASE_       )
        return text_generator, ["This is a test", "Another test"]



      def      SCREAMING_SNAKE_CASE__ (      self				:      List[str]       ):
        lowerCAmelCase_   :				Tuple								= 'Hello I believe in'
        lowerCAmelCase_   :				Optional[Any]								= pipeline('text-generation'    ,			model='hf-internal-testing/tiny-random-gpt2'       )
        lowerCAmelCase_   :				Union[str, Any]								= text_generator(SCREAMING_SNAKE_CASE_       )
        self.assertEqual(
            SCREAMING_SNAKE_CASE_    ,			[{'generated_text': 'Hello I believe in fe fe fe fe fe fe fe fe fe fe fe fe'}]    ,			)

        lowerCAmelCase_   :				Optional[int]								= text_generator(SCREAMING_SNAKE_CASE_    ,			stop_sequence=' fe'       )
        self.assertEqual(SCREAMING_SNAKE_CASE_    ,			[{'generated_text': 'Hello I believe in fe'}]       )



      def      SCREAMING_SNAKE_CASE__ (      self				:      int    ,			SCREAMING_SNAKE_CASE_				:      List[Any]    ,			SCREAMING_SNAKE_CASE_				:      Tuple       ):
        lowerCAmelCase_   :				List[Any]								= text_generator.model
        lowerCAmelCase_   :				Tuple								= text_generator.tokenizer

        lowerCAmelCase_   :				Optional[Any]								= text_generator('This is a test'       )
        self.assertEqual(SCREAMING_SNAKE_CASE_    ,			[{'generated_text': ANY(SCREAMING_SNAKE_CASE_       )}]       )
        self.assertTrue(outputs[0]['generated_text'].startswith('This is a test'       )       )

        lowerCAmelCase_   :				str								= text_generator('This is a test'    ,			return_full_text=SCREAMING_SNAKE_CASE_       )
        self.assertEqual(SCREAMING_SNAKE_CASE_    ,			[{'generated_text': ANY(SCREAMING_SNAKE_CASE_       )}]       )
        self.assertNotIn('This is a test'    ,			outputs[0]['generated_text']       )

        lowerCAmelCase_   :				int								= pipeline(task='text-generation'    ,			model=SCREAMING_SNAKE_CASE_    ,			tokenizer=SCREAMING_SNAKE_CASE_    ,			return_full_text=SCREAMING_SNAKE_CASE_       )
        lowerCAmelCase_   :				int								= text_generator('This is a test'       )
        self.assertEqual(SCREAMING_SNAKE_CASE_    ,			[{'generated_text': ANY(SCREAMING_SNAKE_CASE_       )}]       )
        self.assertNotIn('This is a test'    ,			outputs[0]['generated_text']       )

        lowerCAmelCase_   :				Dict								= text_generator('This is a test'    ,			return_full_text=SCREAMING_SNAKE_CASE_       )
        self.assertEqual(SCREAMING_SNAKE_CASE_    ,			[{'generated_text': ANY(SCREAMING_SNAKE_CASE_       )}]       )
        self.assertTrue(outputs[0]['generated_text'].startswith('This is a test'       )       )

        lowerCAmelCase_   :				Tuple								= text_generator(['This is great !', 'Something else']    ,			num_return_sequences=2    ,			do_sample=SCREAMING_SNAKE_CASE_       )
        self.assertEqual(
            SCREAMING_SNAKE_CASE_    ,			[
                [{'generated_text': ANY(SCREAMING_SNAKE_CASE_       )}, {'generated_text': ANY(SCREAMING_SNAKE_CASE_       )}],
                [{'generated_text': ANY(SCREAMING_SNAKE_CASE_       )}, {'generated_text': ANY(SCREAMING_SNAKE_CASE_       )}],
            ]    ,			)

        if text_generator.tokenizer.pad_token is not None:
          lowerCAmelCase_   :				Optional[Any]								= text_generator(
              ['This is great !', 'Something else']    ,			num_return_sequences=2    ,			batch_size=2    ,			do_sample=SCREAMING_SNAKE_CASE_       )
          self.assertEqual(
              SCREAMING_SNAKE_CASE_    ,			[
                  [{'generated_text': ANY(SCREAMING_SNAKE_CASE_       )}, {'generated_text': ANY(SCREAMING_SNAKE_CASE_       )}],
                  [{'generated_text': ANY(SCREAMING_SNAKE_CASE_       )}, {'generated_text': ANY(SCREAMING_SNAKE_CASE_       )}],
              ]    ,			)

        with self.assertRaises(SCREAMING_SNAKE_CASE_       ):
          lowerCAmelCase_   :				Tuple								= text_generator('test'    ,			return_full_text=SCREAMING_SNAKE_CASE_    ,			return_text=SCREAMING_SNAKE_CASE_       )
        with self.assertRaises(SCREAMING_SNAKE_CASE_       ):
          lowerCAmelCase_   :				str								= text_generator('test'    ,			return_full_text=SCREAMING_SNAKE_CASE_    ,			return_tensors=SCREAMING_SNAKE_CASE_       )
        with self.assertRaises(SCREAMING_SNAKE_CASE_       ):
          lowerCAmelCase_   :				List[Any]								= text_generator('test'    ,			return_text=SCREAMING_SNAKE_CASE_    ,			return_tensors=SCREAMING_SNAKE_CASE_       )

        # Empty prompt is slighly special
        # it requires BOS token to exist.
        # Special case for Pegasus which will always append EOS so will
        # work even without BOS.
        if (
            text_generator.tokenizer.bos_token_id is not None
            or "Pegasus" in tokenizer.__class__.__name__
            or "Git" in model.__class__.__name__
        ):
          lowerCAmelCase_   :				str								= text_generator(''       )
          self.assertEqual(SCREAMING_SNAKE_CASE_    ,			[{'generated_text': ANY(SCREAMING_SNAKE_CASE_       )}]       )
        else:
          with self.assertRaises((ValueError, AssertionError)       ):
            lowerCAmelCase_   :				Dict								= text_generator(''       )

        if text_generator.framework == "tf":
          # TF generation does not support max_new_tokens, and it's impossible
          # to control long generation with only max_length without
          # fancy calculation, dismissing tests for now.
          return
        # We don't care about infinite range models.
        # They already work.
        # Skip this test for XGLM, since it uses sinusoidal positional embeddings which are resized on-the-fly.
        lowerCAmelCase_   :				str								= ['RwkvForCausalLM', 'XGLMForCausalLM', 'GPTNeoXForCausalLM']
        if (
            tokenizer.model_max_length < 1_0_0_0_0
            and text_generator.model.__class__.__name__ not in EXTRA_MODELS_CAN_HANDLE_LONG_INPUTS
        ):
          # Handling of large generations
          with self.assertRaises((RuntimeError, IndexError, ValueError, AssertionError)       ):
            text_generator('This is a test' * 5_0_0    ,			max_new_tokens=2_0       )

          lowerCAmelCase_   :				Optional[Any]								= text_generator('This is a test' * 5_0_0    ,			handle_long_generation='hole'    ,			max_new_tokens=2_0       )
          # Hole strategy cannot work
          with self.assertRaises(SCREAMING_SNAKE_CASE_       ):
            text_generator(
                'This is a test' * 5_0_0    ,			handle_long_generation='hole'    ,			max_new_tokens=tokenizer.model_max_length + 1_0    ,			)



      @require_torch
      @require_accelerate
      @require_torch_gpu
      def      SCREAMING_SNAKE_CASE__ (      self				:      List[str]       ):
        import torch

        # Classic `model_kwargs`
        lowerCAmelCase_   :				Dict								= pipeline(
            model='hf-internal-testing/tiny-random-bloom'    ,			model_kwargs={'device_map': 'auto', 'torch_dtype': torch.bfloataa}    ,			)
        self.assertEqual(pipe.model.device    ,			torch.device(0       )       )
        self.assertEqual(pipe.model.lm_head.weight.dtype    ,			torch.bfloataa       )
        lowerCAmelCase_   :				Any								= pipe('This is a test'       )
        self.assertEqual(
            SCREAMING_SNAKE_CASE_    ,			[
                {
                    'generated_text': (
                        'This is a test test test test test test test test test test test test test test test test'
                        ' test'
                    )
                }
            ]    ,			)

        # Upgraded those two to real pipeline arguments (they just get sent for the model as they're unlikely to mean anything else.)
        lowerCAmelCase_   :				str								= pipeline(model='hf-internal-testing/tiny-random-bloom'    ,			device_map='auto'    ,			torch_dtype=torch.bfloataa       )
        self.assertEqual(pipe.model.device    ,			torch.device(0       )       )
        self.assertEqual(pipe.model.lm_head.weight.dtype    ,			torch.bfloataa       )
        lowerCAmelCase_   :				Any								= pipe('This is a test'       )
        self.assertEqual(
            SCREAMING_SNAKE_CASE_    ,			[
                {
                    'generated_text': (
                        'This is a test test test test test test test test test test test test test test test test'
                        ' test'
                    )
                }
            ]    ,			)

        # torch_dtype will be automatically set to float32 if not provided - check: https://github.com/huggingface/transformers/pull/20602
        lowerCAmelCase_   :				List[str]								= pipeline(model='hf-internal-testing/tiny-random-bloom'    ,			device_map='auto'       )
        self.assertEqual(pipe.model.device    ,			torch.device(0       )       )
        self.assertEqual(pipe.model.lm_head.weight.dtype    ,			torch.floataa       )
        lowerCAmelCase_   :				Optional[Any]								= pipe('This is a test'       )
        self.assertEqual(
            SCREAMING_SNAKE_CASE_    ,			[
                {
                    'generated_text': (
                        'This is a test test test test test test test test test test test test test test test test'
                        ' test'
                    )
                }
            ]    ,			)



      @require_torch
      @require_torch_gpu
      def      SCREAMING_SNAKE_CASE__ (      self				:      str       ):
        import torch

        lowerCAmelCase_   :				int								= pipeline(model='hf-internal-testing/tiny-random-bloom'    ,			device=0    ,			torch_dtype=torch.floataa       )
        pipe('This is a test'       )



      @require_torch
      @require_accelerate
      @require_torch_gpu
      def      SCREAMING_SNAKE_CASE__ (      self				:      str       ):
        import torch

        lowerCAmelCase_   :				Optional[Any]								= pipeline(model='hf-internal-testing/tiny-random-bloom'    ,			device_map='auto'    ,			torch_dtype=torch.floataa       )
        pipe('This is a test'    ,			do_sample=SCREAMING_SNAKE_CASE_    ,			top_p=0.5       )





      def      SCREAMING_SNAKE_CASE__ (      self				:      List[str]       ):
        lowerCAmelCase_   :				Optional[Any]								= 'Hello world'
        lowerCAmelCase_   :				Optional[int]								= pipeline('text-generation'    ,			model='hf-internal-testing/tiny-random-gpt2'       )
        if text_generator.model.framework == "tf":
          lowerCAmelCase_   :				Tuple								= logging.get_logger('transformers.generation.tf_utils'       )
        else:
          lowerCAmelCase_   :				str								= logging.get_logger('transformers.generation.utils'       )
        lowerCAmelCase_   :				Dict								= 'Both `max_new_tokens`'  # The beggining of the message to be checked in this test

        # Both are set by the user -> log warning
        with CaptureLogger(SCREAMING_SNAKE_CASE_       ) as cl:
          lowerCAmelCase_   :				Tuple								= text_generator(SCREAMING_SNAKE_CASE_    ,			max_length=1_0    ,			max_new_tokens=1       )
        self.assertIn(SCREAMING_SNAKE_CASE_    ,			cl.out       )

        # The user only sets one -> no warning
        with CaptureLogger(SCREAMING_SNAKE_CASE_       ) as cl:
          lowerCAmelCase_   :				Tuple								= text_generator(SCREAMING_SNAKE_CASE_    ,			max_new_tokens=1       )
        self.assertNotIn(SCREAMING_SNAKE_CASE_    ,			cl.out       )

        with CaptureLogger(SCREAMING_SNAKE_CASE_       ) as cl:
          lowerCAmelCase_   :				int								= text_generator(SCREAMING_SNAKE_CASE_    ,			max_length=1_0       )
        self.assertNotIn(SCREAMING_SNAKE_CASE_    ,			cl.out       )










"""simple docstring"""







from ..utils import DummyObject, requires_backends







class       UpperCamelCase__   (	metaclass=lowercase_  ):




      """simple docstring"""




      _SCREAMING_SNAKE_CASE  				=     ["""flax"""]



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



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





      @classmethod
      def      SCREAMING_SNAKE_CASE__ (      cls				:      int    ,			*SCREAMING_SNAKE_CASE_				:      Optional[int]    ,			**SCREAMING_SNAKE_CASE_				:      Optional[int]       ):
        requires_backends(cls    ,			['flax']       )







class       UpperCamelCase__   (	metaclass=lowercase_  ):




      """simple docstring"""




      _SCREAMING_SNAKE_CASE  				=     ["""flax"""]



      def __init__(      self				:      Tuple    ,			*SCREAMING_SNAKE_CASE_				:      Tuple    ,			**SCREAMING_SNAKE_CASE_				:      Any       ):
        requires_backends(self    ,			['flax']       )



      @classmethod
      def      SCREAMING_SNAKE_CASE__ (      cls				:      Union[str, Any]    ,			*SCREAMING_SNAKE_CASE_				:      Dict    ,			**SCREAMING_SNAKE_CASE_				:      Dict       ):
        requires_backends(cls    ,			['flax']       )





      @classmethod
      def      SCREAMING_SNAKE_CASE__ (      cls				:      Dict    ,			*SCREAMING_SNAKE_CASE_				:      List[str]    ,			**SCREAMING_SNAKE_CASE_				:      Optional[Any]       ):
        requires_backends(cls    ,			['flax']       )







class       UpperCamelCase__   (	metaclass=lowercase_  ):




      """simple docstring"""




      _SCREAMING_SNAKE_CASE  				=     ["""flax"""]



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



      @classmethod
      def      SCREAMING_SNAKE_CASE__ (      cls				:      List[Any]    ,			*SCREAMING_SNAKE_CASE_				:      Any    ,			**SCREAMING_SNAKE_CASE_				:      List[Any]       ):
        requires_backends(cls    ,			['flax']       )





      @classmethod
      def      SCREAMING_SNAKE_CASE__ (      cls				:      Union[str, Any]    ,			*SCREAMING_SNAKE_CASE_				:      List[str]    ,			**SCREAMING_SNAKE_CASE_				:      List[str]       ):
        requires_backends(cls    ,			['flax']       )







class       UpperCamelCase__   (	metaclass=lowercase_  ):




      """simple docstring"""




      _SCREAMING_SNAKE_CASE  				=     ["""flax"""]



      def __init__(      self				:      Tuple    ,			*SCREAMING_SNAKE_CASE_				:      List[str]    ,			**SCREAMING_SNAKE_CASE_				:      int       ):
        requires_backends(self    ,			['flax']       )



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





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







class       UpperCamelCase__   (	metaclass=lowercase_  ):




      """simple docstring"""




      _SCREAMING_SNAKE_CASE  				=     ["""flax"""]



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



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





      @classmethod
      def      SCREAMING_SNAKE_CASE__ (      cls				:      List[str]    ,			*SCREAMING_SNAKE_CASE_				:      Optional[int]    ,			**SCREAMING_SNAKE_CASE_				:      Dict       ):
        requires_backends(cls    ,			['flax']       )







class       UpperCamelCase__   (	metaclass=lowercase_  ):




      """simple docstring"""




      _SCREAMING_SNAKE_CASE  				=     ["""flax"""]



      def __init__(      self				:      Any    ,			*SCREAMING_SNAKE_CASE_				:      int    ,			**SCREAMING_SNAKE_CASE_				:      Dict       ):
        requires_backends(self    ,			['flax']       )



      @classmethod
      def      SCREAMING_SNAKE_CASE__ (      cls				:      str    ,			*SCREAMING_SNAKE_CASE_				:      Optional[Any]    ,			**SCREAMING_SNAKE_CASE_				:      Any       ):
        requires_backends(cls    ,			['flax']       )





      @classmethod
      def      SCREAMING_SNAKE_CASE__ (      cls				:      Tuple    ,			*SCREAMING_SNAKE_CASE_				:      List[Any]    ,			**SCREAMING_SNAKE_CASE_				:      Union[str, Any]       ):
        requires_backends(cls    ,			['flax']       )







class       UpperCamelCase__   (	metaclass=lowercase_  ):




      """simple docstring"""




      _SCREAMING_SNAKE_CASE  				=     ["""flax"""]



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



      @classmethod
      def      SCREAMING_SNAKE_CASE__ (      cls				:      Optional[int]    ,			*SCREAMING_SNAKE_CASE_				:      int    ,			**SCREAMING_SNAKE_CASE_				:      Dict       ):
        requires_backends(cls    ,			['flax']       )





      @classmethod
      def      SCREAMING_SNAKE_CASE__ (      cls				:      Optional[int]    ,			*SCREAMING_SNAKE_CASE_				:      Tuple    ,			**SCREAMING_SNAKE_CASE_				:      Union[str, Any]       ):
        requires_backends(cls    ,			['flax']       )







class       UpperCamelCase__   (	metaclass=lowercase_  ):




      """simple docstring"""




      _SCREAMING_SNAKE_CASE  				=     ["""flax"""]



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



      @classmethod
      def      SCREAMING_SNAKE_CASE__ (      cls				:      Union[str, Any]    ,			*SCREAMING_SNAKE_CASE_				:      List[str]    ,			**SCREAMING_SNAKE_CASE_				:      Tuple       ):
        requires_backends(cls    ,			['flax']       )





      @classmethod
      def      SCREAMING_SNAKE_CASE__ (      cls				:      Dict    ,			*SCREAMING_SNAKE_CASE_				:      List[Any]    ,			**SCREAMING_SNAKE_CASE_				:      Tuple       ):
        requires_backends(cls    ,			['flax']       )







class       UpperCamelCase__   (	metaclass=lowercase_  ):




      """simple docstring"""




      _SCREAMING_SNAKE_CASE  				=     ["""flax"""]



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



      @classmethod
      def      SCREAMING_SNAKE_CASE__ (      cls				:      Any    ,			*SCREAMING_SNAKE_CASE_				:      Optional[int]    ,			**SCREAMING_SNAKE_CASE_				:      str       ):
        requires_backends(cls    ,			['flax']       )





      @classmethod
      def      SCREAMING_SNAKE_CASE__ (      cls				:      Dict    ,			*SCREAMING_SNAKE_CASE_				:      List[Any]    ,			**SCREAMING_SNAKE_CASE_				:      Tuple       ):
        requires_backends(cls    ,			['flax']       )







class       UpperCamelCase__   (	metaclass=lowercase_  ):




      """simple docstring"""




      _SCREAMING_SNAKE_CASE  				=     ["""flax"""]



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



      @classmethod
      def      SCREAMING_SNAKE_CASE__ (      cls				:      Optional[int]    ,			*SCREAMING_SNAKE_CASE_				:      Tuple    ,			**SCREAMING_SNAKE_CASE_				:      List[Any]       ):
        requires_backends(cls    ,			['flax']       )





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







class       UpperCamelCase__   (	metaclass=lowercase_  ):




      """simple docstring"""




      _SCREAMING_SNAKE_CASE  				=     ["""flax"""]



      def __init__(      self				:      Optional[int]    ,			*SCREAMING_SNAKE_CASE_				:      List[Any]    ,			**SCREAMING_SNAKE_CASE_				:      Dict       ):
        requires_backends(self    ,			['flax']       )



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





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







class       UpperCamelCase__   (	metaclass=lowercase_  ):




      """simple docstring"""




      _SCREAMING_SNAKE_CASE  				=     ["""flax"""]



      def __init__(      self				:      Tuple    ,			*SCREAMING_SNAKE_CASE_				:      Any    ,			**SCREAMING_SNAKE_CASE_				:      Any       ):
        requires_backends(self    ,			['flax']       )



      @classmethod
      def      SCREAMING_SNAKE_CASE__ (      cls				:      Union[str, Any]    ,			*SCREAMING_SNAKE_CASE_				:      Tuple    ,			**SCREAMING_SNAKE_CASE_				:      List[str]       ):
        requires_backends(cls    ,			['flax']       )





      @classmethod
      def      SCREAMING_SNAKE_CASE__ (      cls				:      Tuple    ,			*SCREAMING_SNAKE_CASE_				:      Optional[Any]    ,			**SCREAMING_SNAKE_CASE_				:      str       ):
        requires_backends(cls    ,			['flax']       )







class       UpperCamelCase__   (	metaclass=lowercase_  ):




      """simple docstring"""




      _SCREAMING_SNAKE_CASE  				=     ["""flax"""]



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



      @classmethod
      def      SCREAMING_SNAKE_CASE__ (      cls				:      Tuple    ,			*SCREAMING_SNAKE_CASE_				:      Dict    ,			**SCREAMING_SNAKE_CASE_				:      Optional[int]       ):
        requires_backends(cls    ,			['flax']       )





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





