





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







@overload
def  A					(				UpperCAmelCase	,	UpperCAmelCase	,	UpperCAmelCase					):
					...







def  A					(				UpperCAmelCase	,	UpperCAmelCase	,	UpperCAmelCase					):
					_snake_case							:       Optional[int]												= aatype == rc.restype_order["G"]
					_snake_case							:       Optional[int]												= rc.atom_order["CA"]
					_snake_case							:       Optional[Any]												= rc.atom_order["CB"]
					_snake_case							:       Optional[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							:       Tuple												= 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	,	UpperCAmelCase					):
					_snake_case							:       List[str]												= batched_gather(
					    UpperCAmelCase	,	batch["residx_atom37_to_atom14"]	,	dim=-2	,	no_batch_dims=len(atomaa.shape[:-2]					)	,	)

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

					return atomaa_data







def  A					(				UpperCAmelCase					):
					_snake_case							:       Dict												= template_feats["template_aatype"]
					_snake_case							:       Optional[int]												= template_feats["template_torsion_angles_sin_cos"]
					_snake_case							:       Tuple												= template_feats["template_alt_torsion_angles_sin_cos"]
					_snake_case							:       Optional[int]												= template_feats["template_torsion_angles_mask"]
					_snake_case							:       Union[str, Any]												= 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	,	UpperCAmelCase	,	UpperCAmelCase	,	UpperCAmelCase	,	UpperCAmelCase = False	,	UpperCAmelCase = 1e-20	,	UpperCAmelCase = 1e8	,	):
					_snake_case							:       Union[str, Any]												= batch["template_pseudo_beta_mask"]
					_snake_case							:       Union[str, Any]												= 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							:       Optional[int]												= torch.sum((tpb[..., None, :] - tpb[..., None, :, :]) ** 2	,	dim=-1	,	keepdim=UpperCAmelCase					)
					_snake_case							:       Dict												= torch.linspace(UpperCAmelCase	,	UpperCAmelCase	,	UpperCAmelCase	,	device=tpb.device					) ** 2
					_snake_case							:       Dict												= torch.cat([lower[1:], lower.new_tensor([inf]					)]	,	dim=-1					)
					_snake_case							:       List[Any]												= ((dgram > lower) * (dgram < upper)).type(dgram.dtype					)

					_snake_case							:       Union[str, Any]												= [dgram, template_mask_ad[..., None]]

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

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

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

					_snake_case							:       List[str]												= batch["template_all_atom_mask"]
					_snake_case							:       Optional[Any]												= t_aa_masks[..., n] * t_aa_masks[..., ca] * t_aa_masks[..., c]
					_snake_case							:       Optional[int]												= template_mask[..., None] * template_mask[..., None, :]

					_snake_case							:       Dict												= inv_distance_scalar * template_mask_ad
					_snake_case							:       Any												= rigid_vec * inv_distance_scalar[..., None]

					if not use_unit_vector:
										_snake_case							:       Any												= unit_vector * 0.0

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

					_snake_case							:       Union[str, Any]												= torch.cat(UpperCAmelCase	,	dim=-1					)
					_snake_case							:       Optional[int]												= act * template_mask_ad[..., None]

					return act







def  A					(				UpperCAmelCase					):
					_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	,	UpperCAmelCase	,	UpperCAmelCase	,	UpperCAmelCase	,	):
					# [*, N, 8, 4, 4]
					_snake_case							:       List[Any]												= rrgdf[aatype, ...]

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

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

					# [*, N, 8, 2]
					_snake_case							:       int												= 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							:       int												= alpha.new_zeros(default_r.get_rots().get_rot_mats().shape					)
					_snake_case							:       Tuple												= 1
					_snake_case							:       Union[str, Any]												= alpha[..., 1]
					_snake_case							:       Tuple												= -alpha[..., 0]
					_snake_case							:       Any												= alpha

					_snake_case							:       Optional[Any]												= default_r.compose(Rigid(Rotation(rot_mats=UpperCAmelCase					)	,	UpperCAmelCase					)					)

					_snake_case							:       Tuple												= all_frames[..., 5]
					_snake_case							:       str												= all_frames[..., 6]
					_snake_case							:       str												= all_frames[..., 7]

					_snake_case							:       Optional[Any]												= all_frames[..., 4]
					_snake_case							:       Union[str, Any]												= chia_frame_to_bb.compose(UpperCAmelCase					)
					_snake_case							:       Tuple												= chia_frame_to_bb.compose(UpperCAmelCase					)
					_snake_case							:       Optional[Any]												= chia_frame_to_bb.compose(UpperCAmelCase					)

					_snake_case							:       str												= 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							:       Dict												= r[..., None].compose(UpperCAmelCase					)

					return all_frames_to_global







def  A					(				UpperCAmelCase	,	UpperCAmelCase	,	UpperCAmelCase	,	UpperCAmelCase	,	UpperCAmelCase	,	UpperCAmelCase	,	):
					# [*, N, 14]
					_snake_case							:       List[Any]												= 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							:       List[Any]												= r[..., None, :] * group_mask_one_hot

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

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

					# [*, N, 14, 3]
					_snake_case							:       List[str]												= lit_positions[aatype, ...]
					_snake_case							:       Optional[Any]												= t_atoms_to_global.apply(UpperCAmelCase					)
					_snake_case							:       List[Any]												= pred_positions * atom_mask

					return pred_positions






import importlib
import sys
from argparse import REMAINDER, ArgumentParser
from pathlib import Path

import torch_xla.distributed.xla_multiprocessing as xmp







def  A					(				):
					_snake_case							:       Optional[Any]												= ArgumentParser(
					    description=(
					        "PyTorch TPU distributed training launch helper utility that will spawn up multiple distributed processes"
					    )					)

					# Optional arguments for the launch helper
					parser.add_argument("--num_cores"	,	type=UpperCAmelCase	,	default=1	,	help="Number of TPU cores to use (1 or 8)."					)

					# positional
					parser.add_argument(
					    "training_script"	,	type=UpperCAmelCase	,	help=(
					        "The full path to the single TPU training "
					        "program/script to be launched in parallel, "
					        "followed by all the arguments for the "
					        "training script"
					    )	,	)

					# rest from the training program
					parser.add_argument("training_script_args"	,	nargs=UpperCAmelCase					)

					return parser.parse_args()







def  A					(				):
					_snake_case							:       Any												= parse_args()

					# Import training_script as a module.
					_snake_case							:       Any												= Path(args.training_script					)
					sys.path.append(str(script_fpath.parent.resolve()					)					)
					_snake_case							:       Tuple												= script_fpath.stem
					_snake_case							:       str												= importlib.import_module(UpperCAmelCase					)

					# Patch sys.argv
					_snake_case							:       str												= [args.training_script] + args.training_script_args + ["--tpu_num_cores", str(args.num_cores					)]

					xmp.spawn(mod._mp_fn	,	args=()	,	nprocs=args.num_cores					)


if __name__ == "__main__":
							main()