





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


__lowercase       :List[str]       =  Mapping[str, np.ndarray]
__lowercase       :Any       =  Mapping[str, Any]  # Is a nested dict.
__lowercase       :List[Any]       =  0.0_1



@dataclasses.dataclass(frozen=lowercase__							)
class    _a     :






							"""simple docstring"""

							snake_case_							 =						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'.
							snake_case_							 =						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.
							snake_case_							 =						42  # [num_res, num_atom_type]

							# Residue index as used in PDB. It is not necessarily continuous or 0-indexed.
							snake_case_							 =						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.
							snake_case_							 =						42  # [num_res, num_atom_type]

							# Chain indices for multi-chain predictions
							snake_case_							 =						None

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

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

							# Chain corresponding to each parent
							snake_case_							 =						None







def       UpperCAmelCase							(     _lowerCamelCase      :  str     ):





						'''simple docstring'''


						SCREAMING_SNAKE_CASE__     :				List[str]   =					r"(\[[A-Z]+\]\n)"
						SCREAMING_SNAKE_CASE__     :				List[str]   =					[tag.strip() for tag in re.split(_lowerCamelCase			,   _lowerCamelCase     ) if len(_lowerCamelCase     ) > 0]
						SCREAMING_SNAKE_CASE__     :				Iterator[Tuple[str, List[str]]]   =					zip(tags[0::2]			,   [l.split("\n"     ) for l in tags[1::2]]     )

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

						assert aatype is not None

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







def       UpperCAmelCase							(     _lowerCamelCase      :  Protein			,   _lowerCamelCase      :  int = 0     ):





						'''simple docstring'''


						SCREAMING_SNAKE_CASE__     :				List[str]   =					[]

						SCREAMING_SNAKE_CASE__     :				int   =					prot.remark
						if remark is not None:
												pdb_headers.append(f"""REMARK {remark}"""     )

						SCREAMING_SNAKE_CASE__     :				str   =					prot.parents
						SCREAMING_SNAKE_CASE__     :				int   =					prot.parents_chain_index
						if parents is not None and parents_chain_index is not None:
												SCREAMING_SNAKE_CASE__     :				Union[str, Any]   =					[p for i, p in zip(_lowerCamelCase			,   _lowerCamelCase     ) if i == chain_id]

						if parents is None or len(_lowerCamelCase     ) == 0:
												SCREAMING_SNAKE_CASE__     :				List[str]   =					["N/A"]

						pdb_headers.append(f"""PARENT {' '.join(_lowerCamelCase     )}"""     )

						return pdb_headers







def       UpperCAmelCase							(     _lowerCamelCase      :  Protein			,   _lowerCamelCase      :  str     ):





						'''simple docstring'''


						SCREAMING_SNAKE_CASE__     :				List[str]   =					[]
						SCREAMING_SNAKE_CASE__     :				List[str]   =					pdb_str.split("\n"     )

						SCREAMING_SNAKE_CASE__     :				Optional[Any]   =					prot.remark
						if remark is not None:
												out_pdb_lines.append(f"""REMARK {remark}"""     )

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

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

						def make_parent_line(_lowerCamelCase      :  Sequence[str]     ) -> str:
												return f"""PARENT {' '.join(_lowerCamelCase     )}"""

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

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

																		out_pdb_lines.append(make_parent_line(_lowerCamelCase     )     )

						return "\n".join(_lowerCamelCase     )







def       UpperCAmelCase							(     _lowerCamelCase      :  Protein     ):





						'''simple docstring'''


						SCREAMING_SNAKE_CASE__     :				Union[str, Any]   =					residue_constants.restypes + ["X"]

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

						SCREAMING_SNAKE_CASE__     :				str   =					residue_constants.atom_types

						SCREAMING_SNAKE_CASE__     :				List[str]   =					[]

						SCREAMING_SNAKE_CASE__     :				Dict   =					prot.atom_mask
						SCREAMING_SNAKE_CASE__     :				Tuple   =					prot.aatype
						SCREAMING_SNAKE_CASE__     :				str   =					prot.atom_positions
						SCREAMING_SNAKE_CASE__     :				str   =					prot.residue_index.astype(np.intaa     )
						SCREAMING_SNAKE_CASE__     :				Tuple   =					prot.b_factors
						SCREAMING_SNAKE_CASE__     :				Dict   =					prot.chain_index

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

						SCREAMING_SNAKE_CASE__     :				int   =					get_pdb_headers(_lowerCamelCase     )
						if len(_lowerCamelCase     ) > 0:
												pdb_lines.extend(_lowerCamelCase     )

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

																		SCREAMING_SNAKE_CASE__     :				Optional[Any]   =					"ATOM"
																		SCREAMING_SNAKE_CASE__     :				List[Any]   =					atom_name if len(_lowerCamelCase     ) == 4 else f""" {atom_name}"""
																		SCREAMING_SNAKE_CASE__     :				Tuple   =					""
																		SCREAMING_SNAKE_CASE__     :				Tuple   =					""
																		SCREAMING_SNAKE_CASE__     :				Optional[Any]   =					1.0_0
																		SCREAMING_SNAKE_CASE__     :				Optional[Any]   =					atom_name[0]  # Protein supports only C, N, O, S, this works.
																		SCREAMING_SNAKE_CASE__     :				List[str]   =					""

																		SCREAMING_SNAKE_CASE__     :				Any   =					"A"
																		if chain_index is not None:
																								SCREAMING_SNAKE_CASE__     :				int   =					chain_tags[chain_index[i]]

																		# PDB is a columnar format, every space matters here!
																		SCREAMING_SNAKE_CASE__     :				Optional[int]   =					(
																		    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(_lowerCamelCase     )
																		atom_index += 1

												SCREAMING_SNAKE_CASE__     :				Optional[int]   =					i == n - 1
												if chain_index is not None:
																		if i != n - 1 and chain_index[i + 1] != prev_chain_index:
																								SCREAMING_SNAKE_CASE__     :				Optional[Any]   =					True
																								SCREAMING_SNAKE_CASE__     :				Any   =					chain_index[i + 1]

												if should_terminate:
																		# Close the chain.
																		SCREAMING_SNAKE_CASE__     :				Tuple   =					"TER"
																		SCREAMING_SNAKE_CASE__     :				List[Any]   =					(
																		    f"""{chain_end:<6}{atom_index:>5}      {res_atoa(aatype[i]     ):>3} {chain_tag:>1}{residue_index[i]:>4}"""
																		)
																		pdb_lines.append(_lowerCamelCase     )
																		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(_lowerCamelCase			,   _lowerCamelCase     )     )

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







def       UpperCAmelCase							(     _lowerCamelCase      :  Protein     ):





						'''simple docstring'''


						return residue_constants.STANDARD_ATOM_MASK[prot.aatype]







def       UpperCAmelCase							(     _lowerCamelCase      :  FeatureDict			,   _lowerCamelCase      :  ModelOutput			,   _lowerCamelCase      :  Optional[np.ndarray] = None			,   _lowerCamelCase      :  Optional[np.ndarray] = None			,   _lowerCamelCase      :  Optional[str] = None			,   _lowerCamelCase      :  Optional[Sequence[str]] = None			,   _lowerCamelCase      :  Optional[Sequence[int]] = None			,   ):





						'''simple docstring'''


						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=_lowerCamelCase			,   remark=_lowerCamelCase			,   parents=_lowerCamelCase			,   parents_chain_index=_lowerCamelCase			,   )






from collections import OrderedDict
from typing import TYPE_CHECKING, Any, List, Mapping, Optional, Union

from ...configuration_utils import PretrainedConfig
from ...onnx import OnnxConfig
from ...utils import TensorType, logging


if TYPE_CHECKING:
				from ...onnx.config import PatchingSpec
				from ...tokenization_utils_base import PreTrainedTokenizerBase


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

__lowercase       :Optional[int]       =  {
    "allenai/longformer-base-4096": "https://huggingface.co/allenai/longformer-base-4096/resolve/main/config.json",
    "allenai/longformer-large-4096": "https://huggingface.co/allenai/longformer-large-4096/resolve/main/config.json",
    "allenai/longformer-large-4096-finetuned-triviaqa": (
        "https://huggingface.co/allenai/longformer-large-4096-finetuned-triviaqa/resolve/main/config.json"
    ),
    "allenai/longformer-base-4096-extra.pos.embd.only": (
        "https://huggingface.co/allenai/longformer-base-4096-extra.pos.embd.only/resolve/main/config.json"
    ),
    "allenai/longformer-large-4096-extra.pos.embd.only": (
        "https://huggingface.co/allenai/longformer-large-4096-extra.pos.embd.only/resolve/main/config.json"
    ),
}



class    _a     (				lowercase__							):






							"""simple docstring"""

							snake_case_							 =						"longformer"

							def __init__(      self				:     List[str]							,	a				:     Union[List[int], int] = 5_12							,	a				:     int = 2							,	a				:     int = 1							,	a				:     int = 0							,	a				:     int = 2							,	a				:     int = 3_05_22							,	a				:     int = 7_68							,	a				:     int = 12							,	a				:     int = 12							,	a				:     int = 30_72							,	a				:     str = "gelu"							,	a				:     float = 0.1							,	a				:     float = 0.1							,	a				:     int = 5_12							,	a				:     int = 2							,	a				:     float = 0.02							,	a				:     float = 1E-12							,	a				:     bool = False							,	**a				:     Dict							,	)	->Tuple:
													super().__init__(pad_token_id=a							,	**a    )

													SCREAMING_SNAKE_CASE__     :				int   =					attention_window
													SCREAMING_SNAKE_CASE__     :				Any   =					sep_token_id
													SCREAMING_SNAKE_CASE__     :				str   =					bos_token_id
													SCREAMING_SNAKE_CASE__     :				List[str]   =					eos_token_id
													SCREAMING_SNAKE_CASE__     :				List[str]   =					vocab_size
													SCREAMING_SNAKE_CASE__     :				Optional[Any]   =					hidden_size
													SCREAMING_SNAKE_CASE__     :				List[str]   =					num_hidden_layers
													SCREAMING_SNAKE_CASE__     :				Optional[int]   =					num_attention_heads
													SCREAMING_SNAKE_CASE__     :				List[Any]   =					hidden_act
													SCREAMING_SNAKE_CASE__     :				Optional[int]   =					intermediate_size
													SCREAMING_SNAKE_CASE__     :				List[str]   =					hidden_dropout_prob
													SCREAMING_SNAKE_CASE__     :				Dict   =					attention_probs_dropout_prob
													SCREAMING_SNAKE_CASE__     :				Optional[Any]   =					max_position_embeddings
													SCREAMING_SNAKE_CASE__     :				str   =					type_vocab_size
													SCREAMING_SNAKE_CASE__     :				Any   =					initializer_range
													SCREAMING_SNAKE_CASE__     :				List[Any]   =					layer_norm_eps
													SCREAMING_SNAKE_CASE__     :				Any   =					onnx_export







class    _a     (				lowercase__							):






							"""simple docstring"""

							def __init__(      self				:     int							,	a				:     "PretrainedConfig"							,	a				:     str = "default"							,	a				:     "List[PatchingSpec]" = None    )	->str:
													super().__init__(a							,	a							,	a    )
													SCREAMING_SNAKE_CASE__     :				Any   =					True

							@property
							def      A_  (      self				:     int    )	->Mapping[str, Mapping[int, str]]:
													if self.task == "multiple-choice":
																			SCREAMING_SNAKE_CASE__     :				int   =					{0: "batch", 1: "choice", 2: "sequence"}
													else:
																			SCREAMING_SNAKE_CASE__     :				str   =					{0: "batch", 1: "sequence"}
													return OrderedDict(
													    [
													        ("input_ids", dynamic_axis),
													        ("attention_mask", dynamic_axis),
													        ("global_attention_mask", dynamic_axis),
													    ]    )

							@property
							def      A_  (      self				:     Optional[Any]    )	->Mapping[str, Mapping[int, str]]:
													SCREAMING_SNAKE_CASE__     :				Optional[Any]   =					super().outputs
													if self.task == "default":
																			SCREAMING_SNAKE_CASE__     :				List[str]   =					{0: "batch"}
													return outputs

							@property
							def      A_  (      self				:     str    )	->float:
													return 1E-4

							@property
							def      A_  (      self				:     Any    )	->int:
													# needs to be >= 14 to support tril operator
													return max(super().default_onnx_opset							,	14    )






							def      A_  (      self				:     str							,	a				:     "PreTrainedTokenizerBase"							,	a				:     int = -1							,	a				:     int = -1							,	a				:     bool = False							,	a				:     Optional[TensorType] = None							,	)	->Mapping[str, Any]:
													SCREAMING_SNAKE_CASE__     :				Tuple   =					super().generate_dummy_inputs(
													    preprocessor=a							,	batch_size=a							,	seq_length=a							,	is_pair=a							,	framework=a    )
													import torch

													# for some reason, replacing this code by inputs["global_attention_mask"] = torch.randint(2, inputs["input_ids"].shape, dtype=torch.int64)
													# makes the export fail randomly
													SCREAMING_SNAKE_CASE__     :				Any   =					torch.zeros_like(inputs["input_ids"]    )
													# make every second token global
													SCREAMING_SNAKE_CASE__     :				str   =					1

													return inputs