


"""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 			A__		(					_UpperCAmelCase    :      torch.Tensor				,    _UpperCAmelCase    :      torch.Tensor				,    _UpperCAmelCase    :      None	)							->	torch.Tensor:

	'''simple docstring'''


	...



@overload
def 			A__		(					_UpperCAmelCase    :      torch.Tensor				,    _UpperCAmelCase    :      torch.Tensor				,    _UpperCAmelCase    :      torch.Tensor	)							->	Tuple[torch.Tensor, torch.Tensor]:

	'''simple docstring'''


	...



def 			A__		(					_UpperCAmelCase    :      int				,    _UpperCAmelCase    :      List[str]				,    _UpperCAmelCase    :      Optional[int]	)							->	List[str]:

	'''simple docstring'''


	snake_case__  :						Optional[Any]		=      aatype == rc.restype_order["G"]
	snake_case__  :						Union[str, Any]		=      rc.atom_order["CA"]
	snake_case__  :						Dict		=      rc.atom_order["CB"]
	snake_case__  :						Union[str, Any]		=      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:
		snake_case__  :						Optional[Any]		=      torch.where(
		    _UpperCAmelCase				,    all_atom_masks[..., ca_idx]				,    all_atom_masks[..., cb_idx]				,    )
		return pseudo_beta, pseudo_beta_mask
	else:
		return pseudo_beta



def 			A__		(					_UpperCAmelCase    :      torch.Tensor				,    _UpperCAmelCase    :      Dict[str, torch.Tensor]	)							->	torch.Tensor:

	'''simple docstring'''


	snake_case__  :						Optional[int]		=      batched_gather(
	    _UpperCAmelCase				,    batch["residx_atom37_to_atom14"]				,    dim=-2				,    no_batch_dims=len(atomaa.shape[:-2]	)				,    )

	snake_case__  :						List[Any]		=      atomaa_data * batch["atom37_atom_exists"][..., None]

	return atomaa_data



def 			A__		(					_UpperCAmelCase    :      Dict[str, torch.Tensor]	)							->	torch.Tensor:

	'''simple docstring'''


	snake_case__  :						int		=      template_feats["template_aatype"]
	snake_case__  :						Optional[int]		=      template_feats["template_torsion_angles_sin_cos"]
	snake_case__  :						Any		=      template_feats["template_alt_torsion_angles_sin_cos"]
	snake_case__  :						str		=      template_feats["template_torsion_angles_mask"]
	snake_case__  :						Tuple		=      torch.cat(
	    [
	        nn.functional.one_hot(_UpperCAmelCase				,    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 			A__		(					_UpperCAmelCase    :      Dict[str, torch.Tensor]				,    _UpperCAmelCase    :      torch.types.Number				,    _UpperCAmelCase    :      torch.types.Number				,    _UpperCAmelCase    :      int				,    _UpperCAmelCase    :      bool = False				,    _UpperCAmelCase    :      float = 1e-20				,    _UpperCAmelCase    :      float = 1e8				,    )							->	torch.Tensor:

	'''simple docstring'''


	snake_case__  :						List[Any]		=      batch["template_pseudo_beta_mask"]
	snake_case__  :						int		=      template_mask[..., None] * template_mask[..., None, :]

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

	snake_case__  :						Tuple		=      [dgram, template_mask_ad[..., None]]

	snake_case__  :						torch.LongTensor		=      nn.functional.one_hot(
	    batch["template_aatype"]				,    rc.restype_num + 2				,    )

	snake_case__  :						int		=      batch["template_aatype"].shape[-1]
	to_concat.append(aatype_one_hot[..., None, :, :].expand(*aatype_one_hot.shape[:-2]				,    _UpperCAmelCase				,    -1				,    -1	)	)
	to_concat.append(aatype_one_hot[..., None, :].expand(*aatype_one_hot.shape[:-2]				,    -1				,    _UpperCAmelCase				,    -1	)	)

	snake_case__,					snake_case__,					snake_case__  :						List[Any]		=      [rc.atom_order[a] for a in ["N", "CA", "C"]]
	snake_case__  :						Any		=      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=_UpperCAmelCase				,    )
	snake_case__  :						str		=      rigids.get_trans()[..., None, :, :]
	snake_case__  :						Dict		=      rigids[..., None].invert_apply(_UpperCAmelCase	)

	snake_case__  :						List[str]		=      torch.rsqrt(eps + torch.sum(rigid_vec**2				,    dim=-1	)	)

	snake_case__  :						Dict		=      batch["template_all_atom_mask"]
	snake_case__  :						List[str]		=      t_aa_masks[..., n] * t_aa_masks[..., ca] * t_aa_masks[..., c]
	snake_case__  :						Any		=      template_mask[..., None] * template_mask[..., None, :]

	snake_case__  :						int		=      inv_distance_scalar * template_mask_ad
	snake_case__  :						List[str]		=      rigid_vec * inv_distance_scalar[..., None]

	if not use_unit_vector:
		snake_case__  :						Optional[Any]		=      unit_vector * 0.0

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

	snake_case__  :						List[str]		=      torch.cat(_UpperCAmelCase				,    dim=-1	)
	snake_case__  :						str		=      act * template_mask_ad[..., None]

	return act



def 			A__		(					_UpperCAmelCase    :      Dict[str, torch.Tensor]	)							->	torch.Tensor:

	'''simple docstring'''


	snake_case__  :						torch.LongTensor		=      nn.functional.one_hot(batch["extra_msa"]				,    23	)
	snake_case__  :						Optional[Any]		=      [
	    msa_ahot,
	    batch["extra_has_deletion"].unsqueeze(-1	),
	    batch["extra_deletion_value"].unsqueeze(-1	),
	]
	return torch.cat(_UpperCAmelCase				,    dim=-1	)



def 			A__		(					_UpperCAmelCase    :      Rigid				,    _UpperCAmelCase    :      torch.Tensor				,    _UpperCAmelCase    :      torch.Tensor				,    _UpperCAmelCase    :      torch.Tensor				,    )							->	Rigid:

	'''simple docstring'''


	snake_case__  :						Optional[int]		=      rrgdf[aatype, ...]

	# [*, N, 8] transformations, i.e.
	#   One [*, N, 8, 3, 3] rotation matrix and
	#   One [*, N, 8, 3]    translation matrix
	snake_case__  :						str		=      r.from_tensor_axa(_UpperCAmelCase	)

	snake_case__  :						List[Any]		=      alpha.new_zeros((*((1,) * len(alpha.shape[:-1]	)), 2)	)
	snake_case__  :						Dict		=      1

	# [*, N, 8, 2]
	snake_case__  :						str		=      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.

	snake_case__  :						Tuple		=      alpha.new_zeros(default_r.get_rots().get_rot_mats().shape	)
	snake_case__  :						str		=      1
	snake_case__  :						str		=      alpha[..., 1]
	snake_case__  :						Optional[int]		=      -alpha[..., 0]
	snake_case__  :						List[Any]		=      alpha

	snake_case__  :						str		=      default_r.compose(Rigid(Rotation(rot_mats=_UpperCAmelCase	)				,    _UpperCAmelCase	)	)

	snake_case__  :						Optional[int]		=      all_frames[..., 5]
	snake_case__  :						List[str]		=      all_frames[..., 6]
	snake_case__  :						Tuple		=      all_frames[..., 7]

	snake_case__  :						Optional[Any]		=      all_frames[..., 4]
	snake_case__  :						str		=      chia_frame_to_bb.compose(_UpperCAmelCase	)
	snake_case__  :						List[Any]		=      chia_frame_to_bb.compose(_UpperCAmelCase	)
	snake_case__  :						Union[str, Any]		=      chia_frame_to_bb.compose(_UpperCAmelCase	)

	snake_case__  :						Any		=      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				,    )

	snake_case__  :						Tuple		=      r[..., None].compose(_UpperCAmelCase	)

	return all_frames_to_global



def 			A__		(					_UpperCAmelCase    :      Rigid				,    _UpperCAmelCase    :      torch.Tensor				,    _UpperCAmelCase    :      torch.Tensor				,    _UpperCAmelCase    :      torch.Tensor				,    _UpperCAmelCase    :      torch.Tensor				,    _UpperCAmelCase    :      torch.Tensor				,    )							->	torch.Tensor:

	'''simple docstring'''


	snake_case__  :						Optional[int]		=      group_idx[aatype, ...]

	# [*, N, 14, 8]
	snake_case__  :						torch.LongTensor		=      nn.functional.one_hot(
	    _UpperCAmelCase				,    num_classes=default_frames.shape[-3]				,    )

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

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

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

	# [*, N, 14, 3]
	snake_case__  :						List[Any]		=      lit_positions[aatype, ...]
	snake_case__  :						Union[str, Any]		=      t_atoms_to_global.apply(_UpperCAmelCase	)
	snake_case__  :						Dict		=      pred_positions * atom_mask

	return pred_positions













'''simple docstring'''


import json
import os
import shutil
import tempfile
import unittest

from transformers import is_speech_available, is_torch_available
from transformers.models.speechta import SpeechTaTokenizer
from transformers.testing_utils import get_tests_dir, require_torch
from transformers.utils import FEATURE_EXTRACTOR_NAME


if is_speech_available() and is_torch_available():
					from transformers import SpeechTaFeatureExtractor, SpeechTaProcessor

					from .test_feature_extraction_speechta import floats_list


lowerCamelCase_					:			List[str]     						=				get_tests_dir('''fixtures/test_sentencepiece_bpe_char.model''')
@require_torch
class  _SCREAMING_SNAKE_CASE				(		unittest.TestCase						):


			'''simple docstring'''





			def 					A   ( self				:    Union[str, Any]      )				->     Union[str, Any]:

									'''simple docstring'''







									UpperCamelCase__       =			tempfile.mkdtemp()

									UpperCamelCase__       =			SpeechTaTokenizer(lowercase      )
									tokenizer.save_pretrained(self.tmpdirname      )

									UpperCamelCase__       =			{
									    """feature_size""": 1,
									    """padding_value""": 0.0,
									    """sampling_rate""": 1_6_0_0_0,
									    """do_normalize""": False,
									    """num_mel_bins""": 8_0,
									    """hop_length""": 1_6,
									    """win_length""": 6_4,
									    """win_function""": """hann_window""",
									    """fmin""": 8_0,
									    """fmax""": 7_6_0_0,
									    """mel_floor""": 1e-10,
									    """reduction_factor""": 2,
									    """return_attention_mask""": True,
									}

									UpperCamelCase__       =			os.path.join(self.tmpdirname			,   lowercase      )
									with open(self.feature_extraction_file			,   """w"""			,   encoding="""utf-8"""      ) as fp:
															fp.write(json.dumps(lowercase      ) + """\n"""      )






			def 					A   ( self				:    Union[str, Any]			,   **lowercase				:    List[Any]      )				->     Any:

									'''simple docstring'''







									return SpeechTaTokenizer.from_pretrained(self.tmpdirname			,   **lowercase      )






			def 					A   ( self				:    str			,   **lowercase				:    Tuple      )				->     Optional[Any]:

									'''simple docstring'''







									return SpeechTaFeatureExtractor.from_pretrained(self.tmpdirname			,   **lowercase      )






			def 					A   ( self				:    Union[str, Any]      )				->     str:

									'''simple docstring'''







									shutil.rmtree(self.tmpdirname      )






			def 					A   ( self				:    List[Any]      )				->     Optional[int]:

									'''simple docstring'''







									UpperCamelCase__       =			self.get_tokenizer()
									UpperCamelCase__       =			self.get_feature_extractor()

									UpperCamelCase__       =			SpeechTaProcessor(tokenizer=lowercase			,   feature_extractor=lowercase      )

									processor.save_pretrained(self.tmpdirname      )
									UpperCamelCase__       =			SpeechTaProcessor.from_pretrained(self.tmpdirname      )

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

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






			def 					A   ( self				:    Tuple      )				->     Union[str, Any]:

									'''simple docstring'''







									UpperCamelCase__       =			SpeechTaProcessor(tokenizer=self.get_tokenizer()			,   feature_extractor=self.get_feature_extractor()      )
									processor.save_pretrained(self.tmpdirname      )

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

									UpperCamelCase__       =			SpeechTaProcessor.from_pretrained(
									    self.tmpdirname			,   bos_token="""(BOS)"""			,   eos_token="""(EOS)"""			,   do_normalize=lowercase			,   padding_value=1.0      )

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

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






			def 					A   ( self				:    List[Any]      )				->     Dict:

									'''simple docstring'''







									UpperCamelCase__       =			self.get_feature_extractor()
									UpperCamelCase__       =			self.get_tokenizer()

									UpperCamelCase__       =			SpeechTaProcessor(tokenizer=lowercase			,   feature_extractor=lowercase      )

									UpperCamelCase__       =			floats_list((3, 1_0_0_0)      )

									UpperCamelCase__       =			feature_extractor(audio=lowercase			,   return_tensors="""np"""      )
									UpperCamelCase__       =			processor(audio=lowercase			,   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				:    List[str]      )				->     Optional[Any]:

									'''simple docstring'''







									UpperCamelCase__       =			self.get_feature_extractor()
									UpperCamelCase__       =			self.get_tokenizer()

									UpperCamelCase__       =			SpeechTaProcessor(tokenizer=lowercase			,   feature_extractor=lowercase      )

									UpperCamelCase__       =			floats_list((3, 1_0_0_0)      )

									UpperCamelCase__       =			feature_extractor(audio_target=lowercase			,   return_tensors="""np"""      )
									UpperCamelCase__       =			processor(audio_target=lowercase			,   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				:    Optional[Any]      )				->     Optional[Any]:

									'''simple docstring'''







									UpperCamelCase__       =			self.get_feature_extractor()
									UpperCamelCase__       =			self.get_tokenizer()

									UpperCamelCase__       =			SpeechTaProcessor(tokenizer=lowercase			,   feature_extractor=lowercase      )

									UpperCamelCase__       =			"""This is a test string"""

									UpperCamelCase__       =			processor(text=lowercase      )
									UpperCamelCase__       =			tokenizer(lowercase      )

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






			def 					A   ( self				:    List[Any]      )				->     int:

									'''simple docstring'''







									UpperCamelCase__       =			self.get_feature_extractor()
									UpperCamelCase__       =			self.get_tokenizer()

									UpperCamelCase__       =			SpeechTaProcessor(tokenizer=lowercase			,   feature_extractor=lowercase      )

									UpperCamelCase__       =			"""This is a test string"""

									UpperCamelCase__       =			processor(text_target=lowercase      )
									UpperCamelCase__       =			tokenizer(lowercase      )

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






			def 					A   ( self				:    Any      )				->     Tuple:

									'''simple docstring'''







									UpperCamelCase__       =			self.get_feature_extractor()
									UpperCamelCase__       =			self.get_tokenizer()

									UpperCamelCase__       =			SpeechTaProcessor(tokenizer=lowercase			,   feature_extractor=lowercase      )

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

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

									self.assertListEqual(lowercase			,   lowercase      )







			def 					A   ( self				:    List[Any]      )				->     List[str]:

									'''simple docstring'''







									UpperCamelCase__       =			self.get_feature_extractor()
									UpperCamelCase__       =			self.get_tokenizer()

									UpperCamelCase__       =			SpeechTaProcessor(tokenizer=lowercase			,   feature_extractor=lowercase      )

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