






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


SCREAMING_SNAKE_CASE						=	Mapping[str, np.ndarray]
SCREAMING_SNAKE_CASE						=	Mapping[str, Any]  # Is a nested dict.
SCREAMING_SNAKE_CASE						=	0.01
@dataclasses.dataclass(frozen=__A				)
class UpperCAmelCase_					:




      """simple docstring"""




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

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

      # Chain indices for multi-chain predictions
      UpperCamelCase_								=			None

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

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

      # Chain corresponding to each parent
      UpperCamelCase_								=			None





def 							lowercase_				(    __A :       str			)       ->      Protein:



 """simple docstring"""




 lowercase					:   int				  =R'''(\[[A-Z]+\]\n)'''
 lowercase					:   List[str]				  =[tag.strip() for tag in re.split(__A					,      __A			) if len(__A			) > 0]
 lowercase					:   Iterator[Tuple[str, List[str]]]				  =zip(tags[0::2]					,      [l.split('''\n'''			) for l in tags[1::2]]			)

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

 assert aatype is not None

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


def 							lowercase_				(    __A :       Protein					,      __A :       int = 0			)       ->      List[str]:



 """simple docstring"""




 lowercase					:   List[str]				  =[]

 lowercase					:   List[str]				  =prot.remark
 if remark is not None:
  pdb_headers.append(F'REMARK {remark}'			)

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

 if parents is None or len(__A			) == 0:
  lowercase					:   Optional[Any]				  =['''N/A''']

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

 return pdb_headers


def 							lowercase_				(    __A :       Protein					,      __A :       str			)       ->      str:



 """simple docstring"""




 lowercase					:   List[str]				  =[]
 lowercase					:   Any				  =pdb_str.split('''\n'''			)

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

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

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

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

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

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

   out_pdb_lines.append(make_parent_line(__A			)			)

 return "\n".join(__A			)


def 							lowercase_				(    __A :       Protein			)       ->      str:



 """simple docstring"""




 lowercase					:   List[str]				  =residue_constants.restypes + ['''X''']

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

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

 lowercase					:   List[str]				  =[]

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

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

 lowercase					:   List[str]				  =get_pdb_headers(__A			)
 if len(__A			) > 0:
  pdb_lines.extend(__A			)

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

   lowercase					:   str				  ='''ATOM'''
   lowercase					:   Optional[int]				  =atom_name if len(__A			) == 4 else F' {atom_name}'
   lowercase					:   List[str]				  =''''''
   lowercase					:   int				  =''''''
   lowercase					:   Optional[Any]				  =1.00
   lowercase					:   Tuple				  =atom_name[0]  # Protein supports only C, N, O, S, this works.
   lowercase					:   Union[str, Any]				  =''''''

   lowercase					:   List[str]				  ='''A'''
   if chain_index is not None:
    lowercase					:   List[Any]				  =chain_tags[chain_index[i]]

   # PDB is a columnar format, every space matters here!
   lowercase					:   str				  =(
       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(__A			)
   atom_index += 1

  lowercase					:   Union[str, Any]				  =i == n - 1
  if chain_index is not None:
   if i != n - 1 and chain_index[i + 1] != prev_chain_index:
    lowercase					:   Optional[Any]				  =True
    lowercase					:   Dict				  =chain_index[i + 1]

  if should_terminate:
   # Close the chain.
   lowercase					:   Union[str, Any]				  ='''TER'''
   lowercase					:   Any				  =(
       F'{chain_end:<6}{atom_index:>5}      {res_atoa(aatype[i]			):>3} {chain_tag:>1}{residue_index[i]:>4}'
   )
   pdb_lines.append(__A			)
   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(__A					,      __A			)			)

 pdb_lines.append('''END'''			)
 pdb_lines.append(''''''			)
 return "\n".join(__A			)


def 							lowercase_				(    __A :       Protein			)       ->      np.ndarray:



 """simple docstring"""




 return residue_constants.STANDARD_ATOM_MASK[prot.aatype]





def 							lowercase_				(    __A :       FeatureDict					,      __A :       ModelOutput					,      __A :       Optional[np.ndarray] = None					,      __A :       Optional[np.ndarray] = None					,      __A :       Optional[str] = None					,      __A :       Optional[Sequence[str]] = None					,      __A :       Optional[Sequence[int]] = None					,      )       ->      Protein:



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











'''simple docstring'''



from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_tokenizers_available, is_torch_available


SCREAMING_SNAKE_CASE						=	{
    'configuration_m2m_100': ['M2M_100_PRETRAINED_CONFIG_ARCHIVE_MAP', 'M2M100Config', 'M2M100OnnxConfig'],
    'tokenization_m2m_100': ['M2M100Tokenizer'],
}


try:
      if not is_torch_available():
            raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
      pass
else:
      SCREAMING_SNAKE_CASE						=	[
          'M2M_100_PRETRAINED_MODEL_ARCHIVE_LIST',
          'M2M100ForConditionalGeneration',
          'M2M100Model',
          'M2M100PreTrainedModel',
      ]


if TYPE_CHECKING:
      from .configuration_mam_aaa import M2M_100_PRETRAINED_CONFIG_ARCHIVE_MAP, MaMaaaConfig, MaMaaaOnnxConfig
      from .tokenization_mam_aaa import MaMaaaTokenizer

      try:
            if not is_torch_available():
                  raise OptionalDependencyNotAvailable()
      except OptionalDependencyNotAvailable:
            pass
      else:
            from .modeling_mam_aaa import (
                M2M_100_PRETRAINED_MODEL_ARCHIVE_LIST,
                MaMaaaForConditionalGeneration,
                MaMaaaModel,
                MaMaaaPreTrainedModel,
            )


else:
      import sys

      SCREAMING_SNAKE_CASE						=	_LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)



