


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






@dataclasses.dataclass(frozen=__snake_case  )
class   __lowercase				:
      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   _UpperCamelCase				(						lowerCAmelCase_   )						->Protein:
   UpperCAmelCase							=     R"""(\[[A-Z]+\]\n)"""
   UpperCAmelCase							=     [tag.strip() for tag in re.split(lowerCAmelCase_  ,						lowerCAmelCase_   ) if len(lowerCAmelCase_   ) > 0]
   UpperCAmelCase							=     zip(tags[0::2]  ,						[l.split("""\n"""   ) for l in tags[1::2]]   )

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

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

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

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

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

   return pdb_headers
def   _UpperCamelCase				(						lowerCAmelCase_  ,						lowerCAmelCase_   )						->str:
   UpperCAmelCase							=     []
   UpperCAmelCase							=     pdb_str.split("""\n"""   )

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

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

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

   def make_parent_line(lowerCAmelCase_   ) -> str:
      return F"""PARENT {' '.join(lowerCAmelCase_   )}"""

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

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

         out_pdb_lines.append(make_parent_line(lowerCAmelCase_   )   )

   return "\n".join(lowerCAmelCase_   )
def   _UpperCamelCase				(						lowerCAmelCase_   )						->str:
   UpperCAmelCase							=     residue_constants.restypes + ["""X"""]

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

   UpperCAmelCase							=     residue_constants.atom_types

   UpperCAmelCase							=     []

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

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

   UpperCAmelCase							=     get_pdb_headers(lowerCAmelCase_   )
   if len(lowerCAmelCase_   ) > 0:
      pdb_lines.extend(lowerCAmelCase_   )

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

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

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

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

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

      if should_terminate:
         # Close the chain.
         UpperCAmelCase							=     """TER"""
         UpperCAmelCase							=     (
             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_   )						->np.ndarray:
   return residue_constants.STANDARD_ATOM_MASK[prot.aatype]







def   _UpperCamelCase				(						lowerCAmelCase_  ,						lowerCAmelCase_  ,						lowerCAmelCase_ = None  ,						lowerCAmelCase_ = None  ,						lowerCAmelCase_ = None  ,						lowerCAmelCase_ = None  ,						lowerCAmelCase_ = 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=lowerCAmelCase_  ,						remark=lowerCAmelCase_  ,						parents=lowerCAmelCase_  ,						parents_chain_index=lowerCAmelCase_  ,						)







from ...configuration_utils import PretrainedConfig
from ...utils import logging


__a     =			logging.get_logger(__name__)

__a     =			{"""ctrl""": """https://huggingface.co/ctrl/resolve/main/config.json"""}






class   __lowercase				(  __snake_case  ):
      UpperCamelCase								=       '''ctrl'''
      UpperCamelCase								=       ['''past_key_values''']
      UpperCamelCase								=       {
          '''max_position_embeddings''': '''n_positions''',
          '''hidden_size''': '''n_embd''',
          '''num_attention_heads''': '''n_head''',
          '''num_hidden_layers''': '''n_layer''',
      }





      def __init__(		self						:					str					,       __lowerCamelCase						:					Optional[int]=2_4_6_5_3_4					,       __lowerCamelCase						:					Union[str, Any]=2_5_6					,       __lowerCamelCase						:					int=1_2_8_0					,       __lowerCamelCase						:					Optional[Any]=8_1_9_2					,       __lowerCamelCase						:					List[str]=4_8					,       __lowerCamelCase						:					Dict=1_6					,       __lowerCamelCase						:					Union[str, Any]=0.1					,       __lowerCamelCase						:					Union[str, Any]=0.1					,       __lowerCamelCase						:					Union[str, Any]=1e-6					,       __lowerCamelCase						:					str=0.02					,       __lowerCamelCase						:					Union[str, Any]=True					,       **__lowerCamelCase						:					List[str]					,       )    ->   Optional[Any]:






         """simple docstring"""







         UpperCAmelCase							=     vocab_size
         UpperCAmelCase							=     n_positions
         UpperCAmelCase							=     n_embd
         UpperCAmelCase							=     n_layer
         UpperCAmelCase							=     n_head
         UpperCAmelCase							=     dff
         UpperCAmelCase							=     resid_pdrop
         UpperCAmelCase							=     embd_pdrop
         UpperCAmelCase							=     layer_norm_epsilon
         UpperCAmelCase							=     initializer_range

         UpperCAmelCase							=     use_cache

         super().__init__(**__lowerCamelCase       )



