





'''simple docstring'''




import gym
import numpy as np
import torch
from mujoco_py import GlfwContext

from transformers import DecisionTransformerModel


GlfwContext(offscreen=True)  # Create a window to init GLFW.



def 						__A						(       lowerCamelCase_	,	lowerCamelCase_	,	lowerCamelCase_	,	lowerCamelCase_	,	lowerCamelCase_	,	lowerCamelCase_					):


		"""simple docstring"""



		SCREAMING_SNAKE_CASE				:							str						=	states.reshape(1	,	-1	,	model.config.state_dim					)
		SCREAMING_SNAKE_CASE				:							Optional[int]						=	actions.reshape(1	,	-1	,	model.config.act_dim					)
		SCREAMING_SNAKE_CASE				:							Any						=	returns_to_go.reshape(1	,	-1	,	1					)
		SCREAMING_SNAKE_CASE				:							Optional[Any]						=	timesteps.reshape(1	,	-1					)

		if model.config.max_length is not None:
				SCREAMING_SNAKE_CASE				:							int						=	states[:, -model.config.max_length :]
				SCREAMING_SNAKE_CASE				:							Optional[int]						=	actions[:, -model.config.max_length :]
				SCREAMING_SNAKE_CASE				:							Optional[Any]						=	returns_to_go[:, -model.config.max_length :]
				SCREAMING_SNAKE_CASE				:							List[Any]						=	timesteps[:, -model.config.max_length :]

				# pad all tokens to sequence length
				SCREAMING_SNAKE_CASE				:							List[str]						=	torch.cat(
				    [torch.zeros(model.config.max_length - states.shape[1]					), torch.ones(states.shape[1]					)]					)
				SCREAMING_SNAKE_CASE				:							Union[str, Any]						=	attention_mask.to(dtype=torch.long	,	device=states.device					).reshape(1	,	-1					)
				SCREAMING_SNAKE_CASE				:							Any						=	torch.cat(
				    [
				        torch.zeros(
				            (states.shape[0], model.config.max_length - states.shape[1], model.config.state_dim)	,	device=states.device	,	),
				        states,
				    ]	,	dim=1	,	).to(dtype=torch.floataa					)
				SCREAMING_SNAKE_CASE				:							Tuple						=	torch.cat(
				    [
				        torch.zeros(
				            (actions.shape[0], model.config.max_length - actions.shape[1], model.config.act_dim)	,	device=actions.device	,	),
				        actions,
				    ]	,	dim=1	,	).to(dtype=torch.floataa					)
				SCREAMING_SNAKE_CASE				:							Any						=	torch.cat(
				    [
				        torch.zeros(
				            (returns_to_go.shape[0], model.config.max_length - returns_to_go.shape[1], 1)	,	device=returns_to_go.device	,	),
				        returns_to_go,
				    ]	,	dim=1	,	).to(dtype=torch.floataa					)
				SCREAMING_SNAKE_CASE				:							Any						=	torch.cat(
				    [
				        torch.zeros(
				            (timesteps.shape[0], model.config.max_length - timesteps.shape[1])	,	device=timesteps.device					),
				        timesteps,
				    ]	,	dim=1	,	).to(dtype=torch.long					)
		else:
				SCREAMING_SNAKE_CASE				:							Any						=	None

		SCREAMING_SNAKE_CASE,    SCREAMING_SNAKE_CASE,    SCREAMING_SNAKE_CASE				:							str						=	model(
		    states=lowerCamelCase_	,	actions=lowerCamelCase_	,	rewards=lowerCamelCase_	,	returns_to_go=lowerCamelCase_	,	timesteps=lowerCamelCase_	,	attention_mask=lowerCamelCase_	,	return_dict=lowerCamelCase_	,	)

		return action_preds[0, -1]


# build the environment

__UpperCAmelCase         =   gym.make("""Hopper-v3""")
__UpperCAmelCase         =   env.observation_space.shape[0]
__UpperCAmelCase         =   env.action_space.shape[0]
__UpperCAmelCase         =   1000
__UpperCAmelCase         =   """cuda"""
__UpperCAmelCase         =   1000.0  # normalization for rewards/returns
__UpperCAmelCase         =   3600 / scale  # evaluation conditioning targets, 3600 is reasonable from the paper LINK
__UpperCAmelCase         =   np.array(
    [
        1.311279,
        -0.08469521,
        -0.5382719,
        -0.07201576,
        0.04932366,
        2.1066856,
        -0.15017354,
        0.00878345,
        -0.2848186,
        -0.18540096,
        -0.28461286,
    ]
)
__UpperCAmelCase         =   np.array(
    [
        0.17790751,
        0.05444621,
        0.21297139,
        0.14530419,
        0.6124444,
        0.85174465,
        1.4515252,
        0.6751696,
        1.536239,
        1.6160746,
        5.6072536,
    ]
)
__UpperCAmelCase         =   torch.from_numpy(state_mean).to(device=device)
__UpperCAmelCase         =   torch.from_numpy(state_std).to(device=device)

# Create the decision transformer model
__UpperCAmelCase         =   DecisionTransformerModel.from_pretrained("""edbeeching/decision-transformer-gym-hopper-medium""")
__UpperCAmelCase         =   model.to(device)
model.eval()

for ep in range(10):
							__UpperCAmelCase   ,     __UpperCAmelCase         =   0, 0
							__UpperCAmelCase         =   env.reset()
							__UpperCAmelCase         =   torch.tensor(TARGET_RETURN, device=device, dtype=torch.floataa).reshape(1, 1)
							__UpperCAmelCase         =   torch.from_numpy(state).reshape(1, state_dim).to(device=device, dtype=torch.floataa)
							__UpperCAmelCase         =   torch.zeros((0, act_dim), device=device, dtype=torch.floataa)
							__UpperCAmelCase         =   torch.zeros(0, device=device, dtype=torch.floataa)

							__UpperCAmelCase         =   torch.tensor(0, device=device, dtype=torch.long).reshape(1, 1)
							for t in range(max_ep_len):
														env.render()
														# add padding
														__UpperCAmelCase         =   torch.cat([actions, torch.zeros((1, act_dim), device=device)], dim=0)
														__UpperCAmelCase         =   torch.cat([rewards, torch.zeros(1, device=device)])

														__UpperCAmelCase         =   get_action(
														    model,
														    (states.to(dtype=torch.floataa) - state_mean) / state_std,
														    actions.to(dtype=torch.floataa),
														    rewards.to(dtype=torch.floataa),
														    target_return.to(dtype=torch.floataa),
														    timesteps.to(dtype=torch.long),
														)
														__UpperCAmelCase         =   action
														__UpperCAmelCase         =   action.detach().cpu().numpy()

														__UpperCAmelCase   ,     __UpperCAmelCase   ,     __UpperCAmelCase   ,     __UpperCAmelCase         =   env.step(action)

														__UpperCAmelCase         =   torch.from_numpy(state).to(device=device).reshape(1, state_dim)
														__UpperCAmelCase         =   torch.cat([states, cur_state], dim=0)
														__UpperCAmelCase         =   reward

														__UpperCAmelCase         =   target_return[0, -1] - (reward / scale)
														__UpperCAmelCase         =   torch.cat([target_return, pred_return.reshape(1, 1)], dim=1)
														__UpperCAmelCase         =   torch.cat([timesteps, torch.ones((1, 1), device=device, dtype=torch.long) * (t + 1)], dim=1)

														episode_return += reward
														episode_length += 1

														if done:
																					break










'''simple docstring'''




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

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


__UpperCAmelCase         =   logging.get_logger(__name__)

__UpperCAmelCase         =   {
    """facebook/mbart-large-cc25""": """https://huggingface.co/facebook/mbart-large-cc25/resolve/main/config.json""",
    # See all MBART models at https://huggingface.co/models?filter=mbart
}




class       UpperCamelCase__			(			lowercase_	):




					"""simple docstring"""
					SCREAMING_SNAKE_CASE__						=					'''mbart'''
					SCREAMING_SNAKE_CASE__						=					['''past_key_values''']
					SCREAMING_SNAKE_CASE__						=					{'''num_attention_heads''': '''encoder_attention_heads''', '''hidden_size''': '''d_model'''}


					def __init__(		self							:	Union[str, Any]     ,		lowerCamelCase_							:	List[str]=5_02_65     ,		lowerCamelCase_							:	Tuple=10_24     ,		lowerCamelCase_							:	Union[str, Any]=12     ,		lowerCamelCase_							:	int=40_96     ,		lowerCamelCase_							:	Dict=16     ,		lowerCamelCase_							:	Any=12     ,		lowerCamelCase_							:	Any=40_96     ,		lowerCamelCase_							:	Tuple=16     ,		lowerCamelCase_							:	List[Any]=0.0     ,		lowerCamelCase_							:	Any=0.0     ,		lowerCamelCase_							:	Any=True     ,		lowerCamelCase_							:	Dict=True     ,		lowerCamelCase_							:	List[str]="gelu"     ,		lowerCamelCase_							:	List[str]=10_24     ,		lowerCamelCase_							:	int=0.1     ,		lowerCamelCase_							:	List[Any]=0.0     ,		lowerCamelCase_							:	Tuple=0.0     ,		lowerCamelCase_							:	Optional[int]=0.02     ,		lowerCamelCase_							:	Any=0.0     ,		lowerCamelCase_							:	Tuple=False     ,		lowerCamelCase_							:	Tuple=1     ,		lowerCamelCase_							:	Tuple=0     ,		lowerCamelCase_							:	List[str]=2     ,		lowerCamelCase_							:	Optional[int]=2     ,		**lowerCamelCase_							:	int     ,		):

							'''simple docstring'''



							SCREAMING_SNAKE_CASE				:							List[Any]						=	vocab_size
							SCREAMING_SNAKE_CASE				:							Any						=	max_position_embeddings
							SCREAMING_SNAKE_CASE				:							Optional[int]						=	d_model
							SCREAMING_SNAKE_CASE				:							Union[str, Any]						=	encoder_ffn_dim
							SCREAMING_SNAKE_CASE				:							Tuple						=	encoder_layers
							SCREAMING_SNAKE_CASE				:							Dict						=	encoder_attention_heads
							SCREAMING_SNAKE_CASE				:							str						=	decoder_ffn_dim
							SCREAMING_SNAKE_CASE				:							List[Any]						=	decoder_layers
							SCREAMING_SNAKE_CASE				:							List[str]						=	decoder_attention_heads
							SCREAMING_SNAKE_CASE				:							Union[str, Any]						=	dropout
							SCREAMING_SNAKE_CASE				:							Dict						=	attention_dropout
							SCREAMING_SNAKE_CASE				:							Any						=	activation_dropout
							SCREAMING_SNAKE_CASE				:							Dict						=	activation_function
							SCREAMING_SNAKE_CASE				:							str						=	init_std
							SCREAMING_SNAKE_CASE				:							Tuple						=	encoder_layerdrop
							SCREAMING_SNAKE_CASE				:							Tuple						=	decoder_layerdrop
							SCREAMING_SNAKE_CASE				:							List[str]						=	classifier_dropout
							SCREAMING_SNAKE_CASE				:							int						=	use_cache
							SCREAMING_SNAKE_CASE				:							Union[str, Any]						=	encoder_layers
							SCREAMING_SNAKE_CASE				:							int						=	scale_embedding  # scale factor will be sqrt(d_model) if True
							super().__init__(
							    pad_token_id=lowerCamelCase_     ,		bos_token_id=lowerCamelCase_     ,		eos_token_id=lowerCamelCase_     ,		is_encoder_decoder=lowerCamelCase_     ,		forced_eos_token_id=lowerCamelCase_     ,		**lowerCamelCase_     ,		)







class       UpperCamelCase__			(			lowercase_	):




					"""simple docstring"""


					@property
					def lowerCamelCase_	(		self							:	Optional[int]		):

							'''simple docstring'''



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

									if self.use_past:
											SCREAMING_SNAKE_CASE				:							str						=	{0: """batch"""}
											SCREAMING_SNAKE_CASE				:							Union[str, Any]						=	{0: """batch""", 1: """past_decoder_sequence + sequence"""}
									else:
											SCREAMING_SNAKE_CASE				:							Dict						=	{0: """batch""", 1: """decoder_sequence"""}
											SCREAMING_SNAKE_CASE				:							Union[str, Any]						=	{0: """batch""", 1: """decoder_sequence"""}

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

							'''simple docstring'''



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


					def lowerCamelCase_	(		self							:	List[Any]     ,		lowerCamelCase_							:	PreTrainedTokenizer     ,		lowerCamelCase_							:	int = -1     ,		lowerCamelCase_							:	int = -1     ,		lowerCamelCase_							:	bool = False     ,		lowerCamelCase_							:	Optional[TensorType] = None     ,		):

							'''simple docstring'''



							SCREAMING_SNAKE_CASE				:							Dict						=	self._generate_dummy_inputs_for_sequence_classification_and_question_answering(
							    lowerCamelCase_     ,		lowerCamelCase_     ,		lowerCamelCase_     ,		lowerCamelCase_     ,		lowerCamelCase_		)

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

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

									SCREAMING_SNAKE_CASE				:							Union[str, Any]						=	torch.cat(
									    [common_inputs["""decoder_attention_mask"""], torch.ones(lowerCamelCase_     ,		lowerCamelCase_		)]     ,		dim=1		)

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

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


					def lowerCamelCase_	(		self							:	Optional[int]     ,		lowerCamelCase_							:	PreTrainedTokenizer     ,		lowerCamelCase_							:	int = -1     ,		lowerCamelCase_							:	int = -1     ,		lowerCamelCase_							:	bool = False     ,		lowerCamelCase_							:	Optional[TensorType] = None     ,		):

							'''simple docstring'''



							SCREAMING_SNAKE_CASE				:							Optional[int]						=	self._generate_dummy_inputs_for_sequence_classification_and_question_answering(
							    lowerCamelCase_     ,		lowerCamelCase_     ,		lowerCamelCase_     ,		lowerCamelCase_     ,		lowerCamelCase_		)

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

									SCREAMING_SNAKE_CASE				:							Dict						=	common_inputs["""attention_mask"""].dtype
									SCREAMING_SNAKE_CASE				:							Dict						=	torch.cat(
									    [common_inputs["""attention_mask"""], torch.ones(lowerCamelCase_     ,		lowerCamelCase_     ,		dtype=lowerCamelCase_		)]     ,		dim=1		)
									SCREAMING_SNAKE_CASE				:							Optional[Any]						=	[
									    (torch.zeros(lowerCamelCase_		), torch.zeros(lowerCamelCase_		)) for _ in range(lowerCamelCase_		)
									]
							return common_inputs


					def lowerCamelCase_	(		self							:	str     ,		lowerCamelCase_							:	PreTrainedTokenizer     ,		lowerCamelCase_							:	int = -1     ,		lowerCamelCase_							:	int = -1     ,		lowerCamelCase_							:	bool = False     ,		lowerCamelCase_							:	Optional[TensorType] = None     ,		):

							'''simple docstring'''



							SCREAMING_SNAKE_CASE				:							List[Any]						=	compute_effective_axis_dimension(
							    lowerCamelCase_     ,		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
							SCREAMING_SNAKE_CASE				:							int						=	tokenizer.num_special_tokens_to_add(lowerCamelCase_		)
							SCREAMING_SNAKE_CASE				:							int						=	compute_effective_axis_dimension(
							    lowerCamelCase_     ,		fixed_dimension=OnnxConfig.default_fixed_sequence     ,		num_token_to_add=lowerCamelCase_		)

							# Generate dummy inputs according to compute batch and sequence
							SCREAMING_SNAKE_CASE				:							Any						=	[""" """.join([tokenizer.unk_token]		) * seq_length] * batch_size
							SCREAMING_SNAKE_CASE				:							Optional[Any]						=	dict(tokenizer(lowerCamelCase_     ,		return_tensors=lowerCamelCase_		)		)
							return common_inputs


					def lowerCamelCase_	(		self							:	str     ,		lowerCamelCase_							:	PreTrainedTokenizer     ,		lowerCamelCase_							:	int = -1     ,		lowerCamelCase_							:	int = -1     ,		lowerCamelCase_							:	bool = False     ,		lowerCamelCase_							:	Optional[TensorType] = None     ,		):

							'''simple docstring'''



							if self.task in ["default", "seq2seq-lm"]:
									SCREAMING_SNAKE_CASE				:							List[str]						=	self._generate_dummy_inputs_for_default_and_seqaseq_lm(
									    lowerCamelCase_     ,		batch_size=lowerCamelCase_     ,		seq_length=lowerCamelCase_     ,		is_pair=lowerCamelCase_     ,		framework=lowerCamelCase_		)

							elif self.task == "causal-lm":
									SCREAMING_SNAKE_CASE				:							str						=	self._generate_dummy_inputs_for_causal_lm(
									    lowerCamelCase_     ,		batch_size=lowerCamelCase_     ,		seq_length=lowerCamelCase_     ,		is_pair=lowerCamelCase_     ,		framework=lowerCamelCase_		)
							else:
									SCREAMING_SNAKE_CASE				:							List[Any]						=	self._generate_dummy_inputs_for_sequence_classification_and_question_answering(
									    lowerCamelCase_     ,		batch_size=lowerCamelCase_     ,		seq_length=lowerCamelCase_     ,		is_pair=lowerCamelCase_     ,		framework=lowerCamelCase_		)

							return common_inputs



					def lowerCamelCase_	(		self							:	Union[str, Any]     ,		lowerCamelCase_							:	Union[str, Any]     ,		lowerCamelCase_							:	Tuple     ,		lowerCamelCase_							:	str     ,		lowerCamelCase_							:	List[Any]		):

							'''simple docstring'''



							if self.task in ["default", "seq2seq-lm"]:
									SCREAMING_SNAKE_CASE				:							Tuple						=	super()._flatten_past_key_values_(lowerCamelCase_     ,		lowerCamelCase_     ,		lowerCamelCase_     ,		lowerCamelCase_		)
							else:
									SCREAMING_SNAKE_CASE				:							List[Any]						=	super(lowerCamelCase_     ,		self		)._flatten_past_key_values_(
									    lowerCamelCase_     ,		lowerCamelCase_     ,		lowerCamelCase_     ,		lowerCamelCase_		)



