





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    :					Any =      Mapping[str, np.ndarray]
A    :					int =      Mapping[str, Any]  # Is a nested dict.
A    :					Optional[Any] =      0.01


@dataclasses.dataclass(frozen=UpperCAmelCase_    )
class   A			:
			'''simple docstring'''




			__lowerCamelCase	:       np.ndarray  # [num_res, num_atom_type, 3]

			# Amino-acid type for each residue represented as an integer between 0 and
			# 20, where 20 is 'X'.
			__lowerCamelCase	:       np.ndarray  # [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.
			__lowerCamelCase	:       np.ndarray  # [num_res, num_atom_type]

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

			# Chain indices for multi-chain predictions
			__lowerCamelCase	:       Optional[np.ndarray]							=    None

			# Optional remark about the protein. Included as a comment in output PDB
			# files
			__lowerCamelCase	:       Optional[str]							=    None

			# Templates used to generate this protein (prediction-only)
			__lowerCamelCase	:       Optional[Sequence[str]]							=    None

			# Chain corresponding to each parent
			__lowerCamelCase	:       Optional[Sequence[int]]							=    None







def    __lowerCamelCase					(							__a   :Any    )		->				int:






		"""simple docstring"""

		A__        =   R"(\[[A-Z]+\]\n)"
		A__        =   [tag.strip() for tag in re.split(_UpperCAmelCase    ,     _UpperCAmelCase    ) if len(_UpperCAmelCase    ) > 0]
		A__        =   zip(tags[0::2]    ,     [l.split("""\n"""    ) for l in tags[1::2]]    )

		A__        =   ["N", "CA", "C"]
		A__        =   None
		A__        =   None
		A__        =   None
		for g in groups:
				if "[PRIMARY]" == g[0]:
						A__        =   g[1][0].strip()
						for i in range(len(_UpperCAmelCase    )    ):
								if seq[i] not in residue_constants.restypes:
										A__        =   "X"  # FIXME: strings are immutable
						A__        =   np.array(
						    [residue_constants.restype_order.get(_UpperCAmelCase    ,     residue_constants.restype_num    ) for res_symbol in seq]    )
				elif "[TERTIARY]" == g[0]:
						A__        =   []
						for axis in range(3    ):
								tertiary.append(list(map(_UpperCAmelCase    ,     g[1][axis].split()    )    )    )
						A__        =   np.array(_UpperCAmelCase    )
						A__        =   np.zeros((len(tertiary[0]    ) // 3, residue_constants.atom_type_num, 3)    ).astype(np.floataa    )
						for i, atom in enumerate(_UpperCAmelCase    ):
								A__        =   np.transpose(tertiary_np[:, i::3]    )
						atom_positions *= PICO_TO_ANGSTROM
				elif "[MASK]" == g[0]:
						A__        =   np.array(list(map({"""-""": 0, """+""": 1}.get    ,     g[1][0].strip()    )    )    )
						A__        =   np.zeros(
						    (
						        len(_UpperCAmelCase    ),
						        residue_constants.atom_type_num,
						    )    ).astype(np.floataa    )
						for i, atom in enumerate(_UpperCAmelCase    ):
								A__        =   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    __lowerCamelCase					(							__a   :Tuple    ,     __a   :Tuple = 0    )		->				Optional[Any]:






		"""simple docstring"""

		A__        =   []

		A__        =   prot.remark
		if remark is not None:
				pdb_headers.append(F'REMARK {remark}'    )

		A__        =   prot.parents
		A__        =   prot.parents_chain_index
		if parents is not None and parents_chain_index is not None:
				A__        =   [p for i, p in zip(_UpperCAmelCase    ,     _UpperCAmelCase    ) if i == chain_id]

		if parents is None or len(_UpperCAmelCase    ) == 0:
				A__        =   ["N/A"]

		pdb_headers.append(F'PARENT {" ".join(_UpperCAmelCase    )}'    )

		return pdb_headers







def    __lowerCamelCase					(							__a   :Union[str, Any]    ,     __a   :str    )		->				Optional[Any]:






		"""simple docstring"""

		A__        =   []
		A__        =   pdb_str.split("""\n"""    )

		A__        =   prot.remark
		if remark is not None:
				out_pdb_lines.append(F'REMARK {remark}'    )

		A__        =   42
		if prot.parents is not None and len(prot.parents    ) > 0:
				A__        =   []
				if prot.parents_chain_index is not None:
						A__        =   {}
						for p, i in zip(prot.parents    ,     prot.parents_chain_index    ):
								parent_dict.setdefault(str(_UpperCAmelCase    )    ,     []    )
								parent_dict[str(_UpperCAmelCase    )].append(_UpperCAmelCase    )

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

		def make_parent_line(__a   :List[Any]    ) -> str:
				return F'PARENT {" ".join(_UpperCAmelCase    )}'

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

		A__        =   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    ):
								A__        =   parents_per_chain[chain_counter]
						else:
								A__        =   ["N/A"]

						out_pdb_lines.append(make_parent_line(_UpperCAmelCase    )    )

		return "\n".join(_UpperCAmelCase    )







def    __lowerCamelCase					(							__a   :Optional[int]    )		->				Union[str, Any]:






		"""simple docstring"""

		A__        =   residue_constants.restypes + ["X"]

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

		A__        =   residue_constants.atom_types

		A__        =   []

		A__        =   prot.atom_mask
		A__        =   prot.aatype
		A__        =   prot.atom_positions
		A__        =   prot.residue_index.astype(np.intaa    )
		A__        =   prot.b_factors
		A__        =   prot.chain_index

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

		A__        =   get_pdb_headers(_UpperCAmelCase    )
		if len(_UpperCAmelCase    ) > 0:
				pdb_lines.extend(_UpperCAmelCase    )

		A__        =   aatype.shape[0]
		A__        =   1
		A__        =   0
		A__        =   string.ascii_uppercase
		A__        =   None
		# Add all atom sites.
		for i in range(_UpperCAmelCase    ):
				A__        =   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

						A__        =   "ATOM"
						A__        =   atom_name if len(_UpperCAmelCase    ) == 4 else F' {atom_name}'
						A__        =   ""
						A__        =   ""
						A__        =   1.00
						A__        =   atom_name[0]  # Protein supports only C, N, O, S, this works.
						A__        =   ""

						A__        =   "A"
						if chain_index is not None:
								A__        =   chain_tags[chain_index[i]]

						# PDB is a columnar format, every space matters here!
						A__        =   (
						    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

				A__        =   i == n - 1
				if chain_index is not None:
						if i != n - 1 and chain_index[i + 1] != prev_chain_index:
								A__        =   True
								A__        =   chain_index[i + 1]

				if should_terminate:
						# Close the chain.
						A__        =   "TER"
						A__        =   (
						    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    __lowerCamelCase					(							__a   :List[str]    )		->				Optional[Any]:






		"""simple docstring"""

		return residue_constants.STANDARD_ATOM_MASK[prot.aatype]







def    __lowerCamelCase					(							__a   :Any    ,     __a   :Union[str, Any]    ,     __a   :int = None    ,     __a   :int = None    ,     __a   :Optional[Any] = None    ,     __a   :Any = None    ,     __a   :Optional[int] = None    ,     )		->				Optional[Any]:






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






from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_flax_available,
    is_sentencepiece_available,
    is_tf_available,
    is_tokenizers_available,
    is_torch_available,
)


if is_sentencepiece_available():
						from ..ta.tokenization_ta import TaTokenizer
else:
						from ...utils.dummy_sentencepiece_objects import TaTokenizer

lowerCAmelCase							:  Any   	=						TaTokenizer

if is_tokenizers_available():
						from ..ta.tokenization_ta_fast import TaTokenizerFast
else:
						from ...utils.dummy_tokenizers_objects import TaTokenizerFast

lowerCAmelCase							:  Dict   	=						TaTokenizerFast

lowerCAmelCase							:  Optional[int]   	=						{"""configuration_mt5""": ["""MT5Config""", """MT5OnnxConfig"""]}

try:
						if not is_torch_available():
												raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
						pass
else:
						lowerCAmelCase							:  int   	=						[
						    """MT5EncoderModel""",
						    """MT5ForConditionalGeneration""",
						    """MT5ForQuestionAnswering""",
						    """MT5Model""",
						    """MT5PreTrainedModel""",
						    """MT5Stack""",
						]

try:
						if not is_tf_available():
												raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
						pass
else:
						lowerCAmelCase							:  Tuple   	=						["""TFMT5EncoderModel""", """TFMT5ForConditionalGeneration""", """TFMT5Model"""]

try:
						if not is_flax_available():
												raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
						pass
else:
						lowerCAmelCase							:  List[str]   	=						["""FlaxMT5EncoderModel""", """FlaxMT5ForConditionalGeneration""", """FlaxMT5Model"""]


if TYPE_CHECKING:
						from .configuration_mta import MTaConfig, MTaOnnxConfig

						try:
												if not is_torch_available():
																		raise OptionalDependencyNotAvailable()
						except OptionalDependencyNotAvailable:
												pass
						else:
												from .modeling_mta import (
												    MTaEncoderModel,
												    MTaForConditionalGeneration,
												    MTaForQuestionAnswering,
												    MTaModel,
												    MTaPreTrainedModel,
												    MTaStack,
												)

						try:
												if not is_tf_available():
																		raise OptionalDependencyNotAvailable()
						except OptionalDependencyNotAvailable:
												pass
						else:
												from .modeling_tf_mta import TFMTaEncoderModel, TFMTaForConditionalGeneration, TFMTaModel

						try:
												if not is_flax_available():
																		raise OptionalDependencyNotAvailable()
						except OptionalDependencyNotAvailable:
												pass
						else:
												from .modeling_flax_mta import FlaxMTaEncoderModel, FlaxMTaForConditionalGeneration, FlaxMTaModel

else:
						import sys

						lowerCAmelCase							:  Optional[Any]   	=						_LazyModule(
						    __name__,
						    globals()["""__file__"""],
						    _import_structure,
						    extra_objects={"""MT5Tokenizer""": MTaTokenizer, """MT5TokenizerFast""": MTaTokenizerFast},
						    module_spec=__spec__,
						)






