



import json
from typing import List, Optional, Tuple

from tokenizers import normalizers

from ...tokenization_utils_fast import PreTrainedTokenizerFast
from ...utils import logging
from .tokenization_convbert import ConvBertTokenizer


__snake_case       :	Optional[Any]            =logging.get_logger(__name__)

__snake_case       :	List[Any]            ={'vocab_file': 'vocab.txt'}

__snake_case       :	List[str]            ={
    'vocab_file': {
        'YituTech/conv-bert-base': 'https://huggingface.co/YituTech/conv-bert-base/resolve/main/vocab.txt',
        'YituTech/conv-bert-medium-small': (
            'https://huggingface.co/YituTech/conv-bert-medium-small/resolve/main/vocab.txt'
        ),
        'YituTech/conv-bert-small': 'https://huggingface.co/YituTech/conv-bert-small/resolve/main/vocab.txt',
    }
}

__snake_case       :	Any            ={
    'YituTech/conv-bert-base': 5_1_2,
    'YituTech/conv-bert-medium-small': 5_1_2,
    'YituTech/conv-bert-small': 5_1_2,
}


__snake_case       :	Tuple            ={
    'YituTech/conv-bert-base': {'do_lower_case': True},
    'YituTech/conv-bert-medium-small': {'do_lower_case': True},
    'YituTech/conv-bert-small': {'do_lower_case': True},
}



class  lowerCamelCase__    (							lowerCamelCase__):




		'''simple docstring'''



		snake_case_			=VOCAB_FILES_NAMES
		snake_case_			=PRETRAINED_VOCAB_FILES_MAP
		snake_case_			=PRETRAINED_INIT_CONFIGURATION
		snake_case_			=PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
		snake_case_			=ConvBertTokenizer



		def __init__(self	,__lowerCamelCase=None	,__lowerCamelCase=None	,__lowerCamelCase=True	,__lowerCamelCase="[UNK]"	,__lowerCamelCase="[SEP]"	,__lowerCamelCase="[PAD]"	,__lowerCamelCase="[CLS]"	,__lowerCamelCase="[MASK]"	,__lowerCamelCase=True	,__lowerCamelCase=None	,**__lowerCamelCase	,)  ->    Any:

						"""simple docstring"""






						super().__init__(
						    __lowerCamelCase	,tokenizer_file=__lowerCamelCase	,do_lower_case=__lowerCamelCase	,unk_token=__lowerCamelCase	,sep_token=__lowerCamelCase	,pad_token=__lowerCamelCase	,cls_token=__lowerCamelCase	,mask_token=__lowerCamelCase	,tokenize_chinese_chars=__lowerCamelCase	,strip_accents=__lowerCamelCase	,**__lowerCamelCase	,)

						lowerCAmelCase__  :       List[Any]				=  json.loads(self.backend_tokenizer.normalizer.__getstate__()				)
						if (
						    normalizer_state.get('''lowercase'''	,__lowerCamelCase				) != do_lower_case
						    or normalizer_state.get('''strip_accents'''	,__lowerCamelCase				) != strip_accents
						    or normalizer_state.get('''handle_chinese_chars'''	,__lowerCamelCase				) != tokenize_chinese_chars
						):
										lowerCAmelCase__  :       str				=  getattr(__lowerCamelCase	,normalizer_state.pop('''type'''				)				)
										lowerCAmelCase__  :       Optional[Any]				=  do_lower_case
										lowerCAmelCase__  :       str				=  strip_accents
										lowerCAmelCase__  :       str				=  tokenize_chinese_chars
										lowerCAmelCase__  :       str				=  normalizer_class(**__lowerCamelCase				)

						lowerCAmelCase__  :       str				=  do_lower_case



		def 	lowerCAmelCase__   (self	,__lowerCamelCase	,__lowerCamelCase=None				)  ->    Any:

						"""simple docstring"""






						lowerCAmelCase__  :       List[str]				=  [self.cls_token_id] + token_ids_a + [self.sep_token_id]

						if token_ids_a:
										output += token_ids_a + [self.sep_token_id]

						return output



		def 	lowerCAmelCase__   (self	,__lowerCamelCase	,__lowerCamelCase = None				)  ->    List[int]:

						"""simple docstring"""






						lowerCAmelCase__  :       Union[str, Any]				=  [self.sep_token_id]
						lowerCAmelCase__  :       Tuple				=  [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				) * [0] + len(token_ids_a + sep				) * [1]



		def 	lowerCAmelCase__   (self	,__lowerCamelCase	,__lowerCamelCase = None				)  ->    Tuple[str]:

						"""simple docstring"""






						lowerCAmelCase__  :       Dict				=  self._tokenizer.model.save(__lowerCamelCase	,name=__lowerCamelCase				)
						return tuple(__lowerCamelCase				)






from typing import Dict

import numpy as np
import torch

from . import residue_constants as rc
from .tensor_utils import tensor_tree_map, tree_map






def 			lowerCAmelCase__	(					lowerCamelCase_	:	Dict[str, torch.Tensor]):





				'''simple docstring'''

				lowerCAmelCase__  :       List[Any]				=  []
				lowerCAmelCase__  :       int				=  []
				lowerCAmelCase__  :       Optional[int]				=  []

				for rt in rc.restypes:
								lowerCAmelCase__  :       int				=  rc.restype_name_to_atomaa_names[rc.restype_atoa[rt]]
								restype_atomaa_to_atomaa_list.append([(rc.atom_order[name] if name else 0) for name in atom_names])
								lowerCAmelCase__  :       Any				=  {name: i for i, name in enumerate(lowerCamelCase_)}
								restype_atomaa_to_atomaa_list.append(
								    [(atom_name_to_idxaa[name] if name in atom_name_to_idxaa else 0) for name in rc.atom_types])

								restype_atomaa_mask_list.append([(1.0 if name else 0.0) for name in atom_names])

				# Add dummy mapping for restype 'UNK'
				restype_atomaa_to_atomaa_list.append([0] * 14)
				restype_atomaa_to_atomaa_list.append([0] * 37)
				restype_atomaa_mask_list.append([0.0] * 14)

				lowerCAmelCase__  :       Optional[Any]				=  torch.tensor(
				    lowerCamelCase_ ,dtype=torch.intaa ,device=protein['''aatype'''].device ,)
				lowerCAmelCase__  :       Optional[int]				=  torch.tensor(
				    lowerCamelCase_ ,dtype=torch.intaa ,device=protein['''aatype'''].device ,)
				lowerCAmelCase__  :       List[str]				=  torch.tensor(
				    lowerCamelCase_ ,dtype=torch.floataa ,device=protein['''aatype'''].device ,)
				lowerCAmelCase__  :       Optional[Any]				=  protein['''aatype'''].to(torch.long)

				# create the mapping for (residx, atom14) --> atom37, i.e. an array
				# with shape (num_res, 14) containing the atom37 indices for this protein
				lowerCAmelCase__  :       Optional[int]				=  restype_atomaa_to_atomaa[protein_aatype]
				lowerCAmelCase__  :       List[str]				=  restype_atomaa_mask[protein_aatype]

				lowerCAmelCase__  :       Tuple				=  residx_atomaa_mask
				lowerCAmelCase__  :       Dict				=  residx_atomaa_to_atomaa.long()

				# create the gather indices for mapping back
				lowerCAmelCase__  :       Union[str, Any]				=  restype_atomaa_to_atomaa[protein_aatype]
				lowerCAmelCase__  :       int				=  residx_atomaa_to_atomaa.long()

				# create the corresponding mask
				lowerCAmelCase__  :       List[str]				=  torch.zeros([21, 37] ,dtype=torch.floataa ,device=protein['''aatype'''].device)
				for restype, restype_letter in enumerate(rc.restypes):
								lowerCAmelCase__  :       List[str]				=  rc.restype_atoa[restype_letter]
								lowerCAmelCase__  :       List[str]				=  rc.residue_atoms[restype_name]
								for atom_name in atom_names:
												lowerCAmelCase__  :       List[Any]				=  rc.atom_order[atom_name]
												lowerCAmelCase__  :       Any				=  1

				lowerCAmelCase__  :       int				=  restype_atomaa_mask[protein_aatype]
				lowerCAmelCase__  :       int				=  residx_atomaa_mask

				return protein






def 			lowerCAmelCase__	(					lowerCamelCase_	:	Dict[str, torch.Tensor]):





				'''simple docstring'''

				lowerCAmelCase__  :       Optional[Any]				=  tree_map(lambda lowerCamelCase_: torch.tensor(lowerCamelCase_ ,device=batch['''aatype'''].device) ,lowerCamelCase_ ,np.ndarray)
				lowerCAmelCase__  :       Union[str, Any]				=  tensor_tree_map(lambda lowerCamelCase_: np.array(lowerCamelCase_) ,make_atomaa_masks(lowerCamelCase_))
				return out

