





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.0_1



@dataclasses.dataclass(frozen=__SCREAMING_SNAKE_CASE    )
class    _SCREAMING_SNAKE_CASE						:







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

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

 # Chain indices for multi-chain predictions
 lowercase_		=			None

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

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

 # Chain corresponding to each parent
 lowercase_		=			None





def      lowerCAmelCase_ (       __a		)     ->		Protein:







  """simple docstring"""





  lowerCamelCase__:      Union[str, Any]			  =R"(\[[A-Z]+\]\n)"
  lowerCamelCase__:      List[str]			  =[tag.strip() for tag in re.split(__a	,    __a		) if len(__a		) > 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__:      int			  =None
  lowerCamelCase__:      str			  =None
  lowerCamelCase__:      Dict			  =None
  for g in groups:
    if "[PRIMARY]" == g[0]:
      lowerCamelCase__:      Optional[Any]			  =g[1][0].strip()
      for i in range(len(__a		)		):
        if seq[i] not in residue_constants.restypes:
          lowerCamelCase__:      Optional[int]			  ="X"  # FIXME: strings are immutable
      lowerCamelCase__:      Optional[int]			  =np.array(
          [residue_constants.restype_order.get(__a	,    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(__a	,    g[1][axis].split()		)		)		)
      lowerCamelCase__:      List[str]			  =np.array(__a		)
      lowerCamelCase__:      List[str]			  =np.zeros((len(tertiary[0]		) // 3, residue_constants.atom_type_num, 3)		).astype(np.floataa		)
      for i, atom in enumerate(__a		):
        lowerCamelCase__:      str			  =np.transpose(tertiary_np[:, i::3]		)
      atom_positions *= PICO_TO_ANGSTROM
    elif "[MASK]" == g[0]:
      lowerCamelCase__:      int			  =np.array(list(map({"-": 0, "+": 1}.get	,    g[1][0].strip()		)		)		)
      lowerCamelCase__:      Dict			  =np.zeros(
          (
              len(__a		),
              residue_constants.atom_type_num,
          )		).astype(np.floataa		)
      for i, atom in enumerate(__a		):
        lowerCamelCase__:      int			  =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      lowerCAmelCase_ (       __a	,    __a = 0		)     ->		List[str]:







  """simple docstring"""





  lowerCamelCase__:      List[str]			  =[]

  lowerCamelCase__:      Optional[Any]			  =prot.remark
  if remark is not None:
    pdb_headers.append(F"""REMARK {remark}"""		)

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

  if parents is None or len(__a		) == 0:
    lowerCamelCase__:      Optional[int]			  =["N/A"]

  pdb_headers.append(F"""PARENT {" ".join(__a		)}"""		)

  return pdb_headers





def      lowerCAmelCase_ (       __a	,    __a		)     ->		str:







  """simple docstring"""





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

  lowerCamelCase__:      Optional[Any]			  =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__:      int			  =[]
    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(__a		)	,    []		)
        parent_dict[str(__a		)].append(__a		)

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

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

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

  lowerCamelCase__:      Optional[int]			  =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		):
        lowerCamelCase__:      Union[str, Any]			  =parents_per_chain[chain_counter]
      else:
        lowerCamelCase__:      int			  =["N/A"]

      out_pdb_lines.append(make_parent_line(__a		)		)

  return "\n".join(__a		)





def      lowerCAmelCase_ (       __a		)     ->		str:







  """simple docstring"""





  lowerCamelCase__:      str			  =residue_constants.restypes + ["X"]

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

  lowerCamelCase__:      List[str]			  =residue_constants.atom_types

  lowerCamelCase__:      List[str]			  =[]

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

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

  lowerCamelCase__:      str			  =get_pdb_headers(__a		)
  if len(__a		) > 0:
    pdb_lines.extend(__a		)

  lowerCamelCase__:      Dict			  =aatype.shape[0]
  lowerCamelCase__:      Dict			  =1
  lowerCamelCase__:      List[Any]			  =0
  lowerCamelCase__:      Optional[Any]			  =string.ascii_uppercase
  lowerCamelCase__:      List[str]			  =None
  # Add all atom sites.
  for i in range(__a		):
    lowerCamelCase__:      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

      lowerCamelCase__:      Union[str, Any]			  ="ATOM"
      lowerCamelCase__:      Union[str, Any]			  =atom_name if len(__a		) == 4 else F""" {atom_name}"""
      lowerCamelCase__:      int			  =""
      lowerCamelCase__:      List[str]			  =""
      lowerCamelCase__:      int			  =1.0_0
      lowerCamelCase__:      Optional[int]			  =atom_name[0]  # Protein supports only C, N, O, S, this works.
      lowerCamelCase__:      Dict			  =""

      lowerCamelCase__:      Union[str, Any]			  ="A"
      if chain_index is not None:
        lowerCamelCase__:      Any			  =chain_tags[chain_index[i]]

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

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

    if should_terminate:
      # Close the chain.
      lowerCamelCase__:      str			  ="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(__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      lowerCAmelCase_ (       __a		)     ->		np.ndarray:







  """simple docstring"""





  return residue_constants.STANDARD_ATOM_MASK[prot.aatype]






def      lowerCAmelCase_ (       __a	,    __a	,    __a = None	,    __a = None	,    __a = None	,    __a = None	,    __a = 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	,    )





import os
from shutil import copyfile
from typing import Any, Dict, List, Optional, Tuple

import sentencepiece as spm

from ...tokenization_utils import AddedToken, PreTrainedTokenizer
from ...utils import logging


_A		       =						logging.get_logger(__name__)

_A		       =						'▁'

_A		       =						{'vocab_file': 'sentencepiece.bpe.model', 'monolingual_vocab_file': 'dict.txt'}

_A		       =						{
    'vocab_file': {
        'vinai/bartpho-syllable': 'https://huggingface.co/vinai/bartpho-syllable/resolve/main/sentencepiece.bpe.model',
    },
    'monolingual_vocab_file': {
        'vinai/bartpho-syllable': 'https://huggingface.co/vinai/bartpho-syllable/resolve/main/dict.txt',
    },
}

_A		       =						{'vinai/bartpho-syllable': 1024}






class     UpperCAmelCase__       (					A_		):



    """simple docstring"""






    UpperCAmelCase__						:		Any      =  VOCAB_FILES_NAMES
    UpperCAmelCase__						:		int      =  PRETRAINED_VOCAB_FILES_MAP
    UpperCAmelCase__						:		Tuple      =  PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
    UpperCAmelCase__						:		str      =  ["input_ids", "attention_mask"]






    def __init__(			self					,   A_					,   A_					,   A_="<s>"					,   A_="</s>"					,   A_="</s>"					,   A_="<s>"					,   A_="<unk>"					,   A_="<pad>"					,   A_="<mask>"					,   A_ = None					,   **A_					,   )  ->       None:
         # Mask token behave like a normal word, i.e. include the space before it
         __UpperCamelCase    							=AddedToken(A_					,   lstrip=A_					,   rstrip=A_    ) if isinstance(A_					,   A_    ) else mask_token

         __UpperCamelCase    							={} if sp_model_kwargs is None else sp_model_kwargs

         super().__init__(
             bos_token=A_					,   eos_token=A_					,   unk_token=A_					,   sep_token=A_					,   cls_token=A_					,   pad_token=A_					,   mask_token=A_					,   sp_model_kwargs=self.sp_model_kwargs					,   **A_					,   )

         __UpperCamelCase    							=vocab_file
         __UpperCamelCase    							=monolingual_vocab_file
         __UpperCamelCase    							=spm.SentencePieceProcessor(**self.sp_model_kwargs    )
         self.sp_model.Load(str(A_    )    )

         # Load the reduced vocab

         # Keep order of special tokens for backward compatibility
         __UpperCamelCase    							={}
         __UpperCamelCase    							=0
         for token in [bos_token, pad_token, eos_token, unk_token, sep_token, cls_token]:
              if str(A_    ) not in self.fairseq_tokens_to_ids:
                   __UpperCamelCase    							=cnt
                   cnt += 1
         with open(A_					,   'r'					,   encoding='utf-8'    ) as f:
              for line in f.readlines():
                   __UpperCamelCase    							=line.strip().split()[0]
                   __UpperCamelCase    							=len(self.fairseq_tokens_to_ids    )
         if str(A_    ) not in self.fairseq_tokens_to_ids:
              __UpperCamelCase    							=len(self.fairseq_tokens_to_ids    )

         __UpperCamelCase    							={v: k for k, v in self.fairseq_tokens_to_ids.items()}






    def __getstate__(			self    )  ->       Any:
         __UpperCamelCase    							=self.__dict__.copy()
         __UpperCamelCase    							=None
         __UpperCamelCase    							=self.sp_model.serialized_model_proto()
         return state






    def __setstate__(			self					,   A_    )  ->       List[str]:
         __UpperCamelCase    							=d

         # for backward compatibility
         if not hasattr(self					,   'sp_model_kwargs'    ):
              __UpperCamelCase    							={}

         __UpperCamelCase    							=spm.SentencePieceProcessor(**self.sp_model_kwargs    )
         self.sp_model.LoadFromSerializedProto(self.sp_model_proto    )






    def _a					(			self					,   A_					,   A_ = None    )  ->       List[int]:

         if token_ids_a is None:
              return [self.cls_token_id] + token_ids_a + [self.sep_token_id]
         __UpperCamelCase    							=[self.cls_token_id]
         __UpperCamelCase    							=[self.sep_token_id]
         return cls + token_ids_a + sep + sep + token_ids_a + sep






    def _a					(			self					,   A_					,   A_ = None					,   A_ = False    )  ->       List[int]:

         if already_has_special_tokens:
              return super().get_special_tokens_mask(
                  token_ids_a=A_					,   token_ids_a=A_					,   already_has_special_tokens=A_    )

         if token_ids_a is None:
              return [1] + ([0] * len(A_    )) + [1]
         return [1] + ([0] * len(A_    )) + [1, 1] + ([0] * len(A_    )) + [1]






    def _a					(			self					,   A_					,   A_ = None    )  ->       List[int]:
         __UpperCamelCase    							=[self.sep_token_id]
         __UpperCamelCase    							=[self.cls_token_id]

         if token_ids_a is None:
              return len(cls + token_ids_a + sep    ) * [0]
         return len(cls + token_ids_a + sep + sep + token_ids_a + sep    ) * [0]






    @property
    def _a					(			self    )  ->       Any:
         return len(self.fairseq_ids_to_tokens    )






    def _a					(			self    )  ->       Union[str, Any]:
         __UpperCamelCase    							={self.convert_ids_to_tokens(A_    ): i for i in range(self.vocab_size    )}
         vocab.update(self.added_tokens_encoder    )
         return vocab






    def _a					(			self					,   A_    )  ->       List[str]:
         return self.sp_model.encode(A_					,   out_type=A_    )






    def _a					(			self					,   A_    )  ->       str:
         if token in self.fairseq_tokens_to_ids:
              return self.fairseq_tokens_to_ids[token]
         else:
              return self.unk_token_id






    def _a					(			self					,   A_    )  ->       int:
         return self.fairseq_ids_to_tokens[index]






    def _a					(			self					,   A_    )  ->       List[Any]:
         __UpperCamelCase    							=''.join(A_    ).replace(A_					,   ' '    ).strip()
         return out_string






    def _a					(			self					,   A_					,   A_ = None    )  ->       Tuple[str]:
         if not os.path.isdir(A_    ):
              logger.error(f'Vocabulary path ({save_directory}) should be a directory'    )
              return
         __UpperCamelCase    							=os.path.join(
             A_					,   (filename_prefix + '-' if filename_prefix else '') + VOCAB_FILES_NAMES['vocab_file']    )
         __UpperCamelCase    							=os.path.join(
             A_					,   (filename_prefix + '-' if filename_prefix else '') + VOCAB_FILES_NAMES['monolingual_vocab_file']					,   )

         if os.path.abspath(self.vocab_file    ) != os.path.abspath(A_    ) and os.path.isfile(self.vocab_file    ):
              copyfile(self.vocab_file					,   A_    )
         elif not os.path.isfile(self.vocab_file    ):
              with open(A_					,   'wb'    ) as fi:
                   __UpperCamelCase    							=self.sp_model.serialized_model_proto()
                   fi.write(A_    )

         if os.path.abspath(self.monolingual_vocab_file    ) != os.path.abspath(
             A_    ) and os.path.isfile(self.monolingual_vocab_file    ):
              copyfile(self.monolingual_vocab_file					,   A_    )
         elif not os.path.isfile(self.monolingual_vocab_file    ):
              with open(A_					,   'w'					,   encoding='utf-8'    ) as fp:
                   for token in self.fairseq_tokens_to_ids:
                        if token not in self.all_special_tokens:
                             fp.write(f'{str(A_    )} \n'    )

         return out_vocab_file, out_monolingual_vocab_file





