


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				(     UpperCAmelCase				,UpperCAmelCase				,UpperCAmelCase      )->		torch.Tensor:







					'''simple docstring'''



					...







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







					'''simple docstring'''



					...







def 							UpperCAmelCase				(     UpperCAmelCase				,UpperCAmelCase				,UpperCAmelCase      )->		Any:







					'''simple docstring'''



					SCREAMING_SNAKE_CASE_	      =       aatype == rc.restype_order['''G''']
					SCREAMING_SNAKE_CASE_	      =       rc.atom_order['''CA''']
					SCREAMING_SNAKE_CASE_	      =       rc.atom_order['''CB''']
					SCREAMING_SNAKE_CASE_	      =       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:
										SCREAMING_SNAKE_CASE_	      =       torch.where(
										    UpperCAmelCase				,all_atom_masks[..., ca_idx]				,all_atom_masks[..., cb_idx]				,)
										return pseudo_beta, pseudo_beta_mask
					else:
										return pseudo_beta







def 							UpperCAmelCase				(     UpperCAmelCase				,UpperCAmelCase      )->		torch.Tensor:







					'''simple docstring'''



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

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

					return atomaa_data







def 							UpperCAmelCase				(     UpperCAmelCase      )->		torch.Tensor:







					'''simple docstring'''



					SCREAMING_SNAKE_CASE_	      =       template_feats['''template_aatype''']
					SCREAMING_SNAKE_CASE_	      =       template_feats['''template_torsion_angles_sin_cos''']
					SCREAMING_SNAKE_CASE_	      =       template_feats['''template_alt_torsion_angles_sin_cos''']
					SCREAMING_SNAKE_CASE_	      =       template_feats['''template_torsion_angles_mask''']
					SCREAMING_SNAKE_CASE_	      =       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 							UpperCAmelCase				(     UpperCAmelCase				,UpperCAmelCase				,UpperCAmelCase				,UpperCAmelCase				,UpperCAmelCase = False				,UpperCAmelCase = 1E-20				,UpperCAmelCase = 1E8				,)->		torch.Tensor:







					'''simple docstring'''



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

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

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

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

					SCREAMING_SNAKE_CASE_	      =       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      )      )

					SCREAMING_SNAKE_CASE_      ,SCREAMING_SNAKE_CASE_      ,SCREAMING_SNAKE_CASE_	      =       [rc.atom_order[a] for a in ['''N''', '''CA''', '''C''']]
					SCREAMING_SNAKE_CASE_	      =       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				,)
					SCREAMING_SNAKE_CASE_	      =       rigids.get_trans()[..., None, :, :]
					SCREAMING_SNAKE_CASE_	      =       rigids[..., None].invert_apply(UpperCAmelCase      )

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

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

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

					if not use_unit_vector:
										SCREAMING_SNAKE_CASE_	      =       unit_vector * 0.0

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

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

					return act







def 							UpperCAmelCase				(     UpperCAmelCase      )->		torch.Tensor:







					'''simple docstring'''



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







def 							UpperCAmelCase				(     UpperCAmelCase				,UpperCAmelCase				,UpperCAmelCase				,UpperCAmelCase				,)->		Rigid:







					'''simple docstring'''



					SCREAMING_SNAKE_CASE_	      =       rrgdf[aatype, ...]

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

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

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

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

					SCREAMING_SNAKE_CASE_	      =       default_r.compose(Rigid(Rotation(rot_mats=UpperCAmelCase      )				,UpperCAmelCase      )      )

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

					SCREAMING_SNAKE_CASE_	      =       all_frames[..., 4]
					SCREAMING_SNAKE_CASE_	      =       chia_frame_to_bb.compose(UpperCAmelCase      )
					SCREAMING_SNAKE_CASE_	      =       chia_frame_to_bb.compose(UpperCAmelCase      )
					SCREAMING_SNAKE_CASE_	      =       chia_frame_to_bb.compose(UpperCAmelCase      )

					SCREAMING_SNAKE_CASE_	      =       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				,)

					SCREAMING_SNAKE_CASE_	      =       r[..., None].compose(UpperCAmelCase      )

					return all_frames_to_global







def 							UpperCAmelCase				(     UpperCAmelCase				,UpperCAmelCase				,UpperCAmelCase				,UpperCAmelCase				,UpperCAmelCase				,UpperCAmelCase				,)->		torch.Tensor:







					'''simple docstring'''



					SCREAMING_SNAKE_CASE_	      =       group_idx[aatype, ...]

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

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

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

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

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

					return pred_positions






from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_flax_available,
    is_sentencepiece_available,
    is_tf_available,
    is_tokenizers_available,
    is_torch_available,
)


A_														=      {
    "configuration_switch_transformers": [
        "SWITCH_TRANSFORMERS_PRETRAINED_CONFIG_ARCHIVE_MAP",
        "SwitchTransformersConfig",
        "SwitchTransformersOnnxConfig",
    ]
}

try:
		if not is_torch_available():
				raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
		pass
else:
		A_														=      [
		    "SWITCH_TRANSFORMERS_PRETRAINED_MODEL_ARCHIVE_LIST",
		    "SwitchTransformersEncoderModel",
		    "SwitchTransformersForConditionalGeneration",
		    "SwitchTransformersModel",
		    "SwitchTransformersPreTrainedModel",
		    "SwitchTransformersTop1Router",
		    "SwitchTransformersSparseMLP",
		]


if TYPE_CHECKING:
		from .configuration_switch_transformers import (
		    SWITCH_TRANSFORMERS_PRETRAINED_CONFIG_ARCHIVE_MAP,
		    SwitchTransformersConfig,
		    SwitchTransformersOnnxConfig,
		)

		try:
				if not is_torch_available():
						raise OptionalDependencyNotAvailable()
		except OptionalDependencyNotAvailable:
				pass
		else:
				from .modeling_switch_transformers import (
				    SWITCH_TRANSFORMERS_PRETRAINED_MODEL_ARCHIVE_LIST,
				    SwitchTransformersEncoderModel,
				    SwitchTransformersForConditionalGeneration,
				    SwitchTransformersModel,
				    SwitchTransformersPreTrainedModel,
				    SwitchTransformersSparseMLP,
				    SwitchTransformersTopaRouter,
				)


else:
		import sys

		A_														=      _LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)


