






'''simple docstring'''







import json
import os
import shutil
import tempfile
import unittest

from transformers.models.wavaveca import WavaVecaCTCTokenizer, WavaVecaFeatureExtractor, WavaVecaProcessor
from transformers.models.wavaveca.tokenization_wavaveca import VOCAB_FILES_NAMES
from transformers.utils import FEATURE_EXTRACTOR_NAME

from .test_feature_extraction_wavaveca import floats_list




class      __SCREAMING_SNAKE_CASE					(unittest.TestCase					):


  """simple docstring"""


  def       _a					( self  ):






         """simple docstring"""


         a_	    = '<pad> <s> </s> <unk> | E T A O N I H S R D L U M W C F G Y P B V K \' X J Q Z'.split(' '  )
         a_	    = dict(zip(UpperCamelCase__      ,  range(len(UpperCamelCase__  )  )  )  )

         a_	    = {
             'pad_token': '<pad>',
             'unk_token': '<unk>',
             'bos_token': '<s>',
             'eos_token': '</s>',
         }
         a_	    = {
             'feature_size': 1,
             'padding_value': 0.0,
             'sampling_rate': 16_000,
             'return_attention_mask': False,
             'do_normalize': True,
         }

         a_	    = tempfile.mkdtemp()
         a_	    = os.path.join(self.tmpdirname      ,  VOCAB_FILES_NAMES['vocab_file']  )
         a_	    = os.path.join(self.tmpdirname      ,  UpperCamelCase__  )
         with open(self.vocab_file      ,  'w'      ,  encoding='utf-8'  ) as fp:
                fp.write(json.dumps(UpperCamelCase__  ) + '\n'  )

         with open(self.feature_extraction_file      ,  'w'      ,  encoding='utf-8'  ) as fp:
                fp.write(json.dumps(UpperCamelCase__  ) + '\n'  )







  def       _a					( self      ,  **UpperCamelCase__  ):






         """simple docstring"""


         a_	    = self.add_kwargs_tokens_map.copy()
         kwargs.update(UpperCamelCase__  )
         return WavaVecaCTCTokenizer.from_pretrained(self.tmpdirname      ,  **UpperCamelCase__  )







  def       _a					( self      ,  **UpperCamelCase__  ):






         """simple docstring"""


         return WavaVecaFeatureExtractor.from_pretrained(self.tmpdirname      ,  **UpperCamelCase__  )







  def       _a					( self  ):






         """simple docstring"""


         shutil.rmtree(self.tmpdirname  )







  def       _a					( self  ):






         """simple docstring"""


         a_	    = self.get_tokenizer()
         a_	    = self.get_feature_extractor()

         a_	    = WavaVecaProcessor(tokenizer=UpperCamelCase__      ,  feature_extractor=UpperCamelCase__  )

         processor.save_pretrained(self.tmpdirname  )
         a_	    = WavaVecaProcessor.from_pretrained(self.tmpdirname  )

         self.assertEqual(processor.tokenizer.get_vocab()      ,  tokenizer.get_vocab()  )
         self.assertIsInstance(processor.tokenizer      ,  UpperCamelCase__  )

         self.assertEqual(processor.feature_extractor.to_json_string()      ,  feature_extractor.to_json_string()  )
         self.assertIsInstance(processor.feature_extractor      ,  UpperCamelCase__  )







  def       _a					( self  ):






         """simple docstring"""


         a_	    = WavaVecaProcessor(tokenizer=self.get_tokenizer()      ,  feature_extractor=self.get_feature_extractor()  )
         processor.save_pretrained(self.tmpdirname  )

         a_	    = self.get_tokenizer(bos_token='(BOS)'      ,  eos_token='(EOS)'  )
         a_	    = self.get_feature_extractor(do_normalize=UpperCamelCase__      ,  padding_value=1.0  )

         a_	    = WavaVecaProcessor.from_pretrained(
             self.tmpdirname      ,  bos_token='(BOS)'      ,  eos_token='(EOS)'      ,  do_normalize=UpperCamelCase__      ,  padding_value=1.0  )

         self.assertEqual(processor.tokenizer.get_vocab()      ,  tokenizer_add_kwargs.get_vocab()  )
         self.assertIsInstance(processor.tokenizer      ,  UpperCamelCase__  )

         self.assertEqual(processor.feature_extractor.to_json_string()      ,  feature_extractor_add_kwargs.to_json_string()  )
         self.assertIsInstance(processor.feature_extractor      ,  UpperCamelCase__  )







  def       _a					( self  ):






         """simple docstring"""


         a_	    = self.get_feature_extractor()
         a_	    = self.get_tokenizer()

         a_	    = WavaVecaProcessor(tokenizer=UpperCamelCase__      ,  feature_extractor=UpperCamelCase__  )

         a_	    = floats_list((3, 1_000)  )

         a_	    = feature_extractor(UpperCamelCase__      ,  return_tensors='np'  )
         a_	    = processor(UpperCamelCase__      ,  return_tensors='np'  )

         for key in input_feat_extract.keys():
                self.assertAlmostEqual(input_feat_extract[key].sum()      ,  input_processor[key].sum()      ,  delta=1e-2  )







  def       _a					( self  ):






         """simple docstring"""


         a_	    = self.get_feature_extractor()
         a_	    = self.get_tokenizer()

         a_	    = WavaVecaProcessor(tokenizer=UpperCamelCase__      ,  feature_extractor=UpperCamelCase__  )

         a_	    = 'This is a test string'

         a_	    = processor(text=UpperCamelCase__  )

         a_	    = tokenizer(UpperCamelCase__  )

         for key in encoded_tok.keys():
                self.assertListEqual(encoded_tok[key]      ,  encoded_processor[key]  )







  def       _a					( self  ):






         """simple docstring"""


         a_	    = self.get_feature_extractor()
         a_	    = self.get_tokenizer()

         a_	    = WavaVecaProcessor(tokenizer=UpperCamelCase__      ,  feature_extractor=UpperCamelCase__  )

         a_	    = [[1, 4, 5, 8, 1, 0, 8], [3, 4, 3, 1, 1, 8, 9]]

         a_	    = processor.batch_decode(UpperCamelCase__  )
         a_	    = tokenizer.batch_decode(UpperCamelCase__  )

         self.assertListEqual(UpperCamelCase__      ,  UpperCamelCase__  )







  def       _a					( self  ):






         """simple docstring"""


         a_	    = self.get_feature_extractor()
         a_	    = self.get_tokenizer()

         a_	    = WavaVecaProcessor(tokenizer=UpperCamelCase__      ,  feature_extractor=UpperCamelCase__  )

         self.assertListEqual(
             processor.model_input_names      ,  feature_extractor.model_input_names      ,  msg='`processor` and `feature_extractor` model input names do not match'      ,  )












'''simple docstring'''







from typing import Dict, Tuple, overload

import torch
import torch.types
from torch import nn

from . import residue_constants as rc
from .rigid_utils import Rigid, Rotation
from .tensor_utils import batched_gather


@overload
def 			__UpperCamelCase				(			lowercase_					:     torch.Tensor      ,					lowercase_					:     torch.Tensor      ,					lowercase_					:     None      ):
       """simple docstring"""




       ...


@overload
def 			__UpperCamelCase				(			lowercase_					:     torch.Tensor      ,					lowercase_					:     torch.Tensor      ,					lowercase_					:     torch.Tensor      ):
       """simple docstring"""




       ...


def 			__UpperCamelCase				(			lowercase_					:     Tuple      ,					lowercase_					:     Tuple      ,					lowercase_					:     List[Any]      ):
       """simple docstring"""




       a_	    = aatype == rc.restype_order['G']
       a_	    = rc.atom_order['CA']
       a_	    = rc.atom_order['CB']
       a_	    = torch.where(
           is_gly[..., None].expand(*((-1,) * len(is_gly.shape      ))      ,					3      )      ,					all_atom_positions[..., ca_idx, :]      ,					all_atom_positions[..., cb_idx, :]      ,					)

       if all_atom_masks is not None:
              a_	    = torch.where(
                  lowercase_      ,					all_atom_masks[..., ca_idx]      ,					all_atom_masks[..., cb_idx]      ,					)
              return pseudo_beta, pseudo_beta_mask
       else:
              return pseudo_beta


def 			__UpperCamelCase				(			lowercase_					:     torch.Tensor      ,					lowercase_					:     Dict[str, torch.Tensor]      ):
       """simple docstring"""




       a_	    = batched_gather(
           lowercase_      ,					batch['residx_atom37_to_atom14']      ,					dim=-2      ,					no_batch_dims=len(atomaa.shape[:-2]      )      ,					)

       a_	    = atomaa_data * batch['atom37_atom_exists'][..., None]

       return atomaa_data


def 			__UpperCamelCase				(			lowercase_					:     Dict[str, torch.Tensor]      ):
       """simple docstring"""




       a_	    = template_feats['template_aatype']
       a_	    = template_feats['template_torsion_angles_sin_cos']
       a_	    = template_feats['template_alt_torsion_angles_sin_cos']
       a_	    = template_feats['template_torsion_angles_mask']
       a_	    = torch.cat(
           [
               nn.functional.one_hot(lowercase_      ,					22      ),
               torsion_angles_sin_cos.reshape(*torsion_angles_sin_cos.shape[:-2]      ,					14      ),
               alt_torsion_angles_sin_cos.reshape(*alt_torsion_angles_sin_cos.shape[:-2]      ,					14      ),
               torsion_angles_mask,
           ]      ,					dim=-1      ,					)

       return template_angle_feat


def 			__UpperCamelCase				(			lowercase_					:     Dict[str, torch.Tensor]      ,					lowercase_					:     torch.types.Number      ,					lowercase_					:     torch.types.Number      ,					lowercase_					:     int      ,					lowercase_					:     bool = False      ,					lowercase_					:     float = 1E-20      ,					lowercase_					:     float = 1E8      ,					):
       """simple docstring"""




       a_	    = batch['template_pseudo_beta_mask']
       a_	    = template_mask[..., None] * template_mask[..., None, :]

       # Compute distogram (this seems to differ slightly from Alg. 5)
       a_	    = batch['template_pseudo_beta']
       a_	    = torch.sum((tpb[..., None, :] - tpb[..., None, :, :]) ** 2      ,					dim=-1      ,					keepdim=lowercase_      )
       a_	    = torch.linspace(lowercase_      ,					lowercase_      ,					lowercase_      ,					device=tpb.device      ) ** 2
       a_	    = torch.cat([lower[1:], lower.new_tensor([inf]      )]      ,					dim=-1      )
       a_	    = ((dgram > lower) * (dgram < upper)).type(dgram.dtype      )

       a_	    = [dgram, template_mask_ad[..., None]]

       a_	    = nn.functional.one_hot(
           batch['template_aatype']      ,					rc.restype_num + 2      ,					)

       a_	    = batch['template_aatype'].shape[-1]
       to_concat.append(aatype_one_hot[..., None, :, :].expand(*aatype_one_hot.shape[:-2]      ,					lowercase_      ,					-1      ,					-1      )      )
       to_concat.append(aatype_one_hot[..., None, :].expand(*aatype_one_hot.shape[:-2]      ,					-1      ,					lowercase_      ,					-1      )      )

       a_    ,  a_    ,  a_	    = [rc.atom_order[a] for a in ['N', 'CA', 'C']]
       a_	    = Rigid.make_transform_from_reference(
           n_xyz=batch['template_all_atom_positions'][..., n, :]      ,					ca_xyz=batch['template_all_atom_positions'][..., ca, :]      ,					c_xyz=batch['template_all_atom_positions'][..., c, :]      ,					eps=lowercase_      ,					)
       a_	    = rigids.get_trans()[..., None, :, :]
       a_	    = rigids[..., None].invert_apply(lowercase_      )

       a_	    = torch.rsqrt(eps + torch.sum(rigid_vec**2      ,					dim=-1      )      )

       a_	    = batch['template_all_atom_mask']
       a_	    = t_aa_masks[..., n] * t_aa_masks[..., ca] * t_aa_masks[..., c]
       a_	    = template_mask[..., None] * template_mask[..., None, :]

       a_	    = inv_distance_scalar * template_mask_ad
       a_	    = rigid_vec * inv_distance_scalar[..., None]

       if not use_unit_vector:
              a_	    = unit_vector * 0.0

       to_concat.extend(torch.unbind(unit_vector[..., None, :]      ,					dim=-1      )      )
       to_concat.append(template_mask_ad[..., None]      )

       a_	    = torch.cat(lowercase_      ,					dim=-1      )
       a_	    = act * template_mask_ad[..., None]

       return act


def 			__UpperCamelCase				(			lowercase_					:     Dict[str, torch.Tensor]      ):
       """simple docstring"""




       a_	    = nn.functional.one_hot(batch['extra_msa']      ,					23      )
       a_	    = [
           msa_ahot,
           batch['extra_has_deletion'].unsqueeze(-1      ),
           batch['extra_deletion_value'].unsqueeze(-1      ),
       ]
       return torch.cat(lowercase_      ,					dim=-1      )


def 			__UpperCamelCase				(			lowercase_					:     Rigid      ,					lowercase_					:     torch.Tensor      ,					lowercase_					:     torch.Tensor      ,					lowercase_					:     torch.Tensor      ,					):
       """simple docstring"""




       a_	    = rrgdf[aatype, ...]

       # [*, N, 8] transformations, i.e.
       #   One [*, N, 8, 3, 3] rotation matrix and
       #   One [*, N, 8, 3]    translation matrix
       a_	    = r.from_tensor_axa(lowercase_      )

       a_	    = alpha.new_zeros((*((1,) * len(alpha.shape[:-1]      )), 2)      )
       a_	    = 1

       # [*, N, 8, 2]
       a_	    = torch.cat([bb_rot.expand(*alpha.shape[:-2]      ,					-1      ,					-1      ), alpha]      ,					dim=-2      )

       # [*, N, 8, 3, 3]
       # Produces rotation matrices of the form:
       # [
       #   [1, 0  , 0  ],
       #   [0, a_2,-a_1],
       #   [0, a_1, a_2]
       # ]
       # This follows the original code rather than the supplement, which uses
       # different indices.

       a_	    = alpha.new_zeros(default_r.get_rots().get_rot_mats().shape      )
       a_	    = 1
       a_	    = alpha[..., 1]
       a_	    = -alpha[..., 0]
       a_	    = alpha

       a_	    = default_r.compose(Rigid(Rotation(rot_mats=lowercase_      )      ,					lowercase_      )      )

       a_	    = all_frames[..., 5]
       a_	    = all_frames[..., 6]
       a_	    = all_frames[..., 7]

       a_	    = all_frames[..., 4]
       a_	    = chia_frame_to_bb.compose(lowercase_      )
       a_	    = chia_frame_to_bb.compose(lowercase_      )
       a_	    = chia_frame_to_bb.compose(lowercase_      )

       a_	    = Rigid.cat(
           [
               all_frames[..., :5],
               chia_frame_to_bb.unsqueeze(-1      ),
               chia_frame_to_bb.unsqueeze(-1      ),
               chia_frame_to_bb.unsqueeze(-1      ),
           ]      ,					dim=-1      ,					)

       a_	    = r[..., None].compose(lowercase_      )

       return all_frames_to_global


def 			__UpperCamelCase				(			lowercase_					:     Rigid      ,					lowercase_					:     torch.Tensor      ,					lowercase_					:     torch.Tensor      ,					lowercase_					:     torch.Tensor      ,					lowercase_					:     torch.Tensor      ,					lowercase_					:     torch.Tensor      ,					):
       """simple docstring"""




       a_	    = group_idx[aatype, ...]

       # [*, N, 14, 8]
       a_	    = nn.functional.one_hot(
           lowercase_      ,					num_classes=default_frames.shape[-3]      ,					)

       # [*, N, 14, 8]
       a_	    = r[..., None, :] * group_mask_one_hot

       # [*, N, 14]
       a_	    = t_atoms_to_global.map_tensor_fn(lambda lowercase_      : torch.sum(lowercase_      ,					dim=-1      )      )

       # [*, N, 14, 1]
       a_	    = atom_mask[aatype, ...].unsqueeze(-1      )

       # [*, N, 14, 3]
       a_	    = lit_positions[aatype, ...]
       a_	    = t_atoms_to_global.apply(lowercase_      )
       a_	    = pred_positions * atom_mask

       return pred_positions




