


'''simple docstring'''

import json
import os
from functools import lru_cache
from typing import TYPE_CHECKING, List, Optional, Tuple

import regex as re

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


if TYPE_CHECKING:
 from transformers.pipelines.conversational import Conversation

lowerCamelCase							:   List[str]  						=	logging.get_logger(__name__)


lowerCamelCase							:   List[Any]  						=	{
    'vocab_file': 'vocab.json',
    'merges_file': 'merges.txt',
    'tokenizer_config_file': 'tokenizer_config.json',
}

lowerCamelCase							:   List[str]  						=	{
    'vocab_file': {'facebook/blenderbot-3B': 'https://huggingface.co/facebook/blenderbot-3B/resolve/main/vocab.json'},
    'merges_file': {'facebook/blenderbot-3B': 'https://huggingface.co/facebook/blenderbot-3B/resolve/main/merges.txt'},
    'tokenizer_config_file': {
        'facebook/blenderbot-3B': 'https://huggingface.co/facebook/blenderbot-3B/resolve/main/tokenizer_config.json'
    },
}

lowerCamelCase							:   Optional[int]  						=	{'facebook/blenderbot-3B': 128}

@lru_cache()
# Copied from transformers.models.roberta.tokenization_roberta.bytes_to_unicode
def _SCREAMING_SNAKE_CASE      ()       ->       Optional[int]:






       """simple docstring"""







       lowercase__      			= (
           list(range(ord('''!'''       )  , ord('''~'''       ) + 1       )       ) + list(range(ord('''¡'''       )  , ord('''¬'''       ) + 1       )       ) + list(range(ord('''®'''       )  , ord('''ÿ'''       ) + 1       )       )
       )
       lowercase__      			= bs[:]
       lowercase__      			= 0
       for b in range(2**8       ):
              if b not in bs:
                     bs.append(A       )
                     cs.append(2**8 + n       )
                     n += 1
       lowercase__      			= [chr(A       ) for n in cs]
       return dict(zip(A  , A       )       )

def _SCREAMING_SNAKE_CASE      (A       )       ->       Optional[int]:






       """simple docstring"""







       lowercase__      			= set()
       lowercase__      			= word[0]
       for char in word[1:]:
              pairs.add((prev_char, char)       )
              lowercase__      			= char
       return pairs

class   __lowerCAmelCase						(lowercase_     ):





      '''simple docstring'''






      lowerCAmelCase__					:     int  					=							VOCAB_FILES_NAMES
      lowerCAmelCase__					:     List[str]  					=							PRETRAINED_VOCAB_FILES_MAP
      lowerCAmelCase__					:     Union[str, Any]  					=							PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
      lowerCAmelCase__					:     Optional[int]  					=							["""input_ids""", """attention_mask"""]



      def __init__(self    :    Optional[int]   ,						UpperCamelCase    :    List[Any]   ,						UpperCamelCase    :    Any   ,						UpperCamelCase    :    List[str]="replace"   ,						UpperCamelCase    :    Any="<s>"   ,						UpperCamelCase    :    Optional[int]="</s>"   ,						UpperCamelCase    :    List[str]="</s>"   ,						UpperCamelCase    :    Dict="<s>"   ,						UpperCamelCase    :    Tuple="<unk>"   ,						UpperCamelCase    :    Union[str, Any]="<pad>"   ,						UpperCamelCase    :    Optional[Any]="<mask>"   ,						UpperCamelCase    :    str=False   ,						**UpperCamelCase    :    Union[str, Any]   ,						):

             '''simple docstring'''







             lowercase__      			= AddedToken(UpperCamelCase   ,						lstrip=UpperCamelCase   ,						rstrip=UpperCamelCase ) if isinstance(UpperCamelCase   ,						UpperCamelCase ) else bos_token
             lowercase__      			= AddedToken(UpperCamelCase   ,						lstrip=UpperCamelCase   ,						rstrip=UpperCamelCase ) if isinstance(UpperCamelCase   ,						UpperCamelCase ) else eos_token
             lowercase__      			= AddedToken(UpperCamelCase   ,						lstrip=UpperCamelCase   ,						rstrip=UpperCamelCase ) if isinstance(UpperCamelCase   ,						UpperCamelCase ) else sep_token
             lowercase__      			= AddedToken(UpperCamelCase   ,						lstrip=UpperCamelCase   ,						rstrip=UpperCamelCase ) if isinstance(UpperCamelCase   ,						UpperCamelCase ) else cls_token
             lowercase__      			= AddedToken(UpperCamelCase   ,						lstrip=UpperCamelCase   ,						rstrip=UpperCamelCase ) if isinstance(UpperCamelCase   ,						UpperCamelCase ) else unk_token
             lowercase__      			= AddedToken(UpperCamelCase   ,						lstrip=UpperCamelCase   ,						rstrip=UpperCamelCase ) if isinstance(UpperCamelCase   ,						UpperCamelCase ) else pad_token

             # Mask token behave like a normal word, i.e. include the space before it
             lowercase__      			= AddedToken(UpperCamelCase   ,						lstrip=UpperCamelCase   ,						rstrip=UpperCamelCase ) if isinstance(UpperCamelCase   ,						UpperCamelCase ) else mask_token

             super().__init__(
                 errors=UpperCamelCase   ,						bos_token=UpperCamelCase   ,						eos_token=UpperCamelCase   ,						unk_token=UpperCamelCase   ,						sep_token=UpperCamelCase   ,						cls_token=UpperCamelCase   ,						pad_token=UpperCamelCase   ,						mask_token=UpperCamelCase   ,						add_prefix_space=UpperCamelCase   ,						**UpperCamelCase   ,						)

             with open(UpperCamelCase   ,						encoding='''utf-8''' ) as vocab_handle:
                    lowercase__      			= json.load(UpperCamelCase )
             lowercase__      			= {v: k for k, v in self.encoder.items()}
             lowercase__      			= errors  # how to handle errors in decoding
             lowercase__      			= bytes_to_unicode()
             lowercase__      			= {v: k for k, v in self.byte_encoder.items()}
             with open(UpperCamelCase   ,						encoding='''utf-8''' ) as merges_handle:
                    lowercase__      			= merges_handle.read().split('''\n''' )[1:-1]
             lowercase__      			= [tuple(merge.split() ) for merge in bpe_merges]
             lowercase__      			= dict(zip(UpperCamelCase   ,						range(len(UpperCamelCase ) ) ) )
             lowercase__      			= {}
             lowercase__      			= add_prefix_space

             # Should have added re.IGNORECASE so BPE merges can happen for capitalized versions of contractions
             lowercase__      			= re.compile(R'''\'s|\'t|\'re|\'ve|\'m|\'ll|\'d| ?\p{L}+| ?\p{N}+| ?[^\s\p{L}\p{N}]+|\s+(?!\S)|\s+''' )



      @property
      # Copied from transformers.models.roberta.tokenization_roberta.RobertaTokenizer.vocab_size with Roberta->Blenderbot, RoBERTa->Blenderbot
      def       UpperCamelCase__		(self    :    int ):

             '''simple docstring'''







             return len(self.encoder )



      def       UpperCamelCase__		(self    :    Dict ):

             '''simple docstring'''







             return dict(self.encoder   ,						**self.added_tokens_encoder )



      def       UpperCamelCase__		(self    :    str   ,						UpperCamelCase    :    Tuple ):

             '''simple docstring'''







             if token in self.cache:
                    return self.cache[token]
             lowercase__      			= tuple(UpperCamelCase )
             lowercase__      			= get_pairs(UpperCamelCase )

             if not pairs:
                    return token

             while True:
                    lowercase__      			= min(UpperCamelCase   ,						key=lambda UpperCamelCase : self.bpe_ranks.get(UpperCamelCase   ,						float('''inf''' ) ) )
                    if bigram not in self.bpe_ranks:
                           break
                    lowercase__			,lowercase__      			= bigram
                    lowercase__      			= []
                    lowercase__      			= 0
                    while i < len(UpperCamelCase ):
                           try:
                                  lowercase__      			= word.index(UpperCamelCase   ,						UpperCamelCase )
                           except ValueError:
                                  new_word.extend(word[i:] )
                                  break
                           else:
                                  new_word.extend(word[i:j] )
                                  lowercase__      			= j

                           if word[i] == first and i < len(UpperCamelCase ) - 1 and word[i + 1] == second:
                                  new_word.append(first + second )
                                  i += 2
                           else:
                                  new_word.append(word[i] )
                                  i += 1
                    lowercase__      			= tuple(UpperCamelCase )
                    lowercase__      			= new_word
                    if len(UpperCamelCase ) == 1:
                           break
                    else:
                           lowercase__      			= get_pairs(UpperCamelCase )
             lowercase__      			= ''' '''.join(UpperCamelCase )
             lowercase__      			= word
             return word



      def       UpperCamelCase__		(self    :    Union[str, Any]   ,						UpperCamelCase    :    Any ):

             '''simple docstring'''







             lowercase__      			= []
             for token in re.findall(self.pat   ,						UpperCamelCase ):
                    lowercase__      			= ''''''.join(
                        self.byte_encoder[b] for b in token.encode('''utf-8''' ) )  # Maps all our bytes to unicode strings, avoiding control tokens of the BPE (spaces in our case)
                    bpe_tokens.extend(bpe_token for bpe_token in self.bpe(UpperCamelCase ).split(''' ''' ) )
             return bpe_tokens



      def       UpperCamelCase__		(self    :    Dict   ,						UpperCamelCase    :    Optional[int] ):

             '''simple docstring'''







             return self.encoder.get(UpperCamelCase   ,						self.encoder.get(self.unk_token ) )



      def       UpperCamelCase__		(self    :    Dict   ,						UpperCamelCase    :    Optional[Any] ):

             '''simple docstring'''







             return self.decoder.get(UpperCamelCase )



      def       UpperCamelCase__		(self    :    Optional[Any]   ,						UpperCamelCase    :    int ):

             '''simple docstring'''







             lowercase__      			= ''''''.join(UpperCamelCase )
             lowercase__      			= bytearray([self.byte_decoder[c] for c in text] ).decode('''utf-8'''   ,						errors=self.errors )
             return text



      def       UpperCamelCase__		(self    :    Optional[int]   ,						UpperCamelCase    :    str   ,						UpperCamelCase    :    Optional[str] = None ):

             '''simple docstring'''







             if not os.path.isdir(UpperCamelCase ):
                    logger.error(f"Vocabulary path ({save_directory}) should be a directory" )
                    return
             lowercase__      			= os.path.join(
                 UpperCamelCase   ,						(filename_prefix + '''-''' if filename_prefix else '''''') + VOCAB_FILES_NAMES['''vocab_file'''] )
             lowercase__      			= os.path.join(
                 UpperCamelCase   ,						(filename_prefix + '''-''' if filename_prefix else '''''') + VOCAB_FILES_NAMES['''merges_file'''] )

             with open(UpperCamelCase   ,						'''w'''   ,						encoding='''utf-8''' ) as f:
                    f.write(json.dumps(self.encoder   ,						indent=2   ,						sort_keys=UpperCamelCase   ,						ensure_ascii=UpperCamelCase ) + '''\n''' )

             lowercase__      			= 0
             with open(UpperCamelCase   ,						'''w'''   ,						encoding='''utf-8''' ) as writer:
                    writer.write('''#version: 0.2\n''' )
                    for bpe_tokens, token_index in sorted(self.bpe_ranks.items()   ,						key=lambda UpperCamelCase : kv[1] ):
                           if index != token_index:
                                  logger.warning(
                                      f"Saving vocabulary to {merge_file}: BPE merge indices are not consecutive."
                                      ''' Please check that the tokenizer is not corrupted!''' )
                                  lowercase__      			= token_index
                           writer.write(''' '''.join(UpperCamelCase ) + '''\n''' )
                           index += 1

             return vocab_file, merge_file



      def       UpperCamelCase__		(self    :    Optional[Any]   ,						UpperCamelCase    :    List[int]   ,						UpperCamelCase    :    Optional[List[int]] = None   ,						UpperCamelCase    :    bool = False ):

             '''simple docstring'''







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

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



      def       UpperCamelCase__		(self    :    Optional[Any]   ,						UpperCamelCase    :    List[int]   ,						UpperCamelCase    :    Optional[List[int]] = None ):

             '''simple docstring'''







             lowercase__      			= [self.sep_token_id]
             lowercase__      			= [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]



      def       UpperCamelCase__		(self    :    List[Any]   ,						UpperCamelCase    :    Optional[int]   ,						UpperCamelCase    :    int=False   ,						**UpperCamelCase    :    Any ):

             '''simple docstring'''







             lowercase__      			= kwargs.pop('''add_prefix_space'''   ,						self.add_prefix_space )
             if (is_split_into_words or add_prefix_space) and (len(UpperCamelCase ) > 0 and not text[0].isspace()):
                    lowercase__      			= ''' ''' + text
             return (text, kwargs)



      def       UpperCamelCase__		(self    :    str   ,						UpperCamelCase    :    List[int]   ,						UpperCamelCase    :    Optional[List[int]] = None ):

             '''simple docstring'''







             return token_ids_a + [self.eos_token_id]






      def       UpperCamelCase__		(self    :    Dict   ,						UpperCamelCase    :    "Conversation" ):

             '''simple docstring'''







             lowercase__      			= []
             for is_user, text in conversation.iter_texts():
                    if is_user:
                           # We need to space prefix as it's being done within blenderbot
                           inputs.append(''' ''' + text )
                    else:
                           # Generated responses should contain them already.
                           inputs.append(UpperCamelCase )

             lowercase__      			= '''  '''.join(UpperCamelCase )
             lowercase__      			= self.encode(UpperCamelCase )
             if len(UpperCamelCase ) > self.model_max_length:
                    lowercase__      			= input_ids[-self.model_max_length :]
                    logger.warning(f"Trimmed input from conversation as it was longer than {self.model_max_length} tokens." )
             return input_ids








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


lowerCamelCase							:   str  						=	Mapping[str, np.ndarray]
lowerCamelCase							:   List[Any]  						=	Mapping[str, Any]  # Is a nested dict.
lowerCamelCase							:   Any  						=	0.0_1
@dataclasses.dataclass(frozen=lowercase_     )
class   __lowerCAmelCase						:





      '''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 _SCREAMING_SNAKE_CASE      (A       )       ->       Protein:






       """simple docstring"""







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

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






       """simple docstring"""







       lowercase__      			= []

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

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

       if parents is None or len(A       ) == 0:
              lowercase__      			= ['''N/A''']

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

       return pdb_headers

def _SCREAMING_SNAKE_CASE      (A  , A       )       ->       str:






       """simple docstring"""







       lowercase__      			= []
       lowercase__      			= pdb_str.split('''\n'''       )

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

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

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

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

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

       lowercase__      			= 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__      			= parents_per_chain[chain_counter]
                     else:
                            lowercase__      			= ['''N/A''']

                     out_pdb_lines.append(make_parent_line(A       )       )

       return "\n".join(A       )

def _SCREAMING_SNAKE_CASE      (A       )       ->       str:






       """simple docstring"""







       lowercase__      			= residue_constants.restypes + ['''X''']

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

       lowercase__      			= residue_constants.atom_types

       lowercase__      			= []

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

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

       lowercase__      			= get_pdb_headers(A       )
       if len(A       ) > 0:
              pdb_lines.extend(A       )

       lowercase__      			= aatype.shape[0]
       lowercase__      			= 1
       lowercase__      			= 0
       lowercase__      			= string.ascii_uppercase
       lowercase__      			= None
       # Add all atom sites.
       for i in range(A       ):
              lowercase__      			= 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__      			= '''ATOM'''
                     lowercase__      			= atom_name if len(A       ) == 4 else f" {atom_name}"
                     lowercase__      			= ''''''
                     lowercase__      			= ''''''
                     lowercase__      			= 1.00
                     lowercase__      			= atom_name[0]  # Protein supports only C, N, O, S, this works.
                     lowercase__      			= ''''''

                     lowercase__      			= '''A'''
                     if chain_index is not None:
                            lowercase__      			= chain_tags[chain_index[i]]

                     # PDB is a columnar format, every space matters here!
                     lowercase__      			= (
                         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__      			= i == n - 1
              if chain_index is not None:
                     if i != n - 1 and chain_index[i + 1] != prev_chain_index:
                            lowercase__      			= True
                            lowercase__      			= chain_index[i + 1]

              if should_terminate:
                     # Close the chain.
                     lowercase__      			= '''TER'''
                     lowercase__      			= (
                         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 _SCREAMING_SNAKE_CASE      (A       )       ->       np.ndarray:






       """simple docstring"""







       return residue_constants.STANDARD_ATOM_MASK[prot.aatype]

def _SCREAMING_SNAKE_CASE      (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  , )




