


"""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_       :       Any      						=  Mapping[str, np.ndarray]
lowerCamelCase_       :       Tuple      						=  Mapping[str, Any]  # Is a nested dict.
lowerCamelCase_       :       List[Any]      						=  0.01






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






 """simple docstring"""




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

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

 # Chain indices for multi-chain predictions
 __lowerCAmelCase			 =  None

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

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

 # Chain corresponding to each parent
 __lowerCAmelCase			 =  None

def _A						(						lowercase		):







    """simple docstring"""
    a					=R'''(\[[A-Z]+\]\n)'''
    a					=[tag.strip() for tag in re.split(lowercase	,   lowercase		) if len(lowercase		) > 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(lowercase		)		):
                if seq[i] not in residue_constants.restypes:
                    a					='''X'''  # FIXME: strings are immutable
            a					=np.array(
                [residue_constants.restype_order.get(lowercase	,   residue_constants.restype_num		) for res_symbol in seq]		)
        elif "[TERTIARY]" == g[0]:
            a					=[]
            for axis in range(3		):
                tertiary.append(list(map(lowercase	,   g[1][axis].split()		)		)		)
            a					=np.array(lowercase		)
            a					=np.zeros((len(tertiary[0]		) // 3, residue_constants.atom_type_num, 3)		).astype(np.floataa		)
            for i, atom in enumerate(lowercase		):
                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(lowercase		),
                    residue_constants.atom_type_num,
                )		).astype(np.floataa		)
            for i, atom in enumerate(lowercase		):
                a					=1
            atom_mask *= mask[..., None]

    assert aatype is not None

    return Protein(
        atom_positions=lowercase	,   atom_mask=lowercase	,   aatype=lowercase	,   residue_index=np.arange(len(lowercase		)		)	,   b_factors=lowercase	,   )
def _A						(						lowercase	,   lowercase = 0		):







    """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(lowercase	,   lowercase		) if i == chain_id]

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

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

    return pdb_headers
def _A						(						lowercase	,   lowercase		):







    """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(lowercase		)	,   []		)
                parent_dict[str(lowercase		)].append(lowercase		)

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

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

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

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

            out_pdb_lines.append(make_parent_line(lowercase		)		)

    return "\n".join(lowercase		)
def _A						(						lowercase		):







    """simple docstring"""
    a					=residue_constants.restypes + ['''X''']

    def res_atoa(lowercase		) -> 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(lowercase		)
    if len(lowercase		) > 0:
        pdb_lines.extend(lowercase		)

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

            a					='''ATOM'''
            a					=atom_name if len(lowercase		) == 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(lowercase		)
            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(lowercase		)
            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(lowercase	,   lowercase		)		)

    pdb_lines.append('''END'''		)
    pdb_lines.append(''''''		)
    return "\n".join(lowercase		)
def _A						(						lowercase		):







    """simple docstring"""
    return residue_constants.STANDARD_ATOM_MASK[prot.aatype]





def _A						(						lowercase	,   lowercase	,   lowercase = None	,   lowercase = None	,   lowercase = None	,   lowercase = None	,   lowercase = None	,   ):







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



"""simple docstring"""







import unittest
from pathlib import Path
from tempfile import TemporaryDirectory

from transformers import AutoConfig, TFAutoModel, is_tensorflow_text_available, is_tf_available
from transformers.models.bert.tokenization_bert import BertTokenizer
from transformers.testing_utils import require_tensorflow_text, require_tf, slow


if is_tf_available():
       import tensorflow as tf

if is_tensorflow_text_available():
       from transformers.models.bert import TFBertTokenizer


lowerCamelCase_       :       str      						=  ["""bert-base-uncased""", """bert-base-cased"""]
lowerCamelCase_       :       List[str]      						=  """hf-internal-testing/tiny-bert-tf-only"""

if is_tf_available():






       class 				__A    (	tf.keras.Model      ):






        """simple docstring"""




        def __init__(		self			,   __A						) ->					Dict:
            super().__init__()
            a					=tokenizer
            a					=AutoConfig.from_pretrained(__A						)
            a					=TFAutoModel.from_config(__A						)





        def 				SCREAMING_SNAKE_CASE							(		self			,   __A						) ->					int:
            a					=self.tokenizer(__A						)
            a					=self.bert(**__A						)
            return out["pooler_output"]






@require_tf
@require_tensorflow_text
class 				__A    (	unittest.TestCase      ):






 """simple docstring"""




 def 				SCREAMING_SNAKE_CASE							(		self						) ->					str:
     super().setUp()

     a					=[
         BertTokenizer.from_pretrained(__A						) for checkpoint in (TOKENIZER_CHECKPOINTS * 2)
     ]  # repeat for when fast_bert_tokenizer=false
     a					=[TFBertTokenizer.from_pretrained(__A						) for checkpoint in TOKENIZER_CHECKPOINTS] + [
         TFBertTokenizer.from_pretrained(__A			,   use_fast_bert_tokenizer=__A						)
         for checkpoint in TOKENIZER_CHECKPOINTS
     ]
     assert len(self.tokenizers						) == len(self.tf_tokenizers						)

     a					=[
         '''This is a straightforward English test sentence.''',
         '''This one has some weird characters\rto\nsee\r\nif  those\u00E9break things.''',
         '''Now we\'re going to add some Chinese: 一 二 三 一二三''',
         '''And some much more rare Chinese: 齉 堃 齉堃''',
         '''Je vais aussi écrire en français pour tester les accents''',
         '''Classical Irish also has some unusual characters, so in they go: Gaelaċ, ꝼ''',
     ]
     a					=list(zip(self.test_sentences			,   self.test_sentences[::-1]						)						)


 def 				SCREAMING_SNAKE_CASE							(		self						) ->					Optional[int]:
     for tokenizer, tf_tokenizer in zip(self.tokenizers			,   self.tf_tokenizers						):
         for test_inputs in (self.test_sentences, self.paired_sentences):
             a					=tokenizer(__A			,   return_tensors='''tf'''			,   padding='''longest'''						)
             a					=tf_tokenizer(__A						)

             for key in python_outputs.keys():
                 self.assertTrue(tf.reduce_all(python_outputs[key].shape == tf_outputs[key].shape						)						)
                 self.assertTrue(tf.reduce_all(tf.cast(python_outputs[key]			,   tf.intaa						) == tf_outputs[key]						)						)


 @slow
 def 				SCREAMING_SNAKE_CASE							(		self						) ->					str:
     for tf_tokenizer in self.tf_tokenizers:
         a					=tf_tokenizer(self.paired_sentences						)
         a					=tf_tokenizer(
             text=[sentence[0] for sentence in self.paired_sentences]			,   text_pair=[sentence[1] for sentence in self.paired_sentences]			,   )
         for key in merged_outputs.keys():
             self.assertTrue(tf.reduce_all(tf.cast(merged_outputs[key]			,   tf.intaa						) == separated_outputs[key]						)						)


 @slow
 def 				SCREAMING_SNAKE_CASE							(		self						) ->					List[str]:
     for tf_tokenizer in self.tf_tokenizers:
         a					=tf.function(__A						)
         for test_inputs in (self.test_sentences, self.paired_sentences):
             a					=tf.constant(__A						)
             a					=compiled_tokenizer(__A						)
             a					=tf_tokenizer(__A						)

             for key in eager_outputs.keys():
                 self.assertTrue(tf.reduce_all(eager_outputs[key] == compiled_outputs[key]						)						)





 @slow
 def 				SCREAMING_SNAKE_CASE							(		self						) ->					Tuple:
     for tf_tokenizer in self.tf_tokenizers:
         a					=ModelToSave(tokenizer=__A						)
         a					=tf.convert_to_tensor(self.test_sentences						)
         a					=model(__A						)  # Build model with some sample inputs
         with TemporaryDirectory() as tempdir:
             a					=Path(__A						) / '''saved.model'''
             model.save(__A						)
             a					=tf.keras.models.load_model(__A						)
         a					=loaded_model(__A						)
         # We may see small differences because the loaded model is compiled, so we need an epsilon for the test
         self.assertLessEqual(tf.reduce_max(tf.abs(out - loaded_output						)						)			,   1E-5						)