



import glob
import os
from typing import Dict, List, Union

import torch

from diffusers.utils import is_safetensors_available


if is_safetensors_available():
							import safetensors.torch

from huggingface_hub import snapshot_download

from diffusers import DiffusionPipeline, __version__
from diffusers.schedulers.scheduling_utils import SCHEDULER_CONFIG_NAME
from diffusers.utils import CONFIG_NAME, DIFFUSERS_CACHE, ONNX_WEIGHTS_NAME, WEIGHTS_NAME

class 						lowerCamelCase_     (			_A    ):






						'''simple docstring'''







						def __init__(						self   :      Optional[Any]			)   ->					Optional[Any]:
									self.register_to_config()
									super().__init__()







						def       SCREAMING_SNAKE_CASE__		(						self   :      Dict						,						__lowerCamelCase   :      Any						,						__lowerCamelCase   :      Optional[Any]			)   ->					List[str]:
									if dicta == dicta:
												return True
									else:
												A							,			A				:       List[Any]														=    self._remove_meta_keys(__lowerCamelCase			)
												A							,			A				:       Dict														=    self._remove_meta_keys(__lowerCamelCase			)
												if configa == configa:
															print(F"""Warning !: Mismatch in keys {meta_keysa} and {meta_keysa}."""			)
															return True
									return False







						def       SCREAMING_SNAKE_CASE__		(						self   :      List[Any]						,						__lowerCamelCase   :      Dict			)   ->					str:
									A				:       Union[str, Any]														=    []
									A				:       List[str]														=    config_dict.copy()
									for key in config_dict.keys():
												if key.startswith("_"			):
															temp_dict.pop(__lowerCamelCase			)
															meta_keys.append(__lowerCamelCase			)
									return (temp_dict, meta_keys)







						@torch.no_grad()
						def       SCREAMING_SNAKE_CASE__		(						self   :      List[Any]						,						__lowerCamelCase   :      List[Union[str, os.PathLike]]						,						**__lowerCamelCase   :      List[str]			)   ->					str:
									A				:       List[str]														=    kwargs.pop("cache_dir"						,						__lowerCamelCase			)
									A				:       List[Any]														=    kwargs.pop("resume_download"						,						__lowerCamelCase			)
									A				:       Dict														=    kwargs.pop("force_download"						,						__lowerCamelCase			)
									A				:       List[str]														=    kwargs.pop("proxies"						,						__lowerCamelCase			)
									A				:       List[str]														=    kwargs.pop("local_files_only"						,						__lowerCamelCase			)
									A				:       str														=    kwargs.pop("use_auth_token"						,						__lowerCamelCase			)
									A				:       Optional[Any]														=    kwargs.pop("revision"						,						__lowerCamelCase			)
									A				:       Optional[int]														=    kwargs.pop("torch_dtype"						,						__lowerCamelCase			)
									A				:       List[str]														=    kwargs.pop("device_map"						,						__lowerCamelCase			)

									A				:       int														=    kwargs.pop("alpha"						,						0.5			)
									A				:       Optional[Any]														=    kwargs.pop("interp"						,						__lowerCamelCase			)

									print("Received list"						,						__lowerCamelCase			)
									print(F"""Combining with alpha={alpha}, interpolation mode={interp}"""			)

									A				:       int														=    len(__lowerCamelCase			)
									# Ignore result from model_index_json comparision of the two checkpoints
									A				:       Union[str, Any]														=    kwargs.pop("force"						,						__lowerCamelCase			)

									# If less than 2 checkpoints, nothing to merge. If more than 3, not supported for now.
									if checkpoint_count > 3 or checkpoint_count < 2:
												raise ValueError(
												    "Received incorrect number of checkpoints to merge. Ensure that either 2 or 3 checkpoints are being"
												    " passed."			)

									print("Received the right number of checkpoints"			)
									# chkpt0, chkpt1 = pretrained_model_name_or_path_list[0:2]
									# chkpt2 = pretrained_model_name_or_path_list[2] if checkpoint_count == 3 else None

									# Validate that the checkpoints can be merged
									# Step 1: Load the model config and compare the checkpoints. We'll compare the model_index.json first while ignoring the keys starting with '_'
									A				:       Dict														=    []
									for pretrained_model_name_or_path in pretrained_model_name_or_path_list:
												A				:       int														=    DiffusionPipeline.load_config(
												    __lowerCamelCase						,						cache_dir=__lowerCamelCase						,						resume_download=__lowerCamelCase						,						force_download=__lowerCamelCase						,						proxies=__lowerCamelCase						,						local_files_only=__lowerCamelCase						,						use_auth_token=__lowerCamelCase						,						revision=__lowerCamelCase						,						)
												config_dicts.append(__lowerCamelCase			)

									A				:       Tuple														=    True
									for idx in range(1						,						len(__lowerCamelCase			)			):
												comparison_result &= self._compare_model_configs(config_dicts[idx - 1]						,						config_dicts[idx]			)
												if not force and comparison_result is False:
															raise ValueError("Incompatible checkpoints. Please check model_index.json for the models."			)
															print(config_dicts[0]						,						config_dicts[1]			)
									print("Compatible model_index.json files found"			)
									# Step 2: Basic Validation has succeeded. Let's download the models and save them into our local files.
									A				:       List[str]														=    []
									for pretrained_model_name_or_path, config_dict in zip(__lowerCamelCase						,						__lowerCamelCase			):
												A				:       str														=    [k for k in config_dict.keys() if not k.startswith("_"			)]
												A				:       List[str]														=    [os.path.join(__lowerCamelCase						,						"*"			) for k in folder_names]
												allow_patterns += [
												    WEIGHTS_NAME,
												    SCHEDULER_CONFIG_NAME,
												    CONFIG_NAME,
												    ONNX_WEIGHTS_NAME,
												    DiffusionPipeline.config_name,
												]
												A				:       List[str]														=    config_dict.get("_class_name"			)
												A				:       List[str]														=    {"diffusers": __version__, "pipeline_class": requested_pipeline_class}

												A				:       Tuple														=    (
												    pretrained_model_name_or_path
												    if os.path.isdir(__lowerCamelCase			)
												    else snapshot_download(
												        __lowerCamelCase						,						cache_dir=__lowerCamelCase						,						resume_download=__lowerCamelCase						,						proxies=__lowerCamelCase						,						local_files_only=__lowerCamelCase						,						use_auth_token=__lowerCamelCase						,						revision=__lowerCamelCase						,						allow_patterns=__lowerCamelCase						,						user_agent=__lowerCamelCase						,						)
												)
												print("Cached Folder"						,						__lowerCamelCase			)
												cached_folders.append(__lowerCamelCase			)

									# Step 3:-
									# Load the first checkpoint as a diffusion pipeline and modify its module state_dict in place
									A				:       List[Any]														=    DiffusionPipeline.from_pretrained(
									    cached_folders[0]						,						torch_dtype=__lowerCamelCase						,						device_map=__lowerCamelCase			)
									final_pipe.to(self.device			)

									A				:       int														=    None
									if len(__lowerCamelCase			) > 2:
												A				:       List[str]														=    os.path.join(cached_folders[2]			)

									if interp == "sigmoid":
												A				:       Any														=    CheckpointMergerPipeline.sigmoid
									elif interp == "inv_sigmoid":
												A				:       Any														=    CheckpointMergerPipeline.inv_sigmoid
									elif interp == "add_diff":
												A				:       Tuple														=    CheckpointMergerPipeline.add_difference
									else:
												A				:       Tuple														=    CheckpointMergerPipeline.weighted_sum

									# Find each module's state dict.
									for attr in final_pipe.config.keys():
												if not attr.startswith("_"			):
															A				:       List[Any]														=    os.path.join(cached_folders[1]						,						__lowerCamelCase			)
															if os.path.exists(__lowerCamelCase			):
																		A				:       Union[str, Any]														=    [
																		    *glob.glob(os.path.join(__lowerCamelCase						,						"*.safetensors"			)			),
																		    *glob.glob(os.path.join(__lowerCamelCase						,						"*.bin"			)			),
																		]
																		A				:       Any														=    files[0] if len(__lowerCamelCase			) > 0 else None
															if len(__lowerCamelCase			) < 3:
																		A				:       Optional[int]														=    None
															else:
																		A				:       int														=    os.path.join(cached_folders[2]						,						__lowerCamelCase			)
																		if os.path.exists(__lowerCamelCase			):
																					A				:       Optional[Any]														=    [
																					    *glob.glob(os.path.join(__lowerCamelCase						,						"*.safetensors"			)			),
																					    *glob.glob(os.path.join(__lowerCamelCase						,						"*.bin"			)			),
																					]
																					A				:       List[Any]														=    files[0] if len(__lowerCamelCase			) > 0 else None
                # For an attr if both checkpoint_path_1 and 2 are None, ignore.
                # If atleast one is present, deal with it according to interp method, of course only if the state_dict keys match.
															if checkpoint_path_a is None and checkpoint_path_a is None:
																		print(F"""Skipping {attr}: not present in 2nd or 3d model"""			)
																		continue
															try:
																		A				:       int														=    getattr(__lowerCamelCase						,						__lowerCamelCase			)
																		if isinstance(__lowerCamelCase						,						__lowerCamelCase			):  # ignore requires_safety_checker boolean
																					continue
																		A				:       List[str]														=    getattr(__lowerCamelCase						,						"state_dict"			)
																		A				:       Union[str, Any]														=    theta_a()

																		A				:       Optional[Any]														=    getattr(__lowerCamelCase						,						"load_state_dict"			)
																		A				:       Union[str, Any]														=    (
																		    safetensors.torch.load_file(__lowerCamelCase			)
																		    if (is_safetensors_available() and checkpoint_path_a.endswith(".safetensors"			))
																		    else torch.load(__lowerCamelCase						,						map_location="cpu"			)
																		)
																		A				:       str														=    None
																		if checkpoint_path_a:
																					A				:       Optional[int]														=    (
																					    safetensors.torch.load_file(__lowerCamelCase			)
																					    if (is_safetensors_available() and checkpoint_path_a.endswith(".safetensors"			))
																					    else torch.load(__lowerCamelCase						,						map_location="cpu"			)
																					)

																		if not theta_a.keys() == theta_a.keys():
																					print(F"""Skipping {attr}: key mismatch"""			)
																					continue
																		if theta_a and not theta_a.keys() == theta_a.keys():
																					print(F"""Skipping {attr}:y mismatch"""			)
															except Exception as e:
																		print(F"""Skipping {attr} do to an unexpected error: {str(__lowerCamelCase			)}"""			)
																		continue
															print(F"""MERGING {attr}"""			)

															for key in theta_a.keys():
																		if theta_a:
																					A				:       List[str]														=    theta_func(theta_a[key]						,						theta_a[key]						,						theta_a[key]						,						__lowerCamelCase			)
																		else:
																					A				:       Union[str, Any]														=    theta_func(theta_a[key]						,						theta_a[key]						,						__lowerCamelCase						,						__lowerCamelCase			)

															del theta_a
															del theta_a
															update_theta_a(__lowerCamelCase			)

															del theta_a
									return final_pipe







						@staticmethod
						def       SCREAMING_SNAKE_CASE__		(						__lowerCamelCase   :      Optional[int]						,						__lowerCamelCase   :      str						,						__lowerCamelCase   :      Tuple						,						__lowerCamelCase   :      List[Any]			)   ->					Tuple:
									return ((1 - alpha) * thetaa) + (alpha * thetaa)







						@staticmethod
						def       SCREAMING_SNAKE_CASE__		(						__lowerCamelCase   :      Dict						,						__lowerCamelCase   :      Union[str, Any]						,						__lowerCamelCase   :      List[Any]						,						__lowerCamelCase   :      Union[str, Any]			)   ->					List[Any]:
									A				:       List[str]														=    alpha * alpha * (3 - (2 * alpha))
									return thetaa + ((thetaa - thetaa) * alpha)







						@staticmethod
						def       SCREAMING_SNAKE_CASE__		(						__lowerCamelCase   :      Optional[Any]						,						__lowerCamelCase   :      Optional[Any]						,						__lowerCamelCase   :      int						,						__lowerCamelCase   :      int			)   ->					List[str]:
									import math

									A				:       List[Any]														=    0.5 - math.sin(math.asin(1.0 - 2.0 * alpha			) / 3.0			)
									return thetaa + ((thetaa - thetaa) * alpha)







						@staticmethod
						def       SCREAMING_SNAKE_CASE__		(						__lowerCamelCase   :      int						,						__lowerCamelCase   :      Dict						,						__lowerCamelCase   :      Optional[Any]						,						__lowerCamelCase   :      List[Any]			)   ->					int:
									return thetaa + (thetaa - thetaa) * (1.0 - alpha)




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			)