




"""simple docstring"""




from __future__ import annotations

from collections import deque
from collections.abc import Iterator
from dataclasses import dataclass






@dataclass
class        __magic_name__				:






				'''simple docstring'''
				__UpperCamelCase         =		42
				__UpperCamelCase         =		42






class        __magic_name__				:






				'''simple docstring'''





				def __init__(			self						,					_a					):





							"""simple docstring"""
							lowerCamelCase      =   [[] for _ in range(_a					)]
							lowerCamelCase      =   size





				def __getitem__(			self						,					_a					):





							"""simple docstring"""
							return iter(self._graph[vertex]					)





				@property
				def   _lowerCAmelCase							(			self					):





							"""simple docstring"""
							return self._size





				def   _lowerCAmelCase							(			self						,					_a						,					_a						,					_a					):





							"""simple docstring"""
							if weight not in (0, 1):
										raise ValueError("""Edge weight must be either 0 or 1."""					)

							if to_vertex < 0 or to_vertex >= self.size:
										raise ValueError("""Vertex indexes must be in [0; size)."""					)

							self._graph[from_vertex].append(Edge(_a						,					_a					)					)





				def   _lowerCAmelCase							(			self						,					_a						,					_a					):





							"""simple docstring"""
							lowerCamelCase      =   deque([start_vertex]					)
							lowerCamelCase      =   [None] * self.size
							lowerCamelCase      =   0

							while queue:
										lowerCamelCase      =   queue.popleft()
										lowerCamelCase      =   distances[current_vertex]
										if current_distance is None:
													continue

										for edge in self[current_vertex]:
													lowerCamelCase      =   current_distance + edge.weight
													lowerCamelCase      =   distances[edge.destination_vertex]
													if (
													    isinstance(_a						,					_a					)
													    and new_distance >= dest_vertex_distance
													):
																continue
													lowerCamelCase      =   new_distance
													if edge.weight == 0:
																queue.appendleft(edge.destination_vertex					)
													else:
																queue.append(edge.destination_vertex					)

							if distances[finish_vertex] is None:
										raise ValueError("""No path from start_vertex to finish_vertex."""					)

							return distances[finish_vertex]


if __name__ == "__main__":
					import doctest

					doctest.testmod()









"""simple docstring"""




from typing import Dict

import numpy as np
import torch

from . import residue_constants as rc
from .tensor_utils import tensor_tree_map, tree_map



def        a__					(							snake_case__							)		->   Dict[str, torch.Tensor]:
			lowerCamelCase      =   []
			lowerCamelCase      =   []
			lowerCamelCase      =   []

			for rt in rc.restypes:
						lowerCamelCase      =   rc.restype_name_to_atomaa_names[rc.restype_atoa[rt]]
						restype_atomaa_to_atomaa_list.append([(rc.atom_order[name] if name else 0) for name in atom_names]							)
						lowerCamelCase      =   {name: i for i, name in enumerate(snake_case__							)}
						restype_atomaa_to_atomaa_list.append(
						    [(atom_name_to_idxaa[name] if name in atom_name_to_idxaa else 0) for name in rc.atom_types]							)

						restype_atomaa_mask_list.append([(1.0 if name else 0.0) for name in atom_names]							)

			# Add dummy mapping for restype 'UNK'
			restype_atomaa_to_atomaa_list.append([0] * 14							)
			restype_atomaa_to_atomaa_list.append([0] * 37							)
			restype_atomaa_mask_list.append([0.0] * 14							)

			lowerCamelCase      =   torch.tensor(
			    snake_case__			,					dtype=torch.intaa			,					device=protein["""aatype"""].device			,					)
			lowerCamelCase      =   torch.tensor(
			    snake_case__			,					dtype=torch.intaa			,					device=protein["""aatype"""].device			,					)
			lowerCamelCase      =   torch.tensor(
			    snake_case__			,					dtype=torch.floataa			,					device=protein["""aatype"""].device			,					)
			lowerCamelCase      =   protein["""aatype"""].to(torch.long							)

			# create the mapping for (residx, atom14) --> atom37, i.e. an array
			# with shape (num_res, 14) containing the atom37 indices for this protein
			lowerCamelCase      =   restype_atomaa_to_atomaa[protein_aatype]
			lowerCamelCase      =   restype_atomaa_mask[protein_aatype]

			lowerCamelCase      =   residx_atomaa_mask
			lowerCamelCase      =   residx_atomaa_to_atomaa.long()

			# create the gather indices for mapping back
			lowerCamelCase      =   restype_atomaa_to_atomaa[protein_aatype]
			lowerCamelCase      =   residx_atomaa_to_atomaa.long()

			# create the corresponding mask
			lowerCamelCase      =   torch.zeros([21, 37]			,					dtype=torch.floataa			,					device=protein["""aatype"""].device							)
			for restype, restype_letter in enumerate(rc.restypes							):
						lowerCamelCase      =   rc.restype_atoa[restype_letter]
						lowerCamelCase      =   rc.residue_atoms[restype_name]
						for atom_name in atom_names:
									lowerCamelCase      =   rc.atom_order[atom_name]
									lowerCamelCase      =   1

			lowerCamelCase      =   restype_atomaa_mask[protein_aatype]
			lowerCamelCase      =   residx_atomaa_mask

			return protein



def        a__					(							snake_case__							)		->   Dict[str, np.ndarray]:
			lowerCamelCase      =   tree_map(lambda snake_case__							: torch.tensor(snake_case__			,					device=batch["""aatype"""].device							)			,					snake_case__			,					np.ndarray							)
			lowerCamelCase      =   tensor_tree_map(lambda snake_case__							: np.array(snake_case__							)			,					make_atomaa_masks(snake_case__							)							)
			return out



