


'''simple docstring'''

import json
import os
from typing import List, Optional, Tuple

from ...tokenization_utils import PreTrainedTokenizer
from ...utils import logging


lowercase__					  =		logging.get_logger(__name__)

lowercase__					  =		{
    "vocab_file": "vocab.json",
    "merges_file": "merges.txt",
}

lowercase__					  =		{
    "vocab_file": {
        "microsoft/biogpt": "https://huggingface.co/microsoft/biogpt/resolve/main/vocab.json",
    },
    "merges_file": {"microsoft/biogpt": "https://huggingface.co/microsoft/biogpt/resolve/main/merges.txt"},
}

lowercase__					  =		{
    "microsoft/biogpt": 1_024,
}






def __UpperCamelCase (      __lowerCamelCase		:			Union[str, Any]					)   ->  Dict:







     '''simple docstring'''






     _a            =		set()
     _a            =		word[0]
     for char in word[1:]:
          pairs.add((prev_char, char)					)
          _a            =		char
     return pairs






class     __SCREAMING_SNAKE_CASE       (   _A			):
     UpperCAmelCase			       =					VOCAB_FILES_NAMES
     UpperCAmelCase			       =					PRETRAINED_VOCAB_FILES_MAP
     UpperCAmelCase			       =					PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
     UpperCAmelCase			       =					['''input_ids''', '''attention_mask''']






     def __init__(      self  ,				__UpperCamelCase  ,				__UpperCamelCase  ,				__UpperCamelCase="<unk>"  ,				__UpperCamelCase="<s>"  ,				__UpperCamelCase="</s>"  ,				__UpperCamelCase="</s>"  ,				__UpperCamelCase="<pad>"  ,				**__UpperCamelCase  ,				)							->     List[Any]:
          super().__init__(
              bos_token=__lowerCamelCase  ,				eos_token=__lowerCamelCase  ,				sep_token=__lowerCamelCase  ,				unk_token=__lowerCamelCase  ,				pad_token=__lowerCamelCase  ,				**__lowerCamelCase  ,				)

          try:
               import sacremoses
          except ImportError:
               raise ImportError(
                   "You need to install sacremoses to use BioGptTokenizer. "
                   "See https://pypi.org/project/sacremoses/ for installation."		)

          _a            =		"en"
          _a            =		sacremoses
          # cache of sm.MosesTokenizer instance
          _a            =		{}
          _a            =		{}
          with open(__lowerCamelCase  ,				encoding="utf-8"		) as vocab_handle:
               _a            =		json.load(__lowerCamelCase		)
          _a            =		{v: k for k, v in self.encoder.items()}
          with open(__lowerCamelCase  ,				encoding="utf-8"		) as merges_handle:
               _a            =		merges_handle.read().split("\n"		)[:-1]
          _a            =		[tuple(merge.split()[:2]		) for merge in merges]
          _a            =		dict(zip(__lowerCamelCase  ,				range(len(__lowerCamelCase		)		)		)		)
          _a            =		{}






     @property
     def 			a_       (      self		)							->     int:
          return len(self.encoder		)






     def 			a_       (      self		)							->     Optional[int]:
          return dict(self.encoder  ,				**self.added_tokens_encoder		)






     def 			a_       (      self  ,				__UpperCamelCase  ,				__UpperCamelCase		)							->     Dict:
          if lang not in self.cache_moses_tokenizer:
               _a            =		self.sm.MosesTokenizer(lang=__lowerCamelCase		)
               _a            =		moses_tokenizer
          return self.cache_moses_tokenizer[lang].tokenize(
              __lowerCamelCase  ,				aggressive_dash_splits=__lowerCamelCase  ,				return_str=__lowerCamelCase  ,				escape=__lowerCamelCase		)






     def 			a_       (      self  ,				__UpperCamelCase  ,				__UpperCamelCase		)							->     str:
          if lang not in self.cache_moses_detokenizer:
               _a            =		self.sm.MosesDetokenizer(lang=__lowerCamelCase		)
               _a            =		moses_detokenizer
          return self.cache_moses_detokenizer[lang].detokenize(__lowerCamelCase		)






     def 			a_       (      self  ,				__UpperCamelCase		)							->     Dict:
          _a            =		tuple(token[:-1]		) + (token[-1] + "</w>",)
          if token in self.cache:
               return self.cache[token]
          _a            =		get_pairs(__lowerCamelCase		)

          if not pairs:
               return token + "</w>"

          while True:
               _a            =		min(__lowerCamelCase  ,				key=lambda __UpperCamelCase		: self.bpe_ranks.get(__lowerCamelCase  ,				float("inf"		)		)		)
               if bigram not in self.bpe_ranks:
                    break
               _a            =		bigram
               _a            =		[]
               _a            =		0
               while i < len(__lowerCamelCase		):
                    try:
                         _a            =		word.index(__lowerCamelCase  ,				__lowerCamelCase		)
                    except ValueError:
                         new_word.extend(word[i:]		)
                         break
                    else:
                         new_word.extend(word[i:j]		)
                         _a            =		j

                    if word[i] == first and i < len(__lowerCamelCase		) - 1 and word[i + 1] == second:
                         new_word.append(first + second		)
                         i += 2
                    else:
                         new_word.append(word[i]		)
                         i += 1
               _a            =		tuple(__lowerCamelCase		)
               _a            =		new_word
               if len(__lowerCamelCase		) == 1:
                    break
               else:
                    _a            =		get_pairs(__lowerCamelCase		)
          _a            =		" ".join(__lowerCamelCase		)
          if word == "\n  </w>":
               _a            =		"\n</w>"
          _a            =		word
          return word






     def 			a_       (      self  ,				__UpperCamelCase  ,				__UpperCamelCase=False		)							->     Tuple:
          if bypass_tokenizer:
               _a            =		text.split()
          else:
               _a            =		self.moses_tokenize(__lowerCamelCase  ,				self.lang		)

          _a            =		[]
          for token in text:
               if token:
                    split_tokens.extend(list(self.bpe(__lowerCamelCase		).split(" "		)		)		)

          return split_tokens






     def 			a_       (      self  ,				__UpperCamelCase		)							->     List[Any]:
          return self.encoder.get(__lowerCamelCase  ,				self.encoder.get(self.unk_token		)		)






     def 			a_       (      self  ,				__UpperCamelCase		)							->     List[Any]:
          return self.decoder.get(__lowerCamelCase  ,				self.unk_token		)






     def 			a_       (      self  ,				__UpperCamelCase		)							->     List[str]:
          _a            =		[t.replace(" "  ,				""		).replace("</w>"  ,				" "		) for t in tokens]
          _a            =		"".join(__lowerCamelCase		).split()
          # detokenize
          _a            =		self.moses_detokenize(__lowerCamelCase  ,				self.lang		)
          return text






     def 			a_       (      self  ,				__UpperCamelCase  ,				__UpperCamelCase = None		)							->     List[int]:
          if token_ids_a is None:
               return [self.sep_token_id] + token_ids_a
          _a            =		[self.sep_token_id]
          return sep + token_ids_a + sep + token_ids_a






     def 			a_       (      self  ,				__UpperCamelCase  ,				__UpperCamelCase = None  ,				__UpperCamelCase = False		)							->     List[int]:
          if already_has_special_tokens:
               return super().get_special_tokens_mask(
                   token_ids_a=__lowerCamelCase  ,				token_ids_a=__lowerCamelCase  ,				already_has_special_tokens=__lowerCamelCase		)
          # no bos used in fairseq
          if token_ids_a is not None:
               return [1] + ([0] * len(__lowerCamelCase		)) + [1] + ([0] * len(__lowerCamelCase		))
          return [1] + ([0] * len(__lowerCamelCase		))






     def 			a_       (      self  ,				__UpperCamelCase  ,				__UpperCamelCase = None		)							->     List[int]:
          _a            =		[self.sep_token_id]

          # no bos used in fairseq
          if token_ids_a is None:
               return len(token_ids_a + sep		) * [0]
          return len(token_ids_a + sep		) * [0] + len(token_ids_a + sep		) * [1]






     def 			a_       (      self  ,				__UpperCamelCase  ,				__UpperCamelCase = None		)							->     Tuple[str]:
          if not os.path.isdir(__lowerCamelCase		):
               logger.error(f"Vocabulary path ({save_directory}) should be a directory"		)
               return
          _a            =		os.path.join(
              __lowerCamelCase  ,				(filename_prefix + "-" if filename_prefix else "") + VOCAB_FILES_NAMES["vocab_file"]		)
          _a            =		os.path.join(
              __lowerCamelCase  ,				(filename_prefix + "-" if filename_prefix else "") + VOCAB_FILES_NAMES["merges_file"]		)

          with open(__lowerCamelCase  ,				"w"  ,				encoding="utf-8"		) as f:
               f.write(json.dumps(self.encoder  ,				indent=2  ,				sort_keys=__lowerCamelCase  ,				ensure_ascii=__lowerCamelCase		) + "\n"		)

          _a            =		0
          with open(__lowerCamelCase  ,				"w"  ,				encoding="utf-8"		) as writer:
               for bpe_tokens, token_index in sorted(self.bpe_ranks.items()  ,				key=lambda __UpperCamelCase		: kv[1]		):
                    if index != token_index:
                         logger.warning(
                             f"Saving vocabulary to {merge_file}: BPE merge indices are not consecutive."
                             " Please check that the tokenizer is not corrupted!"		)
                         _a            =		token_index
                    writer.write(" ".join(__lowerCamelCase		) + "\n"		)
                    index += 1

          return vocab_file, merge_file






     def __getstate__(      self		)							->     Any:
          _a            =		self.__dict__.copy()
          _a            =		None
          return state






     def __setstate__(      self  ,				__UpperCamelCase		)							->     int:
          _a            =		d

          try:
               import sacremoses
          except ImportError:
               raise ImportError(
                   "You need to install sacremoses to use XLMTokenizer. "
                   "See https://pypi.org/project/sacremoses/ for installation."		)

          _a            =		sacremoses






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


__SCREAMING_SNAKE_CASE     =	logging.get_logger(__name__)

__SCREAMING_SNAKE_CASE     =	{
    """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 						lowerCamelCase_     (			_A    ):






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







						def __init__(						self   :      int						,						__lowerCamelCase   :      Optional[int]=5_02_65						,						__lowerCamelCase   :      str=10_24						,						__lowerCamelCase   :      str=12						,						__lowerCamelCase   :      Dict=40_96						,						__lowerCamelCase   :      str=16						,						__lowerCamelCase   :      int=12						,						__lowerCamelCase   :      Optional[Any]=40_96						,						__lowerCamelCase   :      Any=16						,						__lowerCamelCase   :      Optional[Any]=0.0						,						__lowerCamelCase   :      List[Any]=0.0						,						__lowerCamelCase   :      Dict=True						,						__lowerCamelCase   :      List[str]=True						,						__lowerCamelCase   :      Optional[int]="gelu"						,						__lowerCamelCase   :      List[Any]=10_24						,						__lowerCamelCase   :      Dict=0.1						,						__lowerCamelCase   :      Tuple=0.0						,						__lowerCamelCase   :      List[str]=0.0						,						__lowerCamelCase   :      Union[str, Any]=0.02						,						__lowerCamelCase   :      List[Any]=0.0						,						__lowerCamelCase   :      List[Any]=False						,						__lowerCamelCase   :      Optional[Any]=1						,						__lowerCamelCase   :      str=0						,						__lowerCamelCase   :      Optional[Any]=2						,						__lowerCamelCase   :      Dict=2						,						**__lowerCamelCase   :      int						,						)   ->					Union[str, Any]:
									A				:       Union[str, Any]														=    vocab_size
									A				:       List[str]														=    max_position_embeddings
									A				:       Optional[int]														=    d_model
									A				:       Any														=    encoder_ffn_dim
									A				:       Union[str, Any]														=    encoder_layers
									A				:       int														=    encoder_attention_heads
									A				:       Union[str, Any]														=    decoder_ffn_dim
									A				:       Any														=    decoder_layers
									A				:       Tuple														=    decoder_attention_heads
									A				:       Any														=    dropout
									A				:       Union[str, Any]														=    attention_dropout
									A				:       str														=    activation_dropout
									A				:       Dict														=    activation_function
									A				:       Optional[int]														=    init_std
									A				:       Optional[Any]														=    encoder_layerdrop
									A				:       Union[str, Any]														=    decoder_layerdrop
									A				:       Tuple														=    classifier_dropout
									A				:       Union[str, Any]														=    use_cache
									A				:       List[str]														=    encoder_layers
									A				:       List[str]														=    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 						lowerCamelCase_     (			_A    ):






						'''simple docstring'''







						@property
						def       SCREAMING_SNAKE_CASE__		(						self   :      Any			)   ->					Mapping[str, Mapping[int, str]]:
									if self.task in ["default", "seq2seq-lm"]:
												A				:       List[str]														=    OrderedDict(
												    [
												        ("input_ids", {0: "batch", 1: "encoder_sequence"}),
												        ("attention_mask", {0: "batch", 1: "encoder_sequence"}),
												    ]			)

												if self.use_past:
															A				:       str														=    {0: "batch"}
															A				:       Optional[int]														=    {0: "batch", 1: "past_decoder_sequence + sequence"}
												else:
															A				:       Optional[int]														=    {0: "batch", 1: "decoder_sequence"}
															A				:       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.
												A				:       Dict														=    OrderedDict(
												    [
												        ("input_ids", {0: "batch", 1: "encoder_sequence"}),
												        ("attention_mask", {0: "batch", 1: "encoder_sequence"}),
												    ]			)
												if self.use_past:
															A							,			A				:       Union[str, Any]														=    self.num_layers
															for i in range(__lowerCamelCase			):
																		A				:       List[str]														=    {0: "batch", 2: "past_sequence + sequence"}
																		A				:       int														=    {0: "batch", 2: "past_sequence + sequence"}
									else:
												A				:       Optional[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       SCREAMING_SNAKE_CASE__		(						self   :      int			)   ->					Mapping[str, Mapping[int, str]]:
									if self.task in ["default", "seq2seq-lm"]:
												A				:       str														=    super().outputs
									else:
												A				:       int														=    super(__lowerCamelCase						,						self			).outputs
												if self.use_past:
															A							,			A				:       Optional[int]														=    self.num_layers
															for i in range(__lowerCamelCase			):
																		A				:       List[Any]														=    {0: "batch", 2: "past_sequence + sequence"}
																		A				:       Tuple														=    {0: "batch", 2: "past_sequence + sequence"}
									return common_outputs







						def       SCREAMING_SNAKE_CASE__		(						self   :      int						,						__lowerCamelCase   :      PreTrainedTokenizer						,						__lowerCamelCase   :      int = -1						,						__lowerCamelCase   :      int = -1						,						__lowerCamelCase   :      bool = False						,						__lowerCamelCase   :      Optional[TensorType] = None						,						)   ->					Mapping[str, Any]:
									A				:       Tuple														=    self._generate_dummy_inputs_for_sequence_classification_and_question_answering(
									    __lowerCamelCase						,						__lowerCamelCase						,						__lowerCamelCase						,						__lowerCamelCase						,						__lowerCamelCase			)

									# Generate decoder inputs
									A				:       Optional[int]														=    seq_length if not self.use_past else 1
									A				:       str														=    self._generate_dummy_inputs_for_sequence_classification_and_question_answering(
									    __lowerCamelCase						,						__lowerCamelCase						,						__lowerCamelCase						,						__lowerCamelCase						,						__lowerCamelCase			)
									A				:       Tuple														=    {F"""decoder_{name}""": tensor for name, tensor in decoder_inputs.items()}
									A				:       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
												A							,			A				:       List[Any]														=    common_inputs["input_ids"].shape
												A				:       Any														=    common_inputs["decoder_input_ids"].shape[1]
												A							,			A				:       Union[str, Any]														=    self.num_attention_heads
												A				:       Tuple														=    (
												    batch,
												    num_encoder_attention_heads,
												    encoder_seq_length,
												    self._config.hidden_size // num_encoder_attention_heads,
												)
												A				:       Dict														=    decoder_seq_length + 3
												A				:       Union[str, Any]														=    (
												    batch,
												    num_decoder_attention_heads,
												    decoder_past_length,
												    self._config.hidden_size // num_decoder_attention_heads,
												)

												A				:       int														=    torch.cat(
												    [common_inputs["decoder_attention_mask"], torch.ones(__lowerCamelCase						,						__lowerCamelCase			)]						,						dim=1			)

												A				:       Optional[int]														=    []
												# If the number of encoder and decoder layers are present in the model configuration, both are considered
												A							,			A				:       Dict														=    self.num_layers
												A				:       Dict														=    min(__lowerCamelCase						,						__lowerCamelCase			)
												A				:       Optional[Any]														=    max(__lowerCamelCase						,						__lowerCamelCase			) - min_num_layers
												A				:       Tuple														=    "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.
												A				:       List[str]														=    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       SCREAMING_SNAKE_CASE__		(						self   :      str						,						__lowerCamelCase   :      PreTrainedTokenizer						,						__lowerCamelCase   :      int = -1						,						__lowerCamelCase   :      int = -1						,						__lowerCamelCase   :      bool = False						,						__lowerCamelCase   :      Optional[TensorType] = None						,						)   ->					Mapping[str, Any]:
									A				:       List[Any]														=    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
												A							,			A				:       List[Any]														=    common_inputs["input_ids"].shape
												# Not using the same length for past_key_values
												A				:       Any														=    seqlen + 2
												A							,			A				:       List[Any]														=    self.num_layers
												A							,			A				:       int														=    self.num_attention_heads
												A				:       int														=    (
												    batch,
												    num_encoder_attention_heads,
												    past_key_values_length,
												    self._config.hidden_size // num_encoder_attention_heads,
												)

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







						def       SCREAMING_SNAKE_CASE__		(						self   :      Union[str, Any]						,						__lowerCamelCase   :      PreTrainedTokenizer						,						__lowerCamelCase   :      int = -1						,						__lowerCamelCase   :      int = -1						,						__lowerCamelCase   :      bool = False						,						__lowerCamelCase   :      Optional[TensorType] = None						,						)   ->					Mapping[str, Any]:
									# Copied from OnnxConfig.generate_dummy_inputs
									# Did not use super(OnnxConfigWithPast, self).generate_dummy_inputs for code clarity.
									# If dynamic axis (-1) we forward with a fixed dimension of 2 samples to avoid optimizations made by ONNX
									A				:       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
									A				:       Any														=    tokenizer.num_special_tokens_to_add(__lowerCamelCase			)
									A				:       Tuple														=    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
									A				:       Dict														=    [" ".join([tokenizer.unk_token]			) * seq_length] * batch_size
									A				:       Tuple														=    dict(tokenizer(__lowerCamelCase						,						return_tensors=__lowerCamelCase			)			)
									return common_inputs







						def       SCREAMING_SNAKE_CASE__		(						self   :      Union[str, Any]						,						__lowerCamelCase   :      PreTrainedTokenizer						,						__lowerCamelCase   :      int = -1						,						__lowerCamelCase   :      int = -1						,						__lowerCamelCase   :      bool = False						,						__lowerCamelCase   :      Optional[TensorType] = None						,						)   ->					Mapping[str, Any]:
									if self.task in ["default", "seq2seq-lm"]:
												A				:       List[Any]														=    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":
												A				:       Tuple														=    self._generate_dummy_inputs_for_causal_lm(
												    __lowerCamelCase						,						batch_size=__lowerCamelCase						,						seq_length=__lowerCamelCase						,						is_pair=__lowerCamelCase						,						framework=__lowerCamelCase			)
									else:
												A				:       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       SCREAMING_SNAKE_CASE__		(						self   :      Union[str, Any]						,						__lowerCamelCase   :      str						,						__lowerCamelCase   :      Union[str, Any]						,						__lowerCamelCase   :      Any						,						__lowerCamelCase   :      List[Any]			)   ->					Dict:
									if self.task in ["default", "seq2seq-lm"]:
												A				:       Any														=    super()._flatten_past_key_values_(__lowerCamelCase						,						__lowerCamelCase						,						__lowerCamelCase						,						__lowerCamelCase			)
									else:
												A				:       Optional[Any]														=    super(__lowerCamelCase						,						self			)._flatten_past_key_values_(
												    __lowerCamelCase						,						__lowerCamelCase						,						__lowerCamelCase						,						__lowerCamelCase			)