code: 
  """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  (	__lowerCamelCase,	__lowerCamelCase,	__lowerCamelCase						):
     ...
  
  
  
  
  
  
  
  @overload
  def 			__a  (	__lowerCamelCase,	__lowerCamelCase,	__lowerCamelCase						):
     ...
  
  
  
  
  
  
  
  def 			__a  (	__lowerCamelCase,	__lowerCamelCase,	__lowerCamelCase						):
     UpperCAmelCase_      :      Optional[int]      =					aatype == rc.restype_order["G"]
     UpperCAmelCase_      :      Tuple      =					rc.atom_order["CA"]
     UpperCAmelCase_      :      Tuple      =					rc.atom_order["CB"]
     UpperCAmelCase_      :      Optional[int]      =					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:
        UpperCAmelCase_      :      Any      =					torch.where(
            __lowerCamelCase,	all_atom_masks[..., ca_idx],	all_atom_masks[..., cb_idx],	)
        return pseudo_beta, pseudo_beta_mask
     else:
        return pseudo_beta
  
  
  
  
  
  
  
  def 			__a  (	__lowerCamelCase,	__lowerCamelCase						):
     UpperCAmelCase_      :      Any      =					batched_gather(
         __lowerCamelCase,	batch["residx_atom37_to_atom14"],	dim=-2,	no_batch_dims=len(atomaa.shape[:-2]						),	)
  
     UpperCAmelCase_      :      str      =					atomaa_data * batch["atom37_atom_exists"][..., None]
  
     return atomaa_data
  
  
  
  
  
  
  
  def 			__a  (	__lowerCamelCase						):
     UpperCAmelCase_      :      int      =					template_feats["template_aatype"]
     UpperCAmelCase_      :      List[str]      =					template_feats["template_torsion_angles_sin_cos"]
     UpperCAmelCase_      :      str      =					template_feats["template_alt_torsion_angles_sin_cos"]
     UpperCAmelCase_      :      List[str]      =					template_feats["template_torsion_angles_mask"]
     UpperCAmelCase_      :      Optional[int]      =					torch.cat(
         [
             nn.functional.one_hot(__lowerCamelCase,	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  (	__lowerCamelCase,	__lowerCamelCase,	__lowerCamelCase,	__lowerCamelCase,	__lowerCamelCase = False,	__lowerCamelCase = 1E-20,	__lowerCamelCase = 1E8,	):
     UpperCAmelCase_      :      Union[str, Any]      =					batch["template_pseudo_beta_mask"]
     UpperCAmelCase_      :      Tuple      =					template_mask[..., None] * template_mask[..., None, :]
  
     # Compute distogram (this seems to differ slightly from Alg. 5)
     UpperCAmelCase_      :      Optional[Any]      =					batch["template_pseudo_beta"]
     UpperCAmelCase_      :      List[str]      =					torch.sum((tpb[..., None, :] - tpb[..., None, :, :]) ** 2,	dim=-1,	keepdim=__lowerCamelCase						)
     UpperCAmelCase_      :      Any      =					torch.linspace(__lowerCamelCase,	__lowerCamelCase,	__lowerCamelCase,	device=tpb.device						) ** 2
     UpperCAmelCase_      :      List[str]      =					torch.cat([lower[1:], lower.new_tensor([inf]						)],	dim=-1						)
     UpperCAmelCase_      :      Any      =					((dgram > lower) * (dgram < upper)).type(dgram.dtype						)
  
     UpperCAmelCase_      :      Optional[int]      =					[dgram, template_mask_ad[..., None]]
  
     UpperCAmelCase_      :      torch.LongTensor      =					nn.functional.one_hot(
         batch["template_aatype"],	rc.restype_num + 2,	)
  
     UpperCAmelCase_      :      Dict      =					batch["template_aatype"].shape[-1]
     to_concat.append(aatype_one_hot[..., None, :, :].expand(*aatype_one_hot.shape[:-2],	__lowerCamelCase,	-1,	-1						)						)
     to_concat.append(aatype_one_hot[..., None, :].expand(*aatype_one_hot.shape[:-2],	-1,	__lowerCamelCase,	-1						)						)
  
     UpperCAmelCase_  ,     UpperCAmelCase_  ,     UpperCAmelCase_      :      str      =					[rc.atom_order[a] for a in ["N", "CA", "C"]]
     UpperCAmelCase_      :      Optional[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=__lowerCamelCase,	)
     UpperCAmelCase_      :      str      =					rigids.get_trans()[..., None, :, :]
     UpperCAmelCase_      :      int      =					rigids[..., None].invert_apply(__lowerCamelCase						)
  
     UpperCAmelCase_      :      Optional[int]      =					torch.rsqrt(eps + torch.sum(rigid_vec**2,	dim=-1						)						)
  
     UpperCAmelCase_      :      Optional[int]      =					batch["template_all_atom_mask"]
     UpperCAmelCase_      :      List[Any]      =					t_aa_masks[..., n] * t_aa_masks[..., ca] * t_aa_masks[..., c]
     UpperCAmelCase_      :      Optional[int]      =					template_mask[..., None] * template_mask[..., None, :]
  
     UpperCAmelCase_      :      Optional[int]      =					inv_distance_scalar * template_mask_ad
     UpperCAmelCase_      :      int      =					rigid_vec * inv_distance_scalar[..., None]
  
     if not use_unit_vector:
        UpperCAmelCase_      :      Optional[Any]      =					unit_vector * 0.0
  
     to_concat.extend(torch.unbind(unit_vector[..., None, :],	dim=-1						)						)
     to_concat.append(template_mask_ad[..., None]						)
  
     UpperCAmelCase_      :      Optional[Any]      =					torch.cat(__lowerCamelCase,	dim=-1						)
     UpperCAmelCase_      :      Dict      =					act * template_mask_ad[..., None]
  
     return act
  
  
  
  
  
  
  
  def 			__a  (	__lowerCamelCase						):
     UpperCAmelCase_      :      torch.LongTensor      =					nn.functional.one_hot(batch["extra_msa"],	23						)
     UpperCAmelCase_      :      Optional[Any]      =					[
         msa_ahot,
         batch["extra_has_deletion"].unsqueeze(-1						),
         batch["extra_deletion_value"].unsqueeze(-1						),
     ]
     return torch.cat(__lowerCamelCase,	dim=-1						)
  
  
  
  
  
  
  
  def 			__a  (	__lowerCamelCase,	__lowerCamelCase,	__lowerCamelCase,	__lowerCamelCase,	):
     # [*, N, 8, 4, 4]
     UpperCAmelCase_      :      List[Any]      =					rrgdf[aatype, ...]
  
     # [*, N, 8] transformations, i.e.
     #   One [*, N, 8, 3, 3] rotation matrix and
     #   One [*, N, 8, 3]    translation matrix
     UpperCAmelCase_      :      Optional[int]      =					r.from_tensor_axa(__lowerCamelCase						)
  
     UpperCAmelCase_      :      Tuple      =					alpha.new_zeros((*((1,) * len(alpha.shape[:-1]						)), 2)						)
     UpperCAmelCase_      :      int      =					1
  
     # [*, N, 8, 2]
     UpperCAmelCase_      :      List[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.
  
     UpperCAmelCase_      :      List[str]      =					alpha.new_zeros(default_r.get_rots().get_rot_mats().shape						)
     UpperCAmelCase_      :      List[Any]      =					1
     UpperCAmelCase_      :      Union[str, Any]      =					alpha[..., 1]
     UpperCAmelCase_      :      Union[str, Any]      =					-alpha[..., 0]
     UpperCAmelCase_      :      int      =					alpha
  
     UpperCAmelCase_      :      Union[str, Any]      =					default_r.compose(Rigid(Rotation(rot_mats=__lowerCamelCase						),	__lowerCamelCase						)						)
  
     UpperCAmelCase_      :      Union[str, Any]      =					all_frames[..., 5]
     UpperCAmelCase_      :      List[str]      =					all_frames[..., 6]
     UpperCAmelCase_      :      List[str]      =					all_frames[..., 7]
  
     UpperCAmelCase_      :      List[Any]      =					all_frames[..., 4]
     UpperCAmelCase_      :      Union[str, Any]      =					chia_frame_to_bb.compose(__lowerCamelCase						)
     UpperCAmelCase_      :      List[str]      =					chia_frame_to_bb.compose(__lowerCamelCase						)
     UpperCAmelCase_      :      str      =					chia_frame_to_bb.compose(__lowerCamelCase						)
  
     UpperCAmelCase_      :      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,	)
  
     UpperCAmelCase_      :      str      =					r[..., None].compose(__lowerCamelCase						)
  
     return all_frames_to_global
  
  
  
  
  
  
  
  def 			__a  (	__lowerCamelCase,	__lowerCamelCase,	__lowerCamelCase,	__lowerCamelCase,	__lowerCamelCase,	__lowerCamelCase,	):
     # [*, N, 14]
     UpperCAmelCase_      :      str      =					group_idx[aatype, ...]
  
     # [*, N, 14, 8]
     UpperCAmelCase_      :      torch.LongTensor      =					nn.functional.one_hot(
         __lowerCamelCase,	num_classes=default_frames.shape[-3],	)
  
     # [*, N, 14, 8]
     UpperCAmelCase_      :      Optional[Any]      =					r[..., None, :] * group_mask_one_hot
  
     # [*, N, 14]
     UpperCAmelCase_      :      str      =					t_atoms_to_global.map_tensor_fn(lambda __lowerCamelCase						: torch.sum(__lowerCamelCase,	dim=-1						)						)
  
     # [*, N, 14, 1]
     UpperCAmelCase_      :      str      =					atom_mask[aatype, ...].unsqueeze(-1						)
  
     # [*, N, 14, 3]
     UpperCAmelCase_      :      Tuple      =					lit_positions[aatype, ...]
     UpperCAmelCase_      :      Dict      =					t_atoms_to_global.apply(__lowerCamelCase						)
     UpperCAmelCase_      :      Any      =					pred_positions * atom_mask
  
     return pred_positions
  
  
  
style_context: 
  """simple docstring"""
  
  
  
  
  
  from string import ascii_uppercase
  
  
  
  
  
  
  
  def 			__a  (	__lowerCamelCase,	__lowerCamelCase,	__lowerCamelCase = False,	__lowerCamelCase = ascii_uppercase						):
     UpperCAmelCase_      :      List[str]      =					keyword.upper()
     UpperCAmelCase_      :      str      =					plaintext.upper()
     UpperCAmelCase_      :      Tuple      =					set(__lowerCamelCase						)
  
     # create a list of unique characters in the keyword - their order matters
     # it determines how we will map plaintext characters to the ciphertext
     UpperCAmelCase_      :      Tuple      =					[]
     for char in keyword:
        if char in alphabet_set and char not in unique_chars:
           unique_chars.append(__lowerCamelCase						)
      # the number of those unique characters will determine the number of rows
     UpperCAmelCase_      :      Union[str, Any]      =					len(__lowerCamelCase						)
  
     # create a shifted version of the alphabet
     UpperCAmelCase_      :      Tuple      =					unique_chars + [
         char for char in alphabet if char not in unique_chars
     ]
  
     # create a modified alphabet by splitting the shifted alphabet into rows
     UpperCAmelCase_      :      List[str]      =					[
         shifted_alphabet[k : k + num_unique_chars_in_keyword]
         for k in range(0,	26,	__lowerCamelCase						)
     ]
  
     # map the alphabet characters to the modified alphabet characters
     # going 'vertically' through the modified alphabet - consider columns first
     UpperCAmelCase_      :      Tuple      =					{}
     UpperCAmelCase_      :      Dict      =					0
     for column in range(__lowerCamelCase						):
        for row in modified_alphabet:
           # if current row (the last one) is too short, break out of loop
           if len(__lowerCamelCase						) <= column:
              break
  
           # map current letter to letter in modified alphabet
           UpperCAmelCase_      :      Tuple      =					row[column]
           letter_index += 1
  
     if verbose:
        print(__lowerCamelCase						)
     # create the encrypted text by mapping the plaintext to the modified alphabet
     return "".join(mapping[char] if char in mapping else char for char in plaintext						)
  
  
  if __name__ == "__main__":
      # example use
      print(mixed_keyword('college', 'UNIVERSITY'))
  
  
  