





from typing import Dict, Iterable, List, Optional, Union

import numpy as np

from ...image_processing_utils import BaseImageProcessor, BatchFeature, get_size_dict
from ...image_transforms import (
    center_crop,
    get_resize_output_image_size,
    normalize,
    rescale,
    resize,
    to_channel_dimension_format,
)
from ...image_utils import (
    IMAGENET_DEFAULT_MEAN,
    IMAGENET_DEFAULT_STD,
    ChannelDimension,
    ImageInput,
    PILImageResampling,
    make_list_of_images,
    to_numpy_array,
    valid_images,
)
from ...utils import TensorType, logging


snake_case								=							logging.get_logger(__name__)





class 					A_					(   UpperCAmelCase						):







       """simple docstring"""





       SCREAMING_SNAKE_CASE_   :			Dict  			=	['''pixel_values''']







       def __init__(     self						:						Union[str, Any]    ,__A						:						bool = True    ,__A						:						Dict[str, int] = None    ,__A						:						PILImageResampling = PILImageResampling.BICUBIC    ,__A						:						bool = True    ,__A						:						Dict[str, int] = None    ,__A						:						bool = True    ,__A						:						Union[int, float] = 1 / 255    ,__A						:						bool = True    ,__A						:						Optional[Union[float, Iterable[float]]] = IMAGENET_DEFAULT_MEAN    ,__A						:						Optional[Union[float, Iterable[float]]] = IMAGENET_DEFAULT_STD    ,**__A						:						Optional[int]    ,)    ->       None:
         super().__init__(**__A	)
         _lowercase						    =			size if size is not None else {'shortest_edge': 224}
         _lowercase						    =			get_size_dict(__A    ,default_to_square=__A	)
         _lowercase						    =			crop_size if crop_size is not None else {'height': 224, 'width': 224}
         _lowercase						    =			get_size_dict(__A    ,param_name='crop_size'	)

         _lowercase						    =			do_resize
         _lowercase						    =			size
         _lowercase						    =			resample
         _lowercase						    =			do_center_crop
         _lowercase						    =			crop_size
         _lowercase						    =			do_rescale
         _lowercase						    =			rescale_factor
         _lowercase						    =			do_normalize
         _lowercase						    =			image_mean if image_mean is not None else IMAGENET_DEFAULT_MEAN
         _lowercase						    =			image_std if image_std is not None else IMAGENET_DEFAULT_STD







       def  __UpperCAmelCase			(     self						:						int    ,__A						:						np.ndarray    ,__A						:						Dict[str, int]    ,__A						:						PILImageResampling = PILImageResampling.BICUBIC    ,__A						:						Optional[Union[str, ChannelDimension]] = None    ,**__A						:						List[str]    ,)    ->       np.ndarray:
         _lowercase						    =			get_size_dict(__A    ,default_to_square=__A	)
         # size_dict is a dict with either keys "height" and "width" or "shortest_edge"
         if "shortest_edge" in size:
           _lowercase						    =			int((256 / 224) * size['shortest_edge']	)
           _lowercase						    =			get_resize_output_image_size(__A    ,size=__A    ,default_to_square=__A	)
           _lowercase						    =			{'height': output_size[0], 'width': output_size[1]}
         if "height" not in size_dict or "width" not in size_dict:
           raise ValueError(
               F"""Size dict must have keys 'height' and 'width' or 'shortest_edge'. Got {size_dict.keys()}"""	)
         return resize(
             __A    ,size=(size_dict['height'], size_dict['width'])    ,resample=__A    ,data_format=__A    ,**__A	)







       def  __UpperCAmelCase			(     self						:						int    ,__A						:						np.ndarray    ,__A						:						Dict[str, int]    ,__A						:						Optional[Union[str, ChannelDimension]] = None    ,**__A						:						Optional[int]    ,)    ->       np.ndarray:
         _lowercase						    =			get_size_dict(__A	)
         if "height" not in size or "width" not in size:
           raise ValueError(F"""Size dict must have keys 'height' and 'width'. Got {size.keys()}"""	)
         return center_crop(__A    ,size=(size['height'], size['width'])    ,data_format=__A    ,**__A	)







       def  __UpperCAmelCase			(     self						:						Optional[int]    ,__A						:						np.ndarray    ,__A						:						Union[int, float]    ,__A						:						Optional[Union[str, ChannelDimension]] = None    ,**__A						:						List[str]    ,)    ->       np.ndarray:
         return rescale(__A    ,scale=__A    ,data_format=__A    ,**__A	)







       def  __UpperCAmelCase			(     self						:						str    ,__A						:						np.ndarray    ,__A						:						Union[float, List[float]]    ,__A						:						Union[float, List[float]]    ,__A						:						Optional[Union[str, ChannelDimension]] = None    ,**__A						:						int    ,)    ->       np.ndarray:
         return normalize(__A    ,mean=__A    ,std=__A    ,data_format=__A    ,**__A	)







       def  __UpperCAmelCase			(     self						:						Dict    ,__A						:						ImageInput    ,__A						:						Optional[bool] = None    ,__A						:						Optional[Dict[str, int]] = None    ,__A						:						PILImageResampling = None    ,__A						:						Optional[bool] = None    ,__A						:						Optional[Dict[str, int]] = None    ,__A						:						Optional[bool] = None    ,__A						:						Optional[float] = None    ,__A						:						Optional[bool] = None    ,__A						:						Optional[Union[float, Iterable[float]]] = None    ,__A						:						Optional[Union[float, Iterable[float]]] = None    ,__A						:						Optional[TensorType] = None    ,__A						:						ChannelDimension = ChannelDimension.FIRST    ,**__A						:						Optional[Any]    ,)    ->       BatchFeature:
         _lowercase						    =			do_resize if do_resize is not None else self.do_resize
         _lowercase						    =			resample if resample is not None else self.resample
         _lowercase						    =			do_center_crop if do_center_crop is not None else self.do_center_crop
         _lowercase						    =			do_rescale if do_rescale is not None else self.do_rescale
         _lowercase						    =			rescale_factor if rescale_factor is not None else self.rescale_factor
         _lowercase						    =			do_normalize if do_normalize is not None else self.do_normalize
         _lowercase						    =			image_mean if image_mean is not None else self.image_mean
         _lowercase						    =			image_std if image_std is not None else self.image_std

         _lowercase						    =			size if size is not None else self.size
         _lowercase						    =			get_size_dict(__A    ,default_to_square=__A	)
         _lowercase						    =			crop_size if crop_size is not None else self.crop_size
         _lowercase						    =			get_size_dict(__A    ,param_name='crop_size'	)

         _lowercase						    =			make_list_of_images(__A	)

         if not valid_images(__A	):
           raise ValueError(
               'Invalid image type. Must be of type PIL.Image.Image, numpy.ndarray, '
               'torch.Tensor, tf.Tensor or jax.ndarray.'	)

         if do_resize and size is None:
           raise ValueError('Size must be specified if do_resize is True.'	)

         if do_center_crop and crop_size is None:
           raise ValueError('Crop size must be specified if do_center_crop is True.'	)

         if do_rescale and rescale_factor is None:
           raise ValueError('Rescale factor must be specified if do_rescale is True.'	)

         if do_normalize and (image_mean is None or image_std is None):
           raise ValueError('Image mean and std must be specified if do_normalize is True.'	)

         # All transformations expect numpy arrays.
         _lowercase						    =			[to_numpy_array(__A	) for image in images]

         if do_resize:
           _lowercase						    =			[self.resize(__A    ,__A    ,__A	) for image in images]

         if do_center_crop:
           _lowercase						    =			[self.center_crop(__A    ,__A	) for image in images]

         if do_rescale:
           _lowercase						    =			[self.rescale(__A    ,__A	) for image in images]

         if do_normalize:
           _lowercase						    =			[self.normalize(__A    ,__A    ,__A	) for image in images]

         _lowercase						    =			[to_channel_dimension_format(__A    ,__A	) for image in images]

         _lowercase						    =			{'pixel_values': images}
         return BatchFeature(data=__A    ,tensor_type=__A	)



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


lowerCAmelCase__    :List[Any]       =				logging.get_logger(__name__)

lowerCAmelCase__    :int       =				{
    '''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 						__a (							UpperCAmelCase     ):
		_a      :    Dict           =      'blenderbot-small'
		_a      :    Tuple           =      ['past_key_values']
		_a      :    List[str]           =      {'num_attention_heads': 'encoder_attention_heads', 'hidden_size': 'd_model'}
		def __init__(     self     ,       _SCREAMING_SNAKE_CASE=50265     ,       _SCREAMING_SNAKE_CASE=512     ,       _SCREAMING_SNAKE_CASE=8     ,       _SCREAMING_SNAKE_CASE=2048     ,       _SCREAMING_SNAKE_CASE=16     ,       _SCREAMING_SNAKE_CASE=8     ,       _SCREAMING_SNAKE_CASE=2048     ,       _SCREAMING_SNAKE_CASE=16     ,       _SCREAMING_SNAKE_CASE=0.0     ,       _SCREAMING_SNAKE_CASE=0.0     ,       _SCREAMING_SNAKE_CASE=True     ,       _SCREAMING_SNAKE_CASE=True     ,       _SCREAMING_SNAKE_CASE="gelu"     ,       _SCREAMING_SNAKE_CASE=512     ,       _SCREAMING_SNAKE_CASE=0.1     ,       _SCREAMING_SNAKE_CASE=0.0     ,       _SCREAMING_SNAKE_CASE=0.0     ,       _SCREAMING_SNAKE_CASE=0.02     ,       _SCREAMING_SNAKE_CASE=1     ,       _SCREAMING_SNAKE_CASE=False     ,       _SCREAMING_SNAKE_CASE=0     ,       _SCREAMING_SNAKE_CASE=1     ,       _SCREAMING_SNAKE_CASE=2     ,       _SCREAMING_SNAKE_CASE=2     ,       **_SCREAMING_SNAKE_CASE     ,       )					->			Dict:




									"""simple docstring"""





									_UpperCAmelCase											=     vocab_size
									_UpperCAmelCase											=     max_position_embeddings
									_UpperCAmelCase											=     d_model
									_UpperCAmelCase											=     encoder_ffn_dim
									_UpperCAmelCase											=     encoder_layers
									_UpperCAmelCase											=     encoder_attention_heads
									_UpperCAmelCase											=     decoder_ffn_dim
									_UpperCAmelCase											=     decoder_layers
									_UpperCAmelCase											=     decoder_attention_heads
									_UpperCAmelCase											=     dropout
									_UpperCAmelCase											=     attention_dropout
									_UpperCAmelCase											=     activation_dropout
									_UpperCAmelCase											=     activation_function
									_UpperCAmelCase											=     init_std
									_UpperCAmelCase											=     encoder_layerdrop
									_UpperCAmelCase											=     decoder_layerdrop
									_UpperCAmelCase											=     use_cache
									_UpperCAmelCase											=     encoder_layers
									_UpperCAmelCase											=     scale_embedding  # scale factor will be sqrt(d_model) if True

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



class 						__a (							UpperCAmelCase     ):
		@property
		def       UpperCAmelCase__							(     self		)					->			Mapping[str, Mapping[int, str]]:




									"""simple docstring"""





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

																if self.use_past:
																							_UpperCAmelCase											=     {0: 'batch'}
																							_UpperCAmelCase											=     {0: 'batch', 1: 'past_decoder_sequence + sequence'}
																else:
																							_UpperCAmelCase											=     {0: 'batch', 1: 'decoder_sequence'}
																							_UpperCAmelCase											=     {0: 'batch', 1: 'decoder_sequence'}

																if self.use_past:
																							self.fill_with_past_key_values_(_SCREAMING_SNAKE_CASE     ,       direction='inputs'		)
									elif self.task == "causal-lm":
																# TODO: figure this case out.
																_UpperCAmelCase											=     OrderedDict(
																    [
																        ('input_ids', {0: 'batch', 1: 'encoder_sequence'}),
																        ('attention_mask', {0: 'batch', 1: 'encoder_sequence'}),
																    ]		)
																if self.use_past:
																							_UpperCAmelCase						,			_UpperCAmelCase											=     self.num_layers
																							for i in range(_SCREAMING_SNAKE_CASE		):
																														_UpperCAmelCase											=     {0: 'batch', 2: 'past_sequence + sequence'}
																														_UpperCAmelCase											=     {0: 'batch', 2: 'past_sequence + sequence'}
									else:
																_UpperCAmelCase											=     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       UpperCAmelCase__							(     self		)					->			Mapping[str, Mapping[int, str]]:




									"""simple docstring"""





									if self.task in ["default", "seq2seq-lm"]:
																_UpperCAmelCase											=     super().outputs
									else:
																_UpperCAmelCase											=     super(_SCREAMING_SNAKE_CASE     ,       self		).outputs
																if self.use_past:
																							_UpperCAmelCase						,			_UpperCAmelCase											=     self.num_layers
																							for i in range(_SCREAMING_SNAKE_CASE		):
																														_UpperCAmelCase											=     {0: 'batch', 2: 'past_sequence + sequence'}
																														_UpperCAmelCase											=     {0: 'batch', 2: 'past_sequence + sequence'}
									return common_outputs
		def       UpperCAmelCase__							(     self     ,       _SCREAMING_SNAKE_CASE     ,       _SCREAMING_SNAKE_CASE = -1     ,       _SCREAMING_SNAKE_CASE = -1     ,       _SCREAMING_SNAKE_CASE = False     ,       _SCREAMING_SNAKE_CASE = None     ,       )					->			Mapping[str, Any]:




									"""simple docstring"""





									_UpperCAmelCase											=     self._generate_dummy_inputs_for_sequence_classification_and_question_answering(
									    _SCREAMING_SNAKE_CASE     ,       _SCREAMING_SNAKE_CASE     ,       _SCREAMING_SNAKE_CASE     ,       _SCREAMING_SNAKE_CASE     ,       _SCREAMING_SNAKE_CASE		)

									# Generate decoder inputs
									_UpperCAmelCase											=     seq_length if not self.use_past else 1
									_UpperCAmelCase											=     self._generate_dummy_inputs_for_sequence_classification_and_question_answering(
									    _SCREAMING_SNAKE_CASE     ,       _SCREAMING_SNAKE_CASE     ,       _SCREAMING_SNAKE_CASE     ,       _SCREAMING_SNAKE_CASE     ,       _SCREAMING_SNAKE_CASE		)
									_UpperCAmelCase											=     {f'''decoder_{name}''': tensor for name, tensor in decoder_inputs.items()}
									_UpperCAmelCase											=     dict(**_SCREAMING_SNAKE_CASE     ,       **_SCREAMING_SNAKE_CASE		)

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

																_UpperCAmelCase											=     torch.cat(
																    [common_inputs['decoder_attention_mask'], torch.ones(_SCREAMING_SNAKE_CASE     ,       _SCREAMING_SNAKE_CASE		)]     ,       dim=1		)

																_UpperCAmelCase											=     []
																# If the number of encoder and decoder layers are present in the model configuration, both are considered
																_UpperCAmelCase						,			_UpperCAmelCase											=     self.num_layers
																_UpperCAmelCase											=     min(_SCREAMING_SNAKE_CASE     ,       _SCREAMING_SNAKE_CASE		)
																_UpperCAmelCase											=     max(_SCREAMING_SNAKE_CASE     ,       _SCREAMING_SNAKE_CASE		) - min_num_layers
																_UpperCAmelCase											=     'encoder' if num_encoder_layers > num_decoder_layers else 'decoder'

																for _ in range(_SCREAMING_SNAKE_CASE		):
																							common_inputs["past_key_values"].append(
																							    (
																							        torch.zeros(_SCREAMING_SNAKE_CASE		),
																							        torch.zeros(_SCREAMING_SNAKE_CASE		),
																							        torch.zeros(_SCREAMING_SNAKE_CASE		),
																							        torch.zeros(_SCREAMING_SNAKE_CASE		),
																							    )		)
																# TODO: test this.
																_UpperCAmelCase											=     encoder_shape if remaining_side_name == 'encoder' else decoder_shape
																for _ in range(_SCREAMING_SNAKE_CASE     ,       _SCREAMING_SNAKE_CASE		):
																							common_inputs["past_key_values"].append((torch.zeros(_SCREAMING_SNAKE_CASE		), torch.zeros(_SCREAMING_SNAKE_CASE		))		)
									return common_inputs
		def       UpperCAmelCase__							(     self     ,       _SCREAMING_SNAKE_CASE     ,       _SCREAMING_SNAKE_CASE = -1     ,       _SCREAMING_SNAKE_CASE = -1     ,       _SCREAMING_SNAKE_CASE = False     ,       _SCREAMING_SNAKE_CASE = None     ,       )					->			Mapping[str, Any]:




									"""simple docstring"""





									_UpperCAmelCase											=     self._generate_dummy_inputs_for_sequence_classification_and_question_answering(
									    _SCREAMING_SNAKE_CASE     ,       _SCREAMING_SNAKE_CASE     ,       _SCREAMING_SNAKE_CASE     ,       _SCREAMING_SNAKE_CASE     ,       _SCREAMING_SNAKE_CASE		)

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

																_UpperCAmelCase											=     common_inputs['attention_mask'].dtype
																_UpperCAmelCase											=     torch.cat(
																    [common_inputs['attention_mask'], torch.ones(_SCREAMING_SNAKE_CASE     ,       _SCREAMING_SNAKE_CASE     ,       dtype=_SCREAMING_SNAKE_CASE		)]     ,       dim=1		)
																_UpperCAmelCase											=     [
																    (torch.zeros(_SCREAMING_SNAKE_CASE		), torch.zeros(_SCREAMING_SNAKE_CASE		)) for _ in range(_SCREAMING_SNAKE_CASE		)
																]
									return common_inputs
		def       UpperCAmelCase__							(     self     ,       _SCREAMING_SNAKE_CASE     ,       _SCREAMING_SNAKE_CASE = -1     ,       _SCREAMING_SNAKE_CASE = -1     ,       _SCREAMING_SNAKE_CASE = False     ,       _SCREAMING_SNAKE_CASE = None     ,       )					->			Mapping[str, Any]:




									"""simple docstring"""





									_UpperCAmelCase											=     compute_effective_axis_dimension(
									    _SCREAMING_SNAKE_CASE     ,       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
									_UpperCAmelCase											=     tokenizer.num_special_tokens_to_add(_SCREAMING_SNAKE_CASE		)
									_UpperCAmelCase											=     compute_effective_axis_dimension(
									    _SCREAMING_SNAKE_CASE     ,       fixed_dimension=OnnxConfig.default_fixed_sequence     ,       num_token_to_add=_SCREAMING_SNAKE_CASE		)

									# Generate dummy inputs according to compute batch and sequence
									_UpperCAmelCase											=     [' '.join([tokenizer.unk_token]		) * seq_length] * batch_size
									_UpperCAmelCase											=     dict(tokenizer(_SCREAMING_SNAKE_CASE     ,       return_tensors=_SCREAMING_SNAKE_CASE		)		)
									return common_inputs
		def       UpperCAmelCase__							(     self     ,       _SCREAMING_SNAKE_CASE     ,       _SCREAMING_SNAKE_CASE = -1     ,       _SCREAMING_SNAKE_CASE = -1     ,       _SCREAMING_SNAKE_CASE = False     ,       _SCREAMING_SNAKE_CASE = None     ,       )					->			Mapping[str, Any]:




									"""simple docstring"""





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

									elif self.task == "causal-lm":
																_UpperCAmelCase											=     self._generate_dummy_inputs_for_causal_lm(
																    _SCREAMING_SNAKE_CASE     ,       batch_size=_SCREAMING_SNAKE_CASE     ,       seq_length=_SCREAMING_SNAKE_CASE     ,       is_pair=_SCREAMING_SNAKE_CASE     ,       framework=_SCREAMING_SNAKE_CASE		)
									else:
																_UpperCAmelCase											=     self._generate_dummy_inputs_for_sequence_classification_and_question_answering(
																    _SCREAMING_SNAKE_CASE     ,       batch_size=_SCREAMING_SNAKE_CASE     ,       seq_length=_SCREAMING_SNAKE_CASE     ,       is_pair=_SCREAMING_SNAKE_CASE     ,       framework=_SCREAMING_SNAKE_CASE		)

									return common_inputs






		def       UpperCAmelCase__							(     self     ,       _SCREAMING_SNAKE_CASE     ,       _SCREAMING_SNAKE_CASE     ,       _SCREAMING_SNAKE_CASE     ,       _SCREAMING_SNAKE_CASE		)					->			List[str]:




									"""simple docstring"""





									if self.task in ["default", "seq2seq-lm"]:
																_UpperCAmelCase											=     super()._flatten_past_key_values_(_SCREAMING_SNAKE_CASE     ,       _SCREAMING_SNAKE_CASE     ,       _SCREAMING_SNAKE_CASE     ,       _SCREAMING_SNAKE_CASE		)
									else:
																_UpperCAmelCase											=     super(_SCREAMING_SNAKE_CASE     ,       self		)._flatten_past_key_values_(
																    _SCREAMING_SNAKE_CASE     ,       _SCREAMING_SNAKE_CASE     ,       _SCREAMING_SNAKE_CASE     ,       _SCREAMING_SNAKE_CASE		)
