




import unittest

from transformers import DebertaConfig, is_torch_available
from transformers.testing_utils import require_sentencepiece, require_tokenizers, require_torch, slow, torch_device

from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
  import torch

  from transformers import (
      DebertaForMaskedLM,
      DebertaForQuestionAnswering,
      DebertaForSequenceClassification,
      DebertaForTokenClassification,
      DebertaModel,
  )
  from transformers.models.deberta.modeling_deberta import DEBERTA_PRETRAINED_MODEL_ARCHIVE_LIST
class 			_UpperCamelCase      (				lowerCAmelCase		):
      def __init__(			self   :Optional[int] ,      lowerCamelCase   :str ,      lowerCamelCase   :Any=13 ,      lowerCamelCase   :str=7 ,      lowerCamelCase   :List[str]=True ,      lowerCamelCase   :int=True ,      lowerCamelCase   :int=True ,      lowerCamelCase   :str=True ,      lowerCamelCase   :Any=99 ,      lowerCamelCase   :Any=32 ,      lowerCamelCase   :List[Any]=5 ,      lowerCamelCase   :Optional[int]=4 ,      lowerCamelCase   :Any=37 ,      lowerCamelCase   :List[Any]="gelu" ,      lowerCamelCase   :str=0.1 ,      lowerCamelCase   :Dict=0.1 ,      lowerCamelCase   :List[Any]=512 ,      lowerCamelCase   :List[Any]=16 ,      lowerCamelCase   :Optional[int]=2 ,      lowerCamelCase   :List[Any]=0.02 ,      lowerCamelCase   :int=False ,      lowerCamelCase   :Tuple=True ,      lowerCamelCase   :List[Any]="None" ,      lowerCamelCase   :Any=3 ,      lowerCamelCase   :Optional[Any]=4 ,      lowerCamelCase   :Tuple=None ,      )     ->			Dict:
       UpperCAmelCase__							 =						parent
       UpperCAmelCase__							 =						batch_size
       UpperCAmelCase__							 =						seq_length
       UpperCAmelCase__							 =						is_training
       UpperCAmelCase__							 =						use_input_mask
       UpperCAmelCase__							 =						use_token_type_ids
       UpperCAmelCase__							 =						use_labels
       UpperCAmelCase__							 =						vocab_size
       UpperCAmelCase__							 =						hidden_size
       UpperCAmelCase__							 =						num_hidden_layers
       UpperCAmelCase__							 =						num_attention_heads
       UpperCAmelCase__							 =						intermediate_size
       UpperCAmelCase__							 =						hidden_act
       UpperCAmelCase__							 =						hidden_dropout_prob
       UpperCAmelCase__							 =						attention_probs_dropout_prob
       UpperCAmelCase__							 =						max_position_embeddings
       UpperCAmelCase__							 =						type_vocab_size
       UpperCAmelCase__							 =						type_sequence_label_size
       UpperCAmelCase__							 =						initializer_range
       UpperCAmelCase__							 =						num_labels
       UpperCAmelCase__							 =						num_choices
       UpperCAmelCase__							 =						relative_attention
       UpperCAmelCase__							 =						position_biased_input
       UpperCAmelCase__							 =						pos_att_type
       UpperCAmelCase__							 =						scope
      def 	UpperCAmelCase_						(			self   :Optional[Any]      )     ->			Union[str, Any]:
       UpperCAmelCase__							 =						ids_tensor([self.batch_size, self.seq_length] ,      self.vocab_size      )

       UpperCAmelCase__							 =						None
       if self.use_input_mask:
        UpperCAmelCase__							 =						ids_tensor([self.batch_size, self.seq_length] ,      vocab_size=2      )

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

       UpperCAmelCase__							 =						None
       UpperCAmelCase__							 =						None
       UpperCAmelCase__							 =						None
       if self.use_labels:
        UpperCAmelCase__							 =						ids_tensor([self.batch_size] ,      self.type_sequence_label_size      )
        UpperCAmelCase__							 =						ids_tensor([self.batch_size, self.seq_length] ,      self.num_labels      )
        UpperCAmelCase__							 =						ids_tensor([self.batch_size] ,      self.num_choices      )

       UpperCAmelCase__							 =						self.get_config()

       return config, input_ids, token_type_ids, input_mask, sequence_labels, token_labels, choice_labels
      def 	UpperCAmelCase_						(			self   :List[Any]      )     ->			Optional[Any]:
       return DebertaConfig(
           vocab_size=self.vocab_size ,      hidden_size=self.hidden_size ,      num_hidden_layers=self.num_hidden_layers ,      num_attention_heads=self.num_attention_heads ,      intermediate_size=self.intermediate_size ,      hidden_act=self.hidden_act ,      hidden_dropout_prob=self.hidden_dropout_prob ,      attention_probs_dropout_prob=self.attention_probs_dropout_prob ,      max_position_embeddings=self.max_position_embeddings ,      type_vocab_size=self.type_vocab_size ,      initializer_range=self.initializer_range ,      relative_attention=self.relative_attention ,      position_biased_input=self.position_biased_input ,      pos_att_type=self.pos_att_type ,      )
      def 	UpperCAmelCase_						(			self   :List[Any]      )     ->			Tuple:
       UpperCAmelCase__							 =						self.get_config()
       UpperCAmelCase__							 =						300
       return config
      def 	UpperCAmelCase_						(			self   :List[Any] ,      lowerCamelCase   :Optional[int]      )     ->			Optional[int]:
       self.parent.assertListEqual(list(result.loss.size()      ) ,      []      )
      def 	UpperCAmelCase_						(			self   :Optional[Any] ,      lowerCamelCase   :Any ,      lowerCamelCase   :Optional[Any] ,      lowerCamelCase   :Dict ,      lowerCamelCase   :Union[str, Any] ,      lowerCamelCase   :List[Any] ,      lowerCamelCase   :List[Any] ,      lowerCamelCase   :Tuple      )     ->			Dict:
       UpperCAmelCase__							 =						DebertaModel(config=lowerCamelCase      )
       model.to(lowerCamelCase      )
       model.eval()
       UpperCAmelCase__							 =						model(lowerCamelCase ,      attention_mask=lowerCamelCase ,      token_type_ids=lowerCamelCase      )[0]
       UpperCAmelCase__							 =						model(lowerCamelCase ,      token_type_ids=lowerCamelCase      )[0]
       UpperCAmelCase__							 =						model(lowerCamelCase      )[0]

       self.parent.assertListEqual(list(sequence_output.size()      ) ,      [self.batch_size, self.seq_length, self.hidden_size]      )
      def 	UpperCAmelCase_						(			self   :Dict ,      lowerCamelCase   :Optional[Any] ,      lowerCamelCase   :Optional[int] ,      lowerCamelCase   :List[Any] ,      lowerCamelCase   :List[str] ,      lowerCamelCase   :Optional[Any] ,      lowerCamelCase   :Dict ,      lowerCamelCase   :Optional[Any]      )     ->			Optional[Any]:
       UpperCAmelCase__							 =						DebertaForMaskedLM(config=lowerCamelCase      )
       model.to(lowerCamelCase      )
       model.eval()
       UpperCAmelCase__							 =						model(lowerCamelCase ,      attention_mask=lowerCamelCase ,      token_type_ids=lowerCamelCase ,      labels=lowerCamelCase      )

       self.parent.assertEqual(result.logits.shape ,      (self.batch_size, self.seq_length, self.vocab_size)      )
      def 	UpperCAmelCase_						(			self   :int ,      lowerCamelCase   :List[str] ,      lowerCamelCase   :Any ,      lowerCamelCase   :Union[str, Any] ,      lowerCamelCase   :Any ,      lowerCamelCase   :Dict ,      lowerCamelCase   :Dict ,      lowerCamelCase   :Optional[Any]      )     ->			int:
       UpperCAmelCase__							 =						self.num_labels
       UpperCAmelCase__							 =						DebertaForSequenceClassification(lowerCamelCase      )
       model.to(lowerCamelCase      )
       model.eval()
       UpperCAmelCase__							 =						model(lowerCamelCase ,      attention_mask=lowerCamelCase ,      token_type_ids=lowerCamelCase ,      labels=lowerCamelCase      )
       self.parent.assertListEqual(list(result.logits.size()      ) ,      [self.batch_size, self.num_labels]      )
       self.check_loss_output(lowerCamelCase      )
      def 	UpperCAmelCase_						(			self   :Union[str, Any] ,      lowerCamelCase   :Tuple ,      lowerCamelCase   :Dict ,      lowerCamelCase   :Union[str, Any] ,      lowerCamelCase   :int ,      lowerCamelCase   :Optional[Any] ,      lowerCamelCase   :Tuple ,      lowerCamelCase   :Union[str, Any]      )     ->			Any:
       UpperCAmelCase__							 =						self.num_labels
       UpperCAmelCase__							 =						DebertaForTokenClassification(config=lowerCamelCase      )
       model.to(lowerCamelCase      )
       model.eval()
       UpperCAmelCase__							 =						model(lowerCamelCase ,      attention_mask=lowerCamelCase ,      token_type_ids=lowerCamelCase ,      labels=lowerCamelCase      )
       self.parent.assertEqual(result.logits.shape ,      (self.batch_size, self.seq_length, self.num_labels)      )
      def 	UpperCAmelCase_						(			self   :Tuple ,      lowerCamelCase   :str ,      lowerCamelCase   :Optional[int] ,      lowerCamelCase   :int ,      lowerCamelCase   :List[str] ,      lowerCamelCase   :int ,      lowerCamelCase   :str ,      lowerCamelCase   :Optional[int]      )     ->			List[Any]:
       UpperCAmelCase__							 =						DebertaForQuestionAnswering(config=lowerCamelCase      )
       model.to(lowerCamelCase      )
       model.eval()
       UpperCAmelCase__							 =						model(
           lowerCamelCase ,      attention_mask=lowerCamelCase ,      token_type_ids=lowerCamelCase ,      start_positions=lowerCamelCase ,      end_positions=lowerCamelCase ,      )
       self.parent.assertEqual(result.start_logits.shape ,      (self.batch_size, self.seq_length)      )
       self.parent.assertEqual(result.end_logits.shape ,      (self.batch_size, self.seq_length)      )







      def 	UpperCAmelCase_						(			self   :Union[str, Any]      )     ->			str:
       UpperCAmelCase__							 =						self.prepare_config_and_inputs()
       (
           (
           UpperCAmelCase__
       ) , (
           UpperCAmelCase__
       ) , (
           UpperCAmelCase__
       ) , (
           UpperCAmelCase__
       ) , (
           UpperCAmelCase__
       ) , (
           UpperCAmelCase__
       ) , (
           UpperCAmelCase__
       ) , 
       )							 =						config_and_inputs
       UpperCAmelCase__							 =						{"input_ids": input_ids, "token_type_ids": token_type_ids, "attention_mask": input_mask}
       return config, inputs_dict



@require_torch
class 			_UpperCamelCase      (				lowerCAmelCase	,       lowerCAmelCase	,       unittest.TestCase		):
      UpperCAmelCase_        =		(
          (
              DebertaModel,
              DebertaForMaskedLM,
              DebertaForSequenceClassification,
              DebertaForTokenClassification,
              DebertaForQuestionAnswering,
          )
          if is_torch_available()
          else ()
      )
      UpperCAmelCase_        =		(
          {
              """feature-extraction""": DebertaModel,
              """fill-mask""": DebertaForMaskedLM,
              """question-answering""": DebertaForQuestionAnswering,
              """text-classification""": DebertaForSequenceClassification,
              """token-classification""": DebertaForTokenClassification,
              """zero-shot""": DebertaForSequenceClassification,
          }
          if is_torch_available()
          else {}
      )

      UpperCAmelCase_        =		True
      UpperCAmelCase_        =		False
      UpperCAmelCase_        =		False
      UpperCAmelCase_        =		False
      UpperCAmelCase_        =		False
      def 	UpperCAmelCase_						(			self   :Any      )     ->			Union[str, Any]:
       UpperCAmelCase__							 =						DebertaModelTester(self      )
       UpperCAmelCase__							 =						ConfigTester(self ,      config_class=lowerCamelCase ,      hidden_size=37      )
      def 	UpperCAmelCase_						(			self   :Tuple      )     ->			List[str]:
       self.config_tester.run_common_tests()
      def 	UpperCAmelCase_						(			self   :Optional[Any]      )     ->			List[str]:
       UpperCAmelCase__							 =						self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_deberta_model(*lowerCamelCase      )
      def 	UpperCAmelCase_						(			self   :Optional[Any]      )     ->			Dict:
       UpperCAmelCase__							 =						self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_deberta_for_sequence_classification(*lowerCamelCase      )
      def 	UpperCAmelCase_						(			self   :List[str]      )     ->			Tuple:
       UpperCAmelCase__							 =						self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_deberta_for_masked_lm(*lowerCamelCase      )
      def 	UpperCAmelCase_						(			self   :Union[str, Any]      )     ->			int:
       UpperCAmelCase__							 =						self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_deberta_for_question_answering(*lowerCamelCase      )
      def 	UpperCAmelCase_						(			self   :List[str]      )     ->			Optional[Any]:
       UpperCAmelCase__							 =						self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_deberta_for_token_classification(*lowerCamelCase      )







      @slow
      def 	UpperCAmelCase_						(			self   :Union[str, Any]      )     ->			Optional[int]:
       for model_name in DEBERTA_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
        UpperCAmelCase__							 =						DebertaModel.from_pretrained(lowerCamelCase      )
        self.assertIsNotNone(lowerCamelCase      )



@require_torch
@require_sentencepiece
@require_tokenizers
class 			_UpperCamelCase      (				unittest.TestCase		):
      @unittest.skip(reason="Model not available yet"      )
      def 	UpperCAmelCase_						(			self   :Tuple      )     ->			Tuple:
       pass







      @slow
      def 	UpperCAmelCase_						(			self   :List[Any]      )     ->			Optional[int]:
       UpperCAmelCase__							 =						DebertaModel.from_pretrained("microsoft/deberta-base"      )

       UpperCAmelCase__							 =						torch.tensor([[0, 3_1414, 232, 328, 740, 1140, 1_2695, 69, 4_6078, 1588, 2]]      )
       UpperCAmelCase__							 =						torch.tensor([[0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]]      )
       with torch.no_grad():
        UpperCAmelCase__							 =						model(lowerCamelCase ,      attention_mask=lowerCamelCase      )[0]
       # compare the actual values for a slice.
       UpperCAmelCase__							 =						torch.tensor(
           [[[-0.59_86, -0.80_55, -0.84_62], [1.44_84, -0.93_48, -0.80_59], [0.31_23, 0.00_32, -1.41_31]]]      )
       self.assertTrue(torch.allclose(output[:, 1:4, 1:4] ,      lowerCamelCase ,      atol=1e-4      ) ,      f'''{output[:, 1:4, 1:4]}'''      )











from ..utils import DummyObject, requires_backends
class 			_UpperCamelCase      (				metaclass=lowerCAmelCase		):
      UpperCAmelCase_        =		["""flax"""]
      def __init__(			self   :List[Any] ,      *lowerCamelCase   :int ,      **lowerCamelCase   :List[Any]      )     ->			Dict:
       requires_backends(self ,      ["flax"]      )
      @classmethod
      def 	UpperCAmelCase_						(			cls   :Union[str, Any] ,      *lowerCamelCase   :Any ,      **lowerCamelCase   :List[str]      )     ->			int:
       requires_backends(cls ,      ["flax"]      )







      @classmethod
      def 	UpperCAmelCase_						(			cls   :Optional[int] ,      *lowerCamelCase   :List[str] ,      **lowerCamelCase   :List[Any]      )     ->			Dict:
       requires_backends(cls ,      ["flax"]      )



class 			_UpperCamelCase      (				metaclass=lowerCAmelCase		):
      UpperCAmelCase_        =		["""flax"""]
      def __init__(			self   :Dict ,      *lowerCamelCase   :int ,      **lowerCamelCase   :str      )     ->			str:
       requires_backends(self ,      ["flax"]      )
      @classmethod
      def 	UpperCAmelCase_						(			cls   :Optional[int] ,      *lowerCamelCase   :Tuple ,      **lowerCamelCase   :List[Any]      )     ->			Optional[int]:
       requires_backends(cls ,      ["flax"]      )







      @classmethod
      def 	UpperCAmelCase_						(			cls   :Optional[Any] ,      *lowerCamelCase   :Dict ,      **lowerCamelCase   :Optional[int]      )     ->			List[Any]:
       requires_backends(cls ,      ["flax"]      )



class 			_UpperCamelCase      (				metaclass=lowerCAmelCase		):
      UpperCAmelCase_        =		["""flax"""]
      def __init__(			self   :List[str] ,      *lowerCamelCase   :Union[str, Any] ,      **lowerCamelCase   :Any      )     ->			Union[str, Any]:
       requires_backends(self ,      ["flax"]      )
      @classmethod
      def 	UpperCAmelCase_						(			cls   :List[Any] ,      *lowerCamelCase   :str ,      **lowerCamelCase   :List[Any]      )     ->			Tuple:
       requires_backends(cls ,      ["flax"]      )







      @classmethod
      def 	UpperCAmelCase_						(			cls   :str ,      *lowerCamelCase   :Any ,      **lowerCamelCase   :Dict      )     ->			int:
       requires_backends(cls ,      ["flax"]      )



class 			_UpperCamelCase      (				metaclass=lowerCAmelCase		):
      UpperCAmelCase_        =		["""flax"""]
      def __init__(			self   :Union[str, Any] ,      *lowerCamelCase   :int ,      **lowerCamelCase   :Dict      )     ->			List[Any]:
       requires_backends(self ,      ["flax"]      )
      @classmethod
      def 	UpperCAmelCase_						(			cls   :int ,      *lowerCamelCase   :Union[str, Any] ,      **lowerCamelCase   :str      )     ->			Optional[int]:
       requires_backends(cls ,      ["flax"]      )







      @classmethod
      def 	UpperCAmelCase_						(			cls   :List[str] ,      *lowerCamelCase   :Optional[int] ,      **lowerCamelCase   :Tuple      )     ->			Dict:
       requires_backends(cls ,      ["flax"]      )



class 			_UpperCamelCase      (				metaclass=lowerCAmelCase		):
      UpperCAmelCase_        =		["""flax"""]
      def __init__(			self   :Union[str, Any] ,      *lowerCamelCase   :Any ,      **lowerCamelCase   :List[str]      )     ->			Union[str, Any]:
       requires_backends(self ,      ["flax"]      )
      @classmethod
      def 	UpperCAmelCase_						(			cls   :Optional[Any] ,      *lowerCamelCase   :Union[str, Any] ,      **lowerCamelCase   :Optional[Any]      )     ->			Optional[int]:
       requires_backends(cls ,      ["flax"]      )







      @classmethod
      def 	UpperCAmelCase_						(			cls   :List[Any] ,      *lowerCamelCase   :Dict ,      **lowerCamelCase   :Optional[int]      )     ->			List[str]:
       requires_backends(cls ,      ["flax"]      )



class 			_UpperCamelCase      (				metaclass=lowerCAmelCase		):
      UpperCAmelCase_        =		["""flax"""]
      def __init__(			self   :Tuple ,      *lowerCamelCase   :str ,      **lowerCamelCase   :List[str]      )     ->			List[Any]:
       requires_backends(self ,      ["flax"]      )
      @classmethod
      def 	UpperCAmelCase_						(			cls   :Any ,      *lowerCamelCase   :List[str] ,      **lowerCamelCase   :Any      )     ->			int:
       requires_backends(cls ,      ["flax"]      )







      @classmethod
      def 	UpperCAmelCase_						(			cls   :List[Any] ,      *lowerCamelCase   :List[Any] ,      **lowerCamelCase   :Optional[Any]      )     ->			Tuple:
       requires_backends(cls ,      ["flax"]      )



class 			_UpperCamelCase      (				metaclass=lowerCAmelCase		):
      UpperCAmelCase_        =		["""flax"""]
      def __init__(			self   :Any ,      *lowerCamelCase   :List[Any] ,      **lowerCamelCase   :List[str]      )     ->			List[str]:
       requires_backends(self ,      ["flax"]      )
      @classmethod
      def 	UpperCAmelCase_						(			cls   :Optional[Any] ,      *lowerCamelCase   :Optional[int] ,      **lowerCamelCase   :Dict      )     ->			Union[str, Any]:
       requires_backends(cls ,      ["flax"]      )







      @classmethod
      def 	UpperCAmelCase_						(			cls   :int ,      *lowerCamelCase   :List[Any] ,      **lowerCamelCase   :str      )     ->			str:
       requires_backends(cls ,      ["flax"]      )



class 			_UpperCamelCase      (				metaclass=lowerCAmelCase		):
      UpperCAmelCase_        =		["""flax"""]
      def __init__(			self   :str ,      *lowerCamelCase   :Any ,      **lowerCamelCase   :Union[str, Any]      )     ->			Optional[Any]:
       requires_backends(self ,      ["flax"]      )
      @classmethod
      def 	UpperCAmelCase_						(			cls   :Optional[Any] ,      *lowerCamelCase   :Any ,      **lowerCamelCase   :List[str]      )     ->			int:
       requires_backends(cls ,      ["flax"]      )







      @classmethod
      def 	UpperCAmelCase_						(			cls   :List[Any] ,      *lowerCamelCase   :Union[str, Any] ,      **lowerCamelCase   :Union[str, Any]      )     ->			List[Any]:
       requires_backends(cls ,      ["flax"]      )



class 			_UpperCamelCase      (				metaclass=lowerCAmelCase		):
      UpperCAmelCase_        =		["""flax"""]
      def __init__(			self   :Dict ,      *lowerCamelCase   :Dict ,      **lowerCamelCase   :int      )     ->			List[Any]:
       requires_backends(self ,      ["flax"]      )
      @classmethod
      def 	UpperCAmelCase_						(			cls   :Tuple ,      *lowerCamelCase   :Optional[Any] ,      **lowerCamelCase   :Optional[int]      )     ->			Dict:
       requires_backends(cls ,      ["flax"]      )







      @classmethod
      def 	UpperCAmelCase_						(			cls   :Any ,      *lowerCamelCase   :Optional[int] ,      **lowerCamelCase   :List[str]      )     ->			List[Any]:
       requires_backends(cls ,      ["flax"]      )



class 			_UpperCamelCase      (				metaclass=lowerCAmelCase		):
      UpperCAmelCase_        =		["""flax"""]
      def __init__(			self   :List[Any] ,      *lowerCamelCase   :int ,      **lowerCamelCase   :Optional[Any]      )     ->			List[str]:
       requires_backends(self ,      ["flax"]      )
      @classmethod
      def 	UpperCAmelCase_						(			cls   :int ,      *lowerCamelCase   :List[Any] ,      **lowerCamelCase   :List[Any]      )     ->			Any:
       requires_backends(cls ,      ["flax"]      )







      @classmethod
      def 	UpperCAmelCase_						(			cls   :str ,      *lowerCamelCase   :Optional[int] ,      **lowerCamelCase   :str      )     ->			List[str]:
       requires_backends(cls ,      ["flax"]      )



class 			_UpperCamelCase      (				metaclass=lowerCAmelCase		):
      UpperCAmelCase_        =		["""flax"""]
      def __init__(			self   :List[Any] ,      *lowerCamelCase   :str ,      **lowerCamelCase   :int      )     ->			List[Any]:
       requires_backends(self ,      ["flax"]      )
      @classmethod
      def 	UpperCAmelCase_						(			cls   :List[str] ,      *lowerCamelCase   :List[Any] ,      **lowerCamelCase   :Any      )     ->			List[Any]:
       requires_backends(cls ,      ["flax"]      )







      @classmethod
      def 	UpperCAmelCase_						(			cls   :Optional[Any] ,      *lowerCamelCase   :Any ,      **lowerCamelCase   :Tuple      )     ->			int:
       requires_backends(cls ,      ["flax"]      )



class 			_UpperCamelCase      (				metaclass=lowerCAmelCase		):
      UpperCAmelCase_        =		["""flax"""]
      def __init__(			self   :Any ,      *lowerCamelCase   :List[Any] ,      **lowerCamelCase   :Tuple      )     ->			Dict:
       requires_backends(self ,      ["flax"]      )
      @classmethod
      def 	UpperCAmelCase_						(			cls   :List[Any] ,      *lowerCamelCase   :int ,      **lowerCamelCase   :Union[str, Any]      )     ->			List[Any]:
       requires_backends(cls ,      ["flax"]      )







      @classmethod
      def 	UpperCAmelCase_						(			cls   :str ,      *lowerCamelCase   :int ,      **lowerCamelCase   :List[str]      )     ->			List[str]:
       requires_backends(cls ,      ["flax"]      )



class 			_UpperCamelCase      (				metaclass=lowerCAmelCase		):
      UpperCAmelCase_        =		["""flax"""]
      def __init__(			self   :int ,      *lowerCamelCase   :Dict ,      **lowerCamelCase   :Optional[int]      )     ->			str:
       requires_backends(self ,      ["flax"]      )
      @classmethod
      def 	UpperCAmelCase_						(			cls   :Union[str, Any] ,      *lowerCamelCase   :Any ,      **lowerCamelCase   :Union[str, Any]      )     ->			Optional[int]:
       requires_backends(cls ,      ["flax"]      )







      @classmethod
      def 	UpperCAmelCase_						(			cls   :int ,      *lowerCamelCase   :Union[str, Any] ,      **lowerCamelCase   :Any      )     ->			Optional[Any]:
       requires_backends(cls ,      ["flax"]      )





