




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


__lowerCAmelCase		:				int       			=		logging.get_logger(__name__)

__lowerCAmelCase		:				Optional[Any]       			=		{
    'Helsinki-NLP/opus-mt-en-de': 'https://huggingface.co/Helsinki-NLP/opus-mt-en-de/resolve/main/config.json',
    # See all Marian models at https://huggingface.co/models?filter=marian
}




class     snake_case__							(_UpperCamelCase   ):
				"""simple docstring"""



				SCREAMING_SNAKE_CASE_       :							Tuple							 =					"""marian"""
				SCREAMING_SNAKE_CASE_       :							Optional[Any]							 =					["""past_key_values"""]
				SCREAMING_SNAKE_CASE_       :							Optional[int]							 =					{"""num_attention_heads""": """encoder_attention_heads""", """hidden_size""": """d_model"""}





				def __init__(      self				:     List[Any]					,      __lowerCamelCase				:     Union[str, Any]=5_81_01					,      __lowerCamelCase				:     Optional[Any]=None					,      __lowerCamelCase				:     Dict=10_24					,      __lowerCamelCase				:     Union[str, Any]=12					,      __lowerCamelCase				:     Any=40_96					,      __lowerCamelCase				:     List[str]=16					,      __lowerCamelCase				:     Optional[Any]=12					,      __lowerCamelCase				:     int=40_96					,      __lowerCamelCase				:     Tuple=16					,      __lowerCamelCase				:     Optional[int]=0.0					,      __lowerCamelCase				:     List[Any]=0.0					,      __lowerCamelCase				:     Any=True					,      __lowerCamelCase				:     int=True					,      __lowerCamelCase				:     List[Any]="gelu"					,      __lowerCamelCase				:     str=10_24					,      __lowerCamelCase				:     int=0.1					,      __lowerCamelCase				:     int=0.0					,      __lowerCamelCase				:     Dict=0.0					,      __lowerCamelCase				:     Any=0.02					,      __lowerCamelCase				:     List[Any]=5_81_00					,      __lowerCamelCase				:     List[str]=False					,      __lowerCamelCase				:     Tuple=5_81_00					,      __lowerCamelCase				:     int=0					,      __lowerCamelCase				:     Optional[Any]=0					,      __lowerCamelCase				:     int=True					,      **__lowerCamelCase				:     Tuple					,      )					->     int:
							a    =			vocab_size
							a    =			decoder_vocab_size or vocab_size
							a    =			max_position_embeddings
							a    =			d_model
							a    =			encoder_ffn_dim
							a    =			encoder_layers
							a    =			encoder_attention_heads
							a    =			decoder_ffn_dim
							a    =			decoder_layers
							a    =			decoder_attention_heads
							a    =			dropout
							a    =			attention_dropout
							a    =			activation_dropout
							a    =			activation_function
							a    =			init_std
							a    =			encoder_layerdrop
							a    =			decoder_layerdrop
							a    =			use_cache
							a    =			encoder_layers
							a    =			scale_embedding  # scale factor will be sqrt(d_model) if True
							a    =			share_encoder_decoder_embeddings
							super().__init__(
							    pad_token_id=__lowerCamelCase					,      eos_token_id=__lowerCamelCase					,      is_encoder_decoder=__lowerCamelCase					,      decoder_start_token_id=__lowerCamelCase					,      forced_eos_token_id=__lowerCamelCase					,      **__lowerCamelCase					,      )




class     snake_case__							(_UpperCamelCase   ):
				"""simple docstring"""



				@property
				# Copied from transformers.models.bart.configuration_bart.BartOnnxConfig.inputs
				def 							__UpperCAmelCase							(      self				:     Tuple							)					->     Mapping[str, Mapping[int, str]]:
							if self.task in ["default", "seq2seq-lm"]:
										a    =			OrderedDict(
										    [
										        ("input_ids", {0: "batch", 1: "encoder_sequence"}),
										        ("attention_mask", {0: "batch", 1: "encoder_sequence"}),
										    ]							)

										if self.use_past:
													a    =			{0: "batch"}
													a    =			{0: "batch", 1: "past_decoder_sequence + sequence"}
										else:
													a    =			{0: "batch", 1: "decoder_sequence"}
													a    =			{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    =			OrderedDict(
										    [
										        ("input_ids", {0: "batch", 1: "encoder_sequence"}),
										        ("attention_mask", {0: "batch", 1: "encoder_sequence"}),
										    ]							)
										if self.use_past:
													a    ,		a    =			self.num_layers
													for i in range(__lowerCamelCase							):
																a    =			{0: "batch", 2: "past_sequence + sequence"}
																a    =			{0: "batch", 2: "past_sequence + sequence"}
							else:
										a    =			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
				# Copied from transformers.models.bart.configuration_bart.BartOnnxConfig.outputs
				def 							__UpperCAmelCase							(      self				:     Union[str, Any]							)					->     Mapping[str, Mapping[int, str]]:
							if self.task in ["default", "seq2seq-lm"]:
										a    =			super().outputs
							else:
										a    =			super(__lowerCamelCase					,      self							).outputs
										if self.use_past:
													a    ,		a    =			self.num_layers
													for i in range(__lowerCamelCase							):
																a    =			{0: "batch", 2: "past_sequence + sequence"}
																a    =			{0: "batch", 2: "past_sequence + sequence"}
							return common_outputs





				def 							__UpperCAmelCase							(      self				:     List[Any]					,      __lowerCamelCase				:     PreTrainedTokenizer					,      __lowerCamelCase				:     int = -1					,      __lowerCamelCase				:     int = -1					,      __lowerCamelCase				:     bool = False					,      __lowerCamelCase				:     Optional[TensorType] = None					,      )					->     Mapping[str, Any]:
							a    =			self._generate_dummy_inputs_for_encoder_and_decoder(
							    __lowerCamelCase					,      __lowerCamelCase					,      __lowerCamelCase					,      __lowerCamelCase					,      __lowerCamelCase							)

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

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

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

										a    =			common_inputs["attention_mask"].dtype
										a    =			torch.cat(
										    [common_inputs["attention_mask"], torch.ones(__lowerCamelCase					,      __lowerCamelCase					,      dtype=__lowerCamelCase							)]					,      dim=1							)
										a    =			[
										    (torch.zeros(__lowerCamelCase							), torch.zeros(__lowerCamelCase							)) for _ in range(__lowerCamelCase							)
										]
							return common_inputs





				def 							__UpperCAmelCase							(      self				:     Optional[int]					,      __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    =			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    =			tokenizer.num_special_tokens_to_add(__lowerCamelCase							)
							a    =			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    =			[" ".join([tokenizer.unk_token]							) * seq_length] * batch_size
							a    =			dict(tokenizer(__lowerCamelCase					,      return_tensors=__lowerCamelCase							)							)
							return common_inputs





				def 							__UpperCAmelCase							(      self				:     List[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    =			self._generate_dummy_inputs_for_default_and_seqaseq_lm(
										    __lowerCamelCase					,      batch_size=__lowerCamelCase					,      seq_length=__lowerCamelCase					,      is_pair=__lowerCamelCase					,      framework=__lowerCamelCase							)

							else:
										a    =			self._generate_dummy_inputs_for_causal_lm(
										    __lowerCamelCase					,      batch_size=__lowerCamelCase					,      seq_length=__lowerCamelCase					,      is_pair=__lowerCamelCase					,      framework=__lowerCamelCase							)

							return common_inputs





				def 							__UpperCAmelCase							(      self				:     Dict					,      __lowerCamelCase				:     Any					,      __lowerCamelCase				:     int					,      __lowerCamelCase				:     int					,      __lowerCamelCase				:     List[Any]							)					->     str:
							if self.task in ["default", "seq2seq-lm"]:
										a    =			super()._flatten_past_key_values_(__lowerCamelCase					,      __lowerCamelCase					,      __lowerCamelCase					,      __lowerCamelCase							)
							else:
										a    =			super(__lowerCamelCase					,      self							)._flatten_past_key_values_(
										    __lowerCamelCase					,      __lowerCamelCase					,      __lowerCamelCase					,      __lowerCamelCase							)





				@property
				def 							__UpperCAmelCase							(      self				:     Tuple							)					->     float:
							return 1e-4












import warnings

from ...utils import logging
from .image_processing_donut import DonutImageProcessor


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




class     snake_case__							(_UpperCamelCase   ):
				"""simple docstring"""



				def __init__(      self				:     Union[str, Any]					,      *__lowerCamelCase				:     Optional[Any]					,      **__lowerCamelCase				:     Dict							)					->     None:
							warnings.warn(
							    "The class DonutFeatureExtractor is deprecated and will be removed in version 5 of Transformers. Please"
							    " use DonutImageProcessor instead."					,      __lowerCamelCase					,      )
							super().__init__(*__lowerCamelCase					,      **__lowerCamelCase							)






