






'''simple docstring'''



from collections import OrderedDict
from typing import Any, Mapping, Optional

from ... import PreTrainedTokenizer
from ...configuration_utils import PretrainedConfig
from ...file_utils import TensorType, is_torch_available
from ...onnx import OnnxConfig, OnnxConfigWithPast, OnnxSeqaSeqConfigWithPast
from ...onnx.utils import compute_effective_axis_dimension
from ...utils import logging


SCREAMING_SNAKE_CASE							=						logging.get_logger(__name__)

SCREAMING_SNAKE_CASE							=						{
    'facebook/blenderbot_small-90M': 'https://huggingface.co/facebook/blenderbot_small-90M/resolve/main/config.json',
    # See all BlenderbotSmall models at https://huggingface.co/models?filter=blenderbot_small
}
class UpperCAmelCase_       (     __A					):




      """simple docstring"""




      UpperCamelCase_             =      '''blenderbot-small'''
      UpperCamelCase_             =      ['''past_key_values''']
      UpperCamelCase_             =      {'''num_attention_heads''': '''encoder_attention_heads''', '''hidden_size''': '''d_model'''}






      def __init__(			self      :		Union[str, Any]  ,   UpperCAmelCase      :		Dict=5_0265  ,   UpperCAmelCase      :		List[Any]=512  ,   UpperCAmelCase      :		Tuple=8  ,   UpperCAmelCase      :		Union[str, Any]=2048  ,   UpperCAmelCase      :		Dict=16  ,   UpperCAmelCase      :		Any=8  ,   UpperCAmelCase      :		List[Any]=2048  ,   UpperCAmelCase      :		str=16  ,   UpperCAmelCase      :		Dict=0.0  ,   UpperCAmelCase      :		Union[str, Any]=0.0  ,   UpperCAmelCase      :		str=True  ,   UpperCAmelCase      :		Optional[Any]=True  ,   UpperCAmelCase      :		Union[str, Any]="gelu"  ,   UpperCAmelCase      :		Optional[Any]=512  ,   UpperCAmelCase      :		Any=0.1  ,   UpperCAmelCase      :		Dict=0.0  ,   UpperCAmelCase      :		str=0.0  ,   UpperCAmelCase      :		Union[str, Any]=0.0_2  ,   UpperCAmelCase      :		List[Any]=1  ,   UpperCAmelCase      :		List[Any]=False  ,   UpperCAmelCase      :		Tuple=0  ,   UpperCAmelCase      :		Optional[int]=1  ,   UpperCAmelCase      :		Optional[int]=2  ,   UpperCAmelCase      :		List[str]=2  ,   **UpperCAmelCase      :		List[Any]  ,   )	->	Dict:


       '''simple docstring'''

       lowercase       : Tuple						=vocab_size
       lowercase       : List[str]						=max_position_embeddings
       lowercase       : str						=d_model
       lowercase       : Tuple						=encoder_ffn_dim
       lowercase       : Dict						=encoder_layers
       lowercase       : Dict						=encoder_attention_heads
       lowercase       : Optional[int]						=decoder_ffn_dim
       lowercase       : List[str]						=decoder_layers
       lowercase       : Tuple						=decoder_attention_heads
       lowercase       : Optional[Any]						=dropout
       lowercase       : Dict						=attention_dropout
       lowercase       : List[Any]						=activation_dropout
       lowercase       : Any						=activation_function
       lowercase       : str						=init_std
       lowercase       : str						=encoder_layerdrop
       lowercase       : Union[str, Any]						=decoder_layerdrop
       lowercase       : Optional[Any]						=use_cache
       lowercase       : Tuple						=encoder_layers
       lowercase       : Tuple						=scale_embedding  # scale factor will be sqrt(d_model) if True

       super().__init__(
           pad_token_id=UpperCAmelCase  ,   bos_token_id=UpperCAmelCase  ,   eos_token_id=UpperCAmelCase  ,   is_encoder_decoder=UpperCAmelCase  ,   decoder_start_token_id=UpperCAmelCase  ,   forced_eos_token_id=UpperCAmelCase  ,   **UpperCAmelCase  ,   )





class UpperCAmelCase_       (     __A					):




      """simple docstring"""




      @property
      def 					A__   (			self      :		int		)	->	Mapping[str, Mapping[int, str]]:


       '''simple docstring'''

       if self.task in ["default", "seq2seq-lm"]:
        lowercase       : Optional[Any]						=OrderedDict(
            [
                ('''input_ids''', {0: '''batch''', 1: '''encoder_sequence'''}),
                ('''attention_mask''', {0: '''batch''', 1: '''encoder_sequence'''}),
            ]		)

        if self.use_past:
         lowercase       : str						={0: '''batch'''}
         lowercase       : List[str]						={0: '''batch''', 1: '''past_decoder_sequence + sequence'''}
        else:
         lowercase       : List[str]						={0: '''batch''', 1: '''decoder_sequence'''}
         lowercase       : Optional[int]						={0: '''batch''', 1: '''decoder_sequence'''}

        if self.use_past:
         self.fill_with_past_key_values_(UpperCAmelCase  ,   direction='''inputs'''		)
       elif self.task == "causal-lm":
        # TODO: figure this case out.
        lowercase       : Any						=OrderedDict(
            [
                ('''input_ids''', {0: '''batch''', 1: '''encoder_sequence'''}),
                ('''attention_mask''', {0: '''batch''', 1: '''encoder_sequence'''}),
            ]		)
        if self.use_past:
         lowercase	,		lowercase       : Union[str, Any]						=self.num_layers
         for i in range(UpperCAmelCase		):
          lowercase       : Optional[int]						={0: '''batch''', 2: '''past_sequence + sequence'''}
          lowercase       : str						={0: '''batch''', 2: '''past_sequence + sequence'''}
       else:
        lowercase       : int						=OrderedDict(
            [
                ('''input_ids''', {0: '''batch''', 1: '''encoder_sequence'''}),
                ('''attention_mask''', {0: '''batch''', 1: '''encoder_sequence'''}),
                ('''decoder_input_ids''', {0: '''batch''', 1: '''decoder_sequence'''}),
                ('''decoder_attention_mask''', {0: '''batch''', 1: '''decoder_sequence'''}),
            ]		)

       return common_inputs






      @property
      def 					A__   (			self      :		int		)	->	Mapping[str, Mapping[int, str]]:


       '''simple docstring'''

       if self.task in ["default", "seq2seq-lm"]:
        lowercase       : Tuple						=super().outputs
       else:
        lowercase       : Any						=super(UpperCAmelCase  ,   self		).outputs
        if self.use_past:
         lowercase	,		lowercase       : Any						=self.num_layers
         for i in range(UpperCAmelCase		):
          lowercase       : Any						={0: '''batch''', 2: '''past_sequence + sequence'''}
          lowercase       : str						={0: '''batch''', 2: '''past_sequence + sequence'''}
       return common_outputs






      def 					A__   (			self      :		Optional[Any]  ,   UpperCAmelCase      :		PreTrainedTokenizer  ,   UpperCAmelCase      :		int = -1  ,   UpperCAmelCase      :		int = -1  ,   UpperCAmelCase      :		bool = False  ,   UpperCAmelCase      :		Optional[TensorType] = None  ,   )	->	Mapping[str, Any]:


       '''simple docstring'''

       lowercase       : str						=self._generate_dummy_inputs_for_sequence_classification_and_question_answering(
           UpperCAmelCase  ,   UpperCAmelCase  ,   UpperCAmelCase  ,   UpperCAmelCase  ,   UpperCAmelCase		)

       # Generate decoder inputs
       lowercase       : str						=seq_length if not self.use_past else 1
       lowercase       : str						=self._generate_dummy_inputs_for_sequence_classification_and_question_answering(
           UpperCAmelCase  ,   UpperCAmelCase  ,   UpperCAmelCase  ,   UpperCAmelCase  ,   UpperCAmelCase		)
       lowercase       : Union[str, Any]						={f'decoder_{name}': tensor for name, tensor in decoder_inputs.items()}
       lowercase       : str						=dict(**UpperCAmelCase  ,   **UpperCAmelCase		)

       if self.use_past:
        if not is_torch_available():
         raise ValueError('''Cannot generate dummy past_keys inputs without PyTorch installed.'''		)
        else:
         import torch
        lowercase	,		lowercase       : int						=common_inputs['''input_ids'''].shape
        lowercase       : str						=common_inputs['''decoder_input_ids'''].shape[1]
        lowercase	,		lowercase       : List[Any]						=self.num_attention_heads
        lowercase       : Union[str, Any]						=(
            batch,
            num_encoder_attention_heads,
            encoder_seq_length,
            self._config.hidden_size // num_encoder_attention_heads,
        )
        lowercase       : Dict						=decoder_seq_length + 3
        lowercase       : List[str]						=(
            batch,
            num_decoder_attention_heads,
            decoder_past_length,
            self._config.hidden_size // num_decoder_attention_heads,
        )

        lowercase       : Dict						=torch.cat(
            [common_inputs['''decoder_attention_mask'''], torch.ones(UpperCAmelCase  ,   UpperCAmelCase		)]  ,   dim=1		)

        lowercase       : List[Any]						=[]
        # If the number of encoder and decoder layers are present in the model configuration, both are considered
        lowercase	,		lowercase       : Union[str, Any]						=self.num_layers
        lowercase       : Optional[int]						=min(UpperCAmelCase  ,   UpperCAmelCase		)
        lowercase       : List[Any]						=max(UpperCAmelCase  ,   UpperCAmelCase		) - min_num_layers
        lowercase       : str						='''encoder''' if num_encoder_layers > num_decoder_layers else '''decoder'''

        for _ in range(UpperCAmelCase		):
         common_inputs["past_key_values"].append(
             (
                 torch.zeros(UpperCAmelCase		),
                 torch.zeros(UpperCAmelCase		),
                 torch.zeros(UpperCAmelCase		),
                 torch.zeros(UpperCAmelCase		),
             )		)
        # TODO: test this.
        lowercase       : List[Any]						=encoder_shape if remaining_side_name == '''encoder''' else decoder_shape
        for _ in range(UpperCAmelCase  ,   UpperCAmelCase		):
         common_inputs["past_key_values"].append((torch.zeros(UpperCAmelCase		), torch.zeros(UpperCAmelCase		))		)
       return common_inputs






      def 					A__   (			self      :		int  ,   UpperCAmelCase      :		PreTrainedTokenizer  ,   UpperCAmelCase      :		int = -1  ,   UpperCAmelCase      :		int = -1  ,   UpperCAmelCase      :		bool = False  ,   UpperCAmelCase      :		Optional[TensorType] = None  ,   )	->	Mapping[str, Any]:


       '''simple docstring'''

       lowercase       : List[Any]						=self._generate_dummy_inputs_for_sequence_classification_and_question_answering(
           UpperCAmelCase  ,   UpperCAmelCase  ,   UpperCAmelCase  ,   UpperCAmelCase  ,   UpperCAmelCase		)

       if self.use_past:
        if not is_torch_available():
         raise ValueError('''Cannot generate dummy past_keys inputs without PyTorch installed.'''		)
        else:
         import torch
        lowercase	,		lowercase       : List[Any]						=common_inputs['''input_ids'''].shape
        # Not using the same length for past_key_values
        lowercase       : Any						=seqlen + 2
        lowercase	,		lowercase       : Optional[int]						=self.num_layers
        lowercase	,		lowercase       : Union[str, Any]						=self.num_attention_heads
        lowercase       : List[str]						=(
            batch,
            num_encoder_attention_heads,
            past_key_values_length,
            self._config.hidden_size // num_encoder_attention_heads,
        )

        lowercase       : int						=common_inputs['''attention_mask'''].dtype
        lowercase       : Tuple						=torch.cat(
            [common_inputs['''attention_mask'''], torch.ones(UpperCAmelCase  ,   UpperCAmelCase  ,   dtype=UpperCAmelCase		)]  ,   dim=1		)
        lowercase       : Dict						=[
            (torch.zeros(UpperCAmelCase		), torch.zeros(UpperCAmelCase		)) for _ in range(UpperCAmelCase		)
        ]
       return common_inputs






      def 					A__   (			self      :		Union[str, Any]  ,   UpperCAmelCase      :		PreTrainedTokenizer  ,   UpperCAmelCase      :		int = -1  ,   UpperCAmelCase      :		int = -1  ,   UpperCAmelCase      :		bool = False  ,   UpperCAmelCase      :		Optional[TensorType] = None  ,   )	->	Mapping[str, Any]:


       '''simple docstring'''

       lowercase       : Tuple						=compute_effective_axis_dimension(
           UpperCAmelCase  ,   fixed_dimension=OnnxConfig.default_fixed_batch  ,   num_token_to_add=0		)

       # If dynamic axis (-1) we forward with a fixed dimension of 8 tokens to avoid optimizations made by ONNX
       lowercase       : int						=tokenizer.num_special_tokens_to_add(UpperCAmelCase		)
       lowercase       : Optional[int]						=compute_effective_axis_dimension(
           UpperCAmelCase  ,   fixed_dimension=OnnxConfig.default_fixed_sequence  ,   num_token_to_add=UpperCAmelCase		)

       # Generate dummy inputs according to compute batch and sequence
       lowercase       : List[str]						=[''' '''.join([tokenizer.unk_token]		) * seq_length] * batch_size
       lowercase       : Dict						=dict(tokenizer(UpperCAmelCase  ,   return_tensors=UpperCAmelCase		)		)
       return common_inputs






      def 					A__   (			self      :		Optional[Any]  ,   UpperCAmelCase      :		PreTrainedTokenizer  ,   UpperCAmelCase      :		int = -1  ,   UpperCAmelCase      :		int = -1  ,   UpperCAmelCase      :		bool = False  ,   UpperCAmelCase      :		Optional[TensorType] = None  ,   )	->	Mapping[str, Any]:


       '''simple docstring'''

       if self.task in ["default", "seq2seq-lm"]:
        lowercase       : Any						=self._generate_dummy_inputs_for_default_and_seqaseq_lm(
            UpperCAmelCase  ,   batch_size=UpperCAmelCase  ,   seq_length=UpperCAmelCase  ,   is_pair=UpperCAmelCase  ,   framework=UpperCAmelCase		)

       elif self.task == "causal-lm":
        lowercase       : Dict						=self._generate_dummy_inputs_for_causal_lm(
            UpperCAmelCase  ,   batch_size=UpperCAmelCase  ,   seq_length=UpperCAmelCase  ,   is_pair=UpperCAmelCase  ,   framework=UpperCAmelCase		)
       else:
        lowercase       : Union[str, Any]						=self._generate_dummy_inputs_for_sequence_classification_and_question_answering(
            UpperCAmelCase  ,   batch_size=UpperCAmelCase  ,   seq_length=UpperCAmelCase  ,   is_pair=UpperCAmelCase  ,   framework=UpperCAmelCase		)

       return common_inputs






      def 					A__   (			self      :		List[Any]  ,   UpperCAmelCase      :		str  ,   UpperCAmelCase      :		Any  ,   UpperCAmelCase      :		str  ,   UpperCAmelCase      :		Dict		)	->	str:


       '''simple docstring'''

       if self.task in ["default", "seq2seq-lm"]:
        lowercase       : Any						=super()._flatten_past_key_values_(UpperCAmelCase  ,   UpperCAmelCase  ,   UpperCAmelCase  ,   UpperCAmelCase		)
       else:
        lowercase       : Optional[int]						=super(UpperCAmelCase  ,   self		)._flatten_past_key_values_(
            UpperCAmelCase  ,   UpperCAmelCase  ,   UpperCAmelCase  ,   UpperCAmelCase		)











'''simple docstring'''



from ..utils import DummyObject, requires_backends
class UpperCAmelCase_       (     metaclass=__A					):




      """simple docstring"""




      UpperCamelCase_             =      ['''flax''']






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


       '''simple docstring'''

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






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


       '''simple docstring'''

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






      @classmethod
      def 					A__   (			cls      :		Dict  ,   *UpperCAmelCase      :		str  ,   **UpperCAmelCase      :		Any		)	->	Any:


       '''simple docstring'''

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





class UpperCAmelCase_       (     metaclass=__A					):




      """simple docstring"""




      UpperCamelCase_             =      ['''flax''']






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


       '''simple docstring'''

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






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


       '''simple docstring'''

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






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


       '''simple docstring'''

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





class UpperCAmelCase_       (     metaclass=__A					):




      """simple docstring"""




      UpperCamelCase_             =      ['''flax''']






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


       '''simple docstring'''

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






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


       '''simple docstring'''

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






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


       '''simple docstring'''

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





class UpperCAmelCase_       (     metaclass=__A					):




      """simple docstring"""




      UpperCamelCase_             =      ['''flax''']






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


       '''simple docstring'''

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






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


       '''simple docstring'''

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






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


       '''simple docstring'''

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





class UpperCAmelCase_       (     metaclass=__A					):




      """simple docstring"""




      UpperCamelCase_             =      ['''flax''']






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


       '''simple docstring'''

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






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


       '''simple docstring'''

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






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


       '''simple docstring'''

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





class UpperCAmelCase_       (     metaclass=__A					):




      """simple docstring"""




      UpperCamelCase_             =      ['''flax''']






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


       '''simple docstring'''

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






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


       '''simple docstring'''

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






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


       '''simple docstring'''

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





class UpperCAmelCase_       (     metaclass=__A					):




      """simple docstring"""




      UpperCamelCase_             =      ['''flax''']






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


       '''simple docstring'''

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






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


       '''simple docstring'''

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






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


       '''simple docstring'''

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





class UpperCAmelCase_       (     metaclass=__A					):




      """simple docstring"""




      UpperCamelCase_             =      ['''flax''']






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


       '''simple docstring'''

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






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


       '''simple docstring'''

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






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


       '''simple docstring'''

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





class UpperCAmelCase_       (     metaclass=__A					):




      """simple docstring"""




      UpperCamelCase_             =      ['''flax''']






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


       '''simple docstring'''

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






      @classmethod
      def 					A__   (			cls      :		Tuple  ,   *UpperCAmelCase      :		List[str]  ,   **UpperCAmelCase      :		Optional[int]		)	->	List[str]:


       '''simple docstring'''

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






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


       '''simple docstring'''

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





class UpperCAmelCase_       (     metaclass=__A					):




      """simple docstring"""




      UpperCamelCase_             =      ['''flax''']






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


       '''simple docstring'''

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






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


       '''simple docstring'''

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






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


       '''simple docstring'''

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





class UpperCAmelCase_       (     metaclass=__A					):




      """simple docstring"""




      UpperCamelCase_             =      ['''flax''']






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


       '''simple docstring'''

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






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


       '''simple docstring'''

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






      @classmethod
      def 					A__   (			cls      :		str  ,   *UpperCAmelCase      :		str  ,   **UpperCAmelCase      :		Any		)	->	int:


       '''simple docstring'''

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





class UpperCAmelCase_       (     metaclass=__A					):




      """simple docstring"""




      UpperCamelCase_             =      ['''flax''']






      def __init__(			self      :		Optional[int]  ,   *UpperCAmelCase      :		str  ,   **UpperCAmelCase      :		Any		)	->	Optional[int]:


       '''simple docstring'''

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






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


       '''simple docstring'''

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






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


       '''simple docstring'''

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





class UpperCAmelCase_       (     metaclass=__A					):




      """simple docstring"""




      UpperCamelCase_             =      ['''flax''']






      def __init__(			self      :		Optional[Any]  ,   *UpperCAmelCase      :		str  ,   **UpperCAmelCase      :		int		)	->	Tuple:


       '''simple docstring'''

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






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


       '''simple docstring'''

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






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


       '''simple docstring'''

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



