



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

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


__SCREAMING_SNAKE_CASE           =  logging.get_logger(__name__)

__SCREAMING_SNAKE_CASE           =  {
    """facebook/blenderbot_small-90M""": """https://huggingface.co/facebook/blenderbot_small-90M/resolve/main/config.json""",
    # See all BlenderbotSmall models at https://huggingface.co/models?filter=blenderbot_small
}

class 	lowerCamelCase_    ( _A						):






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







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







class 	lowerCamelCase_    ( _A						):






						'''simple docstring'''







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

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







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

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

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

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

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







						def 			SCREAMING_SNAKE_CASE__		(	self      :			List[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							:					Optional[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							:					str              =						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							:					List[str]              =						[" ".join([tokenizer.unk_token] ) * seq_length] * batch_size
									A							:					Any              =						dict(tokenizer(__lowerCamelCase	,	return_tensors=__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]:
									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							:					Union[str, Any]              =						self._generate_dummy_inputs_for_causal_lm(
												    __lowerCamelCase	,	batch_size=__lowerCamelCase	,	seq_length=__lowerCamelCase	,	is_pair=__lowerCamelCase	,	framework=__lowerCamelCase )
									else:
												A							:					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      :			Dict	,	__lowerCamelCase      :			int	,	__lowerCamelCase      :			Optional[Any]	,	__lowerCamelCase      :			List[str]	,	__lowerCamelCase      :			List[Any] )      ->				Union[str, Any]:
									if self.task in ["default", "seq2seq-lm"]:
												A							:					Optional[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 )




import os


# All paths are set with the intent you should run this script from the root of the repo with the command
# python utils/check_doctest_list.py
__SCREAMING_SNAKE_CASE           =  """."""


if __name__ == "__main__":
							__SCREAMING_SNAKE_CASE           =  os.path.join(REPO_PATH, """utils/documentation_tests.txt""")
							__SCREAMING_SNAKE_CASE           =  []
							__SCREAMING_SNAKE_CASE           =  []
							with open(doctest_file_path) as fp:
														for line in fp:
																					__SCREAMING_SNAKE_CASE           =  line.strip()
																					__SCREAMING_SNAKE_CASE           =  os.path.join(REPO_PATH, line)
																					if not (os.path.isfile(path) or os.path.isdir(path)):
																												non_existent_paths.append(line)
																					all_paths.append(path)
							if len(non_existent_paths) > 0:
														__SCREAMING_SNAKE_CASE           =  """\n""".join(non_existent_paths)
														raise ValueError(F"""`utils/documentation_tests.txt` contains non-existent paths:\n{non_existent_paths}""")
							if all_paths != sorted(all_paths):
														raise ValueError("""Files in `utils/documentation_tests.txt` are not in alphabetical order.""")