






'''simple docstring'''







import dataclasses
import re
import string
from typing import Any, Dict, Iterator, List, Mapping, Optional, Sequence, Tuple

import numpy as np

from . import residue_constants


_A     :      Union[str, Any]   					=Mapping[str, np.ndarray]
_A     :      Tuple   					=Mapping[str, Any]  # Is a nested dict.
_A     :      Union[str, Any]   					=0.01

@dataclasses.dataclass(frozen=_lowercase		)
class _lowercase     :
       a    				=	42  # [num_res, num_atom_type, 3]

       # Amino-acid type for each residue represented as an integer between 0 and
       # 20, where 20 is 'X'.
       a    				=	42  # [num_res]

       # Binary float mask to indicate presence of a particular atom. 1.0 if an atom
       # is present and 0.0 if not. This should be used for loss masking.
       a    				=	42  # [num_res, num_atom_type]

       # Residue index as used in PDB. It is not necessarily continuous or 0-indexed.
       a    				=	42  # [num_res]

       # B-factors, or temperature factors, of each residue (in sq. angstroms units),
       # representing the displacement of the residue from its ground truth mean
       # value.
       a    				=	42  # [num_res, num_atom_type]

       # Chain indices for multi-chain predictions
       a    				=	None

       # Optional remark about the protein. Included as a comment in output PDB
       # files
       a    				=	None

       # Templates used to generate this protein (prediction-only)
       a    				=	None

       # Chain corresponding to each parent
       a    				=	None





def 			SCREAMING_SNAKE_CASE_	(UpperCamelCase				)				->	Protein:
       lowerCamelCase__ :     Optional[Any]	  =	r"""(\[[A-Z]+\]\n)"""
       lowerCamelCase__ :     List[str]	  =	[tag.strip() for tag in re.split(UpperCamelCase    ,      UpperCamelCase				) if len(UpperCamelCase				) > 0]
       lowerCamelCase__ :     Iterator[Tuple[str, List[str]]]	  =	zip(tags[0::2]    ,      [l.split("""\n"""				) for l in tags[1::2]]				)

       lowerCamelCase__ :     List[str]	  =	["N", "CA", "C"]
       lowerCamelCase__ :     Optional[int]	  =	None
       lowerCamelCase__ :     List[Any]	  =	None
       lowerCamelCase__ :     Any	  =	None
       for g in groups:
              if "[PRIMARY]" == g[0]:
                     lowerCamelCase__ :     List[Any]	  =	g[1][0].strip()
                     for i in range(len(UpperCamelCase				)				):
                            if seq[i] not in residue_constants.restypes:
                                   lowerCamelCase__ :     Any	  =	"""X"""  # FIXME: strings are immutable
                     lowerCamelCase__ :     Dict	  =	np.array(
                         [residue_constants.restype_order.get(UpperCamelCase    ,      residue_constants.restype_num				) for res_symbol in seq]				)
              elif "[TERTIARY]" == g[0]:
                     lowerCamelCase__ :     List[List[float]]	  =	[]
                     for axis in range(3				):
                            tertiary.append(list(map(UpperCamelCase    ,      g[1][axis].split()				)				)				)
                     lowerCamelCase__ :     Optional[int]	  =	np.array(UpperCamelCase				)
                     lowerCamelCase__ :     List[Any]	  =	np.zeros((len(tertiary[0]				) // 3, residue_constants.atom_type_num, 3)				).astype(np.floataa				)
                     for i, atom in enumerate(UpperCamelCase				):
                            lowerCamelCase__ :     Tuple	  =	np.transpose(tertiary_np[:, i::3]				)
                     atom_positions *= PICO_TO_ANGSTROM
              elif "[MASK]" == g[0]:
                     lowerCamelCase__ :     Dict	  =	np.array(list(map({"""-""": 0, """+""": 1}.get    ,      g[1][0].strip()				)				)				)
                     lowerCamelCase__ :     List[Any]	  =	np.zeros(
                         (
                             len(UpperCamelCase				),
                             residue_constants.atom_type_num,
                         )				).astype(np.floataa				)
                     for i, atom in enumerate(UpperCamelCase				):
                            lowerCamelCase__ :     int	  =	1
                     atom_mask *= mask[..., None]

       assert aatype is not None

       return Protein(
           atom_positions=UpperCamelCase    ,      atom_mask=UpperCamelCase    ,      aatype=UpperCamelCase    ,      residue_index=np.arange(len(UpperCamelCase				)				)    ,      b_factors=UpperCamelCase    ,      )





def 			SCREAMING_SNAKE_CASE_	(UpperCamelCase    ,      UpperCamelCase = 0				)				->	List[str]:
       lowerCamelCase__ :     List[str]	  =	[]

       lowerCamelCase__ :     List[Any]	  =	prot.remark
       if remark is not None:
              pdb_headers.append(f'''REMARK {remark}'''				)

       lowerCamelCase__ :     Optional[Any]	  =	prot.parents
       lowerCamelCase__ :     List[str]	  =	prot.parents_chain_index
       if parents is not None and parents_chain_index is not None:
              lowerCamelCase__ :     Optional[int]	  =	[p for i, p in zip(UpperCamelCase    ,      UpperCamelCase				) if i == chain_id]

       if parents is None or len(UpperCamelCase				) == 0:
              lowerCamelCase__ :     str	  =	["""N/A"""]

       pdb_headers.append(f'''PARENT {' '.join(UpperCamelCase				)}'''				)

       return pdb_headers





def 			SCREAMING_SNAKE_CASE_	(UpperCamelCase    ,      UpperCamelCase				)				->	str:
       lowerCamelCase__ :     List[str]	  =	[]
       lowerCamelCase__ :     Dict	  =	pdb_str.split("""\n"""				)

       lowerCamelCase__ :     int	  =	prot.remark
       if remark is not None:
              out_pdb_lines.append(f'''REMARK {remark}'''				)

       lowerCamelCase__ :     List[List[str]]
       if prot.parents is not None and len(prot.parents				) > 0:
              lowerCamelCase__ :     List[Any]	  =	[]
              if prot.parents_chain_index is not None:
                     lowerCamelCase__ :     Dict[str, List[str]]	  =	{}
                     for p, i in zip(prot.parents    ,      prot.parents_chain_index				):
                            parent_dict.setdefault(str(UpperCamelCase				)    ,      []				)
                            parent_dict[str(UpperCamelCase				)].append(UpperCamelCase				)

                     lowerCamelCase__ :     Optional[Any]	  =	max([int(UpperCamelCase				) for chain_idx in parent_dict]				)
                     for i in range(max_idx + 1				):
                            lowerCamelCase__ :     Optional[int]	  =	parent_dict.get(str(UpperCamelCase				)    ,      ["""N/A"""]				)
                            parents_per_chain.append(UpperCamelCase				)
              else:
                     parents_per_chain.append(list(prot.parents				)				)
       else:
              lowerCamelCase__ :     List[str]	  =	[["""N/A"""]]

       def make_parent_line(UpperCamelCase				) -> str:
              return f'''PARENT {' '.join(UpperCamelCase				)}'''

       out_pdb_lines.append(make_parent_line(parents_per_chain[0]				)				)

       lowerCamelCase__ :     Tuple	  =	0
       for i, l in enumerate(UpperCamelCase				):
              if "PARENT" not in l and "REMARK" not in l:
                     out_pdb_lines.append(UpperCamelCase				)
              if "TER" in l and "END" not in lines[i + 1]:
                     chain_counter += 1
                     if not chain_counter >= len(UpperCamelCase				):
                            lowerCamelCase__ :     Optional[Any]	  =	parents_per_chain[chain_counter]
                     else:
                            lowerCamelCase__ :     List[str]	  =	["""N/A"""]

                     out_pdb_lines.append(make_parent_line(UpperCamelCase				)				)

       return "\n".join(UpperCamelCase				)





def 			SCREAMING_SNAKE_CASE_	(UpperCamelCase				)				->	str:
       lowerCamelCase__ :     Union[str, Any]	  =	residue_constants.restypes + ["""X"""]

       def res_atoa(UpperCamelCase				) -> str:
              return residue_constants.restype_atoa.get(restypes[r]    ,      """UNK"""				)

       lowerCamelCase__ :     Union[str, Any]	  =	residue_constants.atom_types

       lowerCamelCase__ :     List[str]	  =	[]

       lowerCamelCase__ :     List[str]	  =	prot.atom_mask
       lowerCamelCase__ :     List[str]	  =	prot.aatype
       lowerCamelCase__ :     Optional[Any]	  =	prot.atom_positions
       lowerCamelCase__ :     Tuple	  =	prot.residue_index.astype(np.intaa				)
       lowerCamelCase__ :     Union[str, Any]	  =	prot.b_factors
       lowerCamelCase__ :     List[str]	  =	prot.chain_index

       if np.any(aatype > residue_constants.restype_num				):
              raise ValueError("""Invalid aatypes."""				)

       lowerCamelCase__ :     Dict	  =	get_pdb_headers(UpperCamelCase				)
       if len(UpperCamelCase				) > 0:
              pdb_lines.extend(UpperCamelCase				)

       lowerCamelCase__ :     Optional[Any]	  =	aatype.shape[0]
       lowerCamelCase__ :     Tuple	  =	1
       lowerCamelCase__ :     Union[str, Any]	  =	0
       lowerCamelCase__ :     Union[str, Any]	  =	string.ascii_uppercase
       lowerCamelCase__ :     Dict	  =	None
       # Add all atom sites.
       for i in range(UpperCamelCase				):
              lowerCamelCase__ :     List[str]	  =	res_atoa(aatype[i]				)
              for atom_name, pos, mask, b_factor in zip(UpperCamelCase    ,      atom_positions[i]    ,      atom_mask[i]    ,      b_factors[i]				):
                     if mask < 0.5:
                            continue

                     lowerCamelCase__ :     Any	  =	"""ATOM"""
                     lowerCamelCase__ :     Union[str, Any]	  =	atom_name if len(UpperCamelCase				) == 4 else f''' {atom_name}'''
                     lowerCamelCase__ :     Optional[Any]	  =	""""""
                     lowerCamelCase__ :     Optional[int]	  =	""""""
                     lowerCamelCase__ :     Any	  =	1.00
                     lowerCamelCase__ :     Union[str, Any]	  =	atom_name[0]  # Protein supports only C, N, O, S, this works.
                     lowerCamelCase__ :     Any	  =	""""""

                     lowerCamelCase__ :     Dict	  =	"""A"""
                     if chain_index is not None:
                            lowerCamelCase__ :     Optional[int]	  =	chain_tags[chain_index[i]]

                     # PDB is a columnar format, every space matters here!
                     lowerCamelCase__ :     Dict	  =	(
                         f'''{record_type:<6}{atom_index:>5} {name:<4}{alt_loc:>1}'''
                         f'''{res_name_a:>3} {chain_tag:>1}'''
                         f'''{residue_index[i]:>4}{insertion_code:>1}   '''
                         f'''{pos[0]:>8.3f}{pos[1]:>8.3f}{pos[2]:>8.3f}'''
                         f'''{occupancy:>6.2f}{b_factor:>6.2f}          '''
                         f'''{element:>2}{charge:>2}'''
                     )
                     pdb_lines.append(UpperCamelCase				)
                     atom_index += 1

              lowerCamelCase__ :     Union[str, Any]	  =	i == n - 1
              if chain_index is not None:
                     if i != n - 1 and chain_index[i + 1] != prev_chain_index:
                            lowerCamelCase__ :     Tuple	  =	True
                            lowerCamelCase__ :     List[Any]	  =	chain_index[i + 1]

              if should_terminate:
                     # Close the chain.
                     lowerCamelCase__ :     Dict	  =	"""TER"""
                     lowerCamelCase__ :     List[Any]	  =	(
                         f'''{chain_end:<6}{atom_index:>5}      {res_atoa(aatype[i]				):>3} {chain_tag:>1}{residue_index[i]:>4}'''
                     )
                     pdb_lines.append(UpperCamelCase				)
                     atom_index += 1

                     if i != n - 1:
                            # "prev" is a misnomer here. This happens at the beginning of
                            # each new chain.
                            pdb_lines.extend(get_pdb_headers(UpperCamelCase    ,      UpperCamelCase				)				)

       pdb_lines.append("""END"""				)
       pdb_lines.append(""""""				)
       return "\n".join(UpperCamelCase				)





def 			SCREAMING_SNAKE_CASE_	(UpperCamelCase				)				->	np.ndarray:
       return residue_constants.STANDARD_ATOM_MASK[prot.aatype]





def 			SCREAMING_SNAKE_CASE_	(UpperCamelCase    ,      UpperCamelCase    ,      UpperCamelCase = None    ,      UpperCamelCase = None    ,      UpperCamelCase = None    ,      UpperCamelCase = None    ,      UpperCamelCase = None    ,      )				->	Protein:
       return Protein(
           aatype=features["""aatype"""]    ,      atom_positions=result["""final_atom_positions"""]    ,      atom_mask=result["""final_atom_mask"""]    ,      residue_index=features["""residue_index"""] + 1    ,      b_factors=b_factors if b_factors is not None else np.zeros_like(result["""final_atom_mask"""]				)    ,      chain_index=UpperCamelCase    ,      remark=UpperCamelCase    ,      parents=UpperCamelCase    ,      parents_chain_index=UpperCamelCase    ,      )









'''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


_A     :      Optional[Any]   					=logging.get_logger(__name__)

_A     :      List[str]   					={
    '''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 _lowercase     (    _lowercase		):
							a    				=	"""marian"""
							a    				=	["""past_key_values"""]
							a    				=	{"""num_attention_heads""": """encoder_attention_heads""", """hidden_size""": """d_model"""}




							def __init__(							self:    Tuple      ,							UpperCamelCase__:    Optional[Any]=58_101      ,							UpperCamelCase__:    Optional[int]=None      ,							UpperCamelCase__:    Union[str, Any]=1_024      ,							UpperCamelCase__:    Any=12      ,							UpperCamelCase__:    Optional[int]=4_096      ,							UpperCamelCase__:    Tuple=16      ,							UpperCamelCase__:    Dict=12      ,							UpperCamelCase__:    Optional[Any]=4_096      ,							UpperCamelCase__:    Any=16      ,							UpperCamelCase__:    List[str]=0.0      ,							UpperCamelCase__:    Tuple=0.0      ,							UpperCamelCase__:    str=True      ,							UpperCamelCase__:    Optional[int]=True      ,							UpperCamelCase__:    Optional[int]="gelu"      ,							UpperCamelCase__:    Union[str, Any]=1_024      ,							UpperCamelCase__:    Optional[int]=0.1      ,							UpperCamelCase__:    Optional[Any]=0.0      ,							UpperCamelCase__:    Optional[Any]=0.0      ,							UpperCamelCase__:    Optional[int]=0.02      ,							UpperCamelCase__:    str=58_100      ,							UpperCamelCase__:    Tuple=False      ,							UpperCamelCase__:    Optional[Any]=58_100      ,							UpperCamelCase__:    int=0      ,							UpperCamelCase__:    Union[str, Any]=0      ,							UpperCamelCase__:    List[str]=True      ,							**UpperCamelCase__:    str      ,							):
														lowerCamelCase__ :     int	  =	vocab_size
														lowerCamelCase__ :     Tuple	  =	decoder_vocab_size or vocab_size
														lowerCamelCase__ :     List[str]	  =	max_position_embeddings
														lowerCamelCase__ :     Optional[Any]	  =	d_model
														lowerCamelCase__ :     int	  =	encoder_ffn_dim
														lowerCamelCase__ :     Union[str, Any]	  =	encoder_layers
														lowerCamelCase__ :     Dict	  =	encoder_attention_heads
														lowerCamelCase__ :     Optional[int]	  =	decoder_ffn_dim
														lowerCamelCase__ :     List[str]	  =	decoder_layers
														lowerCamelCase__ :     Dict	  =	decoder_attention_heads
														lowerCamelCase__ :     int	  =	dropout
														lowerCamelCase__ :     str	  =	attention_dropout
														lowerCamelCase__ :     Dict	  =	activation_dropout
														lowerCamelCase__ :     List[str]	  =	activation_function
														lowerCamelCase__ :     Union[str, Any]	  =	init_std
														lowerCamelCase__ :     str	  =	encoder_layerdrop
														lowerCamelCase__ :     Any	  =	decoder_layerdrop
														lowerCamelCase__ :     List[str]	  =	use_cache
														lowerCamelCase__ :     List[str]	  =	encoder_layers
														lowerCamelCase__ :     int	  =	scale_embedding  # scale factor will be sqrt(d_model) if True
														lowerCamelCase__ :     str	  =	share_encoder_decoder_embeddings
														super().__init__(
														    pad_token_id=UpperCamelCase__      ,							eos_token_id=UpperCamelCase__      ,							is_encoder_decoder=UpperCamelCase__      ,							decoder_start_token_id=UpperCamelCase__      ,							forced_eos_token_id=UpperCamelCase__      ,							**UpperCamelCase__      ,							)



class _lowercase     (    _lowercase		):




							@property
							# Copied from transformers.models.bart.configuration_bart.BartOnnxConfig.inputs
							def 		lowerCamelCase_    (							self:    Union[str, Any]					):
														if self.task in ["default", "seq2seq-lm"]:
																					lowerCamelCase__ :     List[str]	  =	OrderedDict(
																					    [
																					        ("""input_ids""", {0: """batch""", 1: """encoder_sequence"""}),
																					        ("""attention_mask""", {0: """batch""", 1: """encoder_sequence"""}),
																					    ]					)

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

																					if self.use_past:
																												self.fill_with_past_key_values_(UpperCamelCase__      ,							direction="""inputs"""					)
														elif self.task == "causal-lm":
																					# TODO: figure this case out.
																					lowerCamelCase__ :     Union[str, Any]	  =	OrderedDict(
																					    [
																					        ("""input_ids""", {0: """batch""", 1: """encoder_sequence"""}),
																					        ("""attention_mask""", {0: """batch""", 1: """encoder_sequence"""}),
																					    ]					)
																					if self.use_past:
																												lowerCamelCase__  ,		lowerCamelCase__ :     Tuple	  =	self.num_layers
																												for i in range(UpperCamelCase__					):
																																			lowerCamelCase__ :     Union[str, Any]	  =	{0: """batch""", 2: """past_sequence + sequence"""}
																																			lowerCamelCase__ :     List[str]	  =	{0: """batch""", 2: """past_sequence + sequence"""}
														else:
																					lowerCamelCase__ :     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
							# Copied from transformers.models.bart.configuration_bart.BartOnnxConfig.outputs
							def 		lowerCamelCase_    (							self:    Optional[Any]					):
														if self.task in ["default", "seq2seq-lm"]:
																					lowerCamelCase__ :     Dict	  =	super().outputs
														else:
																					lowerCamelCase__ :     Any	  =	super(UpperCamelCase__      ,							self					).outputs
																					if self.use_past:
																												lowerCamelCase__  ,		lowerCamelCase__ :     str	  =	self.num_layers
																												for i in range(UpperCamelCase__					):
																																			lowerCamelCase__ :     Tuple	  =	{0: """batch""", 2: """past_sequence + sequence"""}
																																			lowerCamelCase__ :     Union[str, Any]	  =	{0: """batch""", 2: """past_sequence + sequence"""}
														return common_outputs




							def 		lowerCamelCase_    (							self:    str      ,							UpperCamelCase__:    PreTrainedTokenizer      ,							UpperCamelCase__:    int = -1      ,							UpperCamelCase__:    int = -1      ,							UpperCamelCase__:    bool = False      ,							UpperCamelCase__:    Optional[TensorType] = None      ,							):
														lowerCamelCase__ :     Union[str, Any]	  =	self._generate_dummy_inputs_for_encoder_and_decoder(
														    UpperCamelCase__      ,							UpperCamelCase__      ,							UpperCamelCase__      ,							UpperCamelCase__      ,							UpperCamelCase__					)

														# Generate decoder inputs
														lowerCamelCase__ :     Any	  =	seq_length if not self.use_past else 1
														lowerCamelCase__ :     Optional[Any]	  =	self._generate_dummy_inputs_for_encoder_and_decoder(
														    UpperCamelCase__      ,							UpperCamelCase__      ,							UpperCamelCase__      ,							UpperCamelCase__      ,							UpperCamelCase__					)
														lowerCamelCase__ :     str	  =	{F'''decoder_{name}''': tensor for name, tensor in decoder_inputs.items()}
														lowerCamelCase__ :     Optional[int]	  =	dict(**UpperCamelCase__      ,							**UpperCamelCase__					)

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

																					lowerCamelCase__ :     Optional[int]	  =	torch.cat(
																					    [common_inputs["""decoder_attention_mask"""], torch.ones(UpperCamelCase__      ,							UpperCamelCase__					)]      ,							dim=1					)

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

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




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

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

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




							def 		lowerCamelCase_    (							self:    Optional[int]      ,							UpperCamelCase__:    PreTrainedTokenizer      ,							UpperCamelCase__:    int = -1      ,							UpperCamelCase__:    int = -1      ,							UpperCamelCase__:    bool = False      ,							UpperCamelCase__:    Optional[TensorType] = None      ,							):
														# 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
														lowerCamelCase__ :     List[Any]	  =	compute_effective_axis_dimension(
														    UpperCamelCase__      ,							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
														lowerCamelCase__ :     Union[str, Any]	  =	tokenizer.num_special_tokens_to_add(UpperCamelCase__					)
														lowerCamelCase__ :     Any	  =	compute_effective_axis_dimension(
														    UpperCamelCase__      ,							fixed_dimension=OnnxConfig.default_fixed_sequence      ,							num_token_to_add=UpperCamelCase__					)

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




							def 		lowerCamelCase_    (							self:    Optional[Any]      ,							UpperCamelCase__:    PreTrainedTokenizer      ,							UpperCamelCase__:    int = -1      ,							UpperCamelCase__:    int = -1      ,							UpperCamelCase__:    bool = False      ,							UpperCamelCase__:    Optional[TensorType] = None      ,							):
														if self.task in ["default", "seq2seq-lm"]:
																					lowerCamelCase__ :     Dict	  =	self._generate_dummy_inputs_for_default_and_seqaseq_lm(
																					    UpperCamelCase__      ,							batch_size=UpperCamelCase__      ,							seq_length=UpperCamelCase__      ,							is_pair=UpperCamelCase__      ,							framework=UpperCamelCase__					)

														else:
																					lowerCamelCase__ :     Tuple	  =	self._generate_dummy_inputs_for_causal_lm(
																					    UpperCamelCase__      ,							batch_size=UpperCamelCase__      ,							seq_length=UpperCamelCase__      ,							is_pair=UpperCamelCase__      ,							framework=UpperCamelCase__					)

														return common_inputs




							def 		lowerCamelCase_    (							self:    Union[str, Any]      ,							UpperCamelCase__:    Optional[Any]      ,							UpperCamelCase__:    List[Any]      ,							UpperCamelCase__:    Dict      ,							UpperCamelCase__:    Optional[Any]					):
														if self.task in ["default", "seq2seq-lm"]:
																					lowerCamelCase__ :     Dict	  =	super()._flatten_past_key_values_(UpperCamelCase__      ,							UpperCamelCase__      ,							UpperCamelCase__      ,							UpperCamelCase__					)
														else:
																					lowerCamelCase__ :     List[Any]	  =	super(UpperCamelCase__      ,							self					)._flatten_past_key_values_(
																					    UpperCamelCase__      ,							UpperCamelCase__      ,							UpperCamelCase__      ,							UpperCamelCase__					)




							@property
							def 		lowerCamelCase_    (							self:    Union[str, Any]					):
														return 1e-4

