






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 				lowerCamelCase__				(_UpperCAmelCase):
			SCREAMING_SNAKE_CASE						= []
			SCREAMING_SNAKE_CASE						= []
			SCREAMING_SNAKE_CASE						= []

			for rt in rc.restypes:
						SCREAMING_SNAKE_CASE						= 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])
						SCREAMING_SNAKE_CASE						= {name: i for i, name in enumerate(_UpperCAmelCase)}
						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)

			SCREAMING_SNAKE_CASE						= torch.tensor(
			    _UpperCAmelCase							,       dtype=torch.intaa							,       device=protein['aatype'].device							,       )
			SCREAMING_SNAKE_CASE						= torch.tensor(
			    _UpperCAmelCase							,       dtype=torch.intaa							,       device=protein['aatype'].device							,       )
			SCREAMING_SNAKE_CASE						= torch.tensor(
			    _UpperCAmelCase							,       dtype=torch.floataa							,       device=protein['aatype'].device							,       )
			SCREAMING_SNAKE_CASE						= 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
			SCREAMING_SNAKE_CASE						= restype_atomaa_to_atomaa[protein_aatype]
			SCREAMING_SNAKE_CASE						= restype_atomaa_mask[protein_aatype]

			SCREAMING_SNAKE_CASE						= residx_atomaa_mask
			SCREAMING_SNAKE_CASE						= residx_atomaa_to_atomaa.long()

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

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

			SCREAMING_SNAKE_CASE						= restype_atomaa_mask[protein_aatype]
			SCREAMING_SNAKE_CASE						= residx_atomaa_mask

			return protein







def 				lowerCamelCase__				(_UpperCAmelCase):
			SCREAMING_SNAKE_CASE						= tree_map(lambda _UpperCAmelCase: torch.tensor(_UpperCAmelCase							,       device=batch['aatype'].device)							,       _UpperCAmelCase							,       np.ndarray)
			SCREAMING_SNAKE_CASE						= tensor_tree_map(lambda _UpperCAmelCase: np.array(_UpperCAmelCase)							,       make_atomaa_masks(_UpperCAmelCase))
			return out












# tests directory-specific settings - this file is run automatically
# by pytest before any tests are run

import doctest
import sys
import warnings
from os.path import abspath, dirname, join

import _pytest

from transformers.testing_utils import HfDoctestModule, HfDocTestParser


# allow having multiple repository checkouts and not needing to remember to rerun
# 'pip install -e .[dev]' when switching between checkouts and running tests.
a_		:						List[str]             =    abspath(join(dirname(__file__), 'src'))
sys.path.insert(1, git_repo_path)

# silence FutureWarning warnings in tests since often we can't act on them until
# they become normal warnings - i.e. the tests still need to test the current functionality
warnings.simplefilter(action='ignore', category=FutureWarning)






def 				lowerCamelCase__				(_UpperCAmelCase):
			config.addinivalue_line(
			    'markers'							,       'is_pt_tf_cross_test: mark test to run only when PT and TF interactions are tested')
			config.addinivalue_line(
			    'markers'							,       'is_pt_flax_cross_test: mark test to run only when PT and FLAX interactions are tested')
			config.addinivalue_line('markers'							,       'is_pipeline_test: mark test to run only when pipelines are tested')
			config.addinivalue_line('markers'							,       'is_staging_test: mark test to run only in the staging environment')
			config.addinivalue_line('markers'							,       'accelerate_tests: mark test that require accelerate')
			config.addinivalue_line('markers'							,       'tool_tests: mark the tool tests that are run on their specific schedule')






def 				lowerCamelCase__				(_UpperCAmelCase):
			from transformers.testing_utils import pytest_addoption_shared

			pytest_addoption_shared(_UpperCAmelCase)






def 				lowerCamelCase__				(_UpperCAmelCase):
			from transformers.testing_utils import pytest_terminal_summary_main

			SCREAMING_SNAKE_CASE						= terminalreporter.config.getoption('--make-reports')
			if make_reports:
						pytest_terminal_summary_main(_UpperCAmelCase							,       id=_UpperCAmelCase)






def 				lowerCamelCase__				(_UpperCAmelCase							,       _UpperCAmelCase):
			# If no tests are collected, pytest exists with code 5, which makes the CI fail.
			if exitstatus == 5:
						SCREAMING_SNAKE_CASE						= 0


# Doctest custom flag to ignore output.
a_		:						List[Any]             =    doctest.register_optionflag('IGNORE_RESULT')

a_		:						Any             =    doctest.OutputChecker

class 		_snake_case  (  A__					):






			def    SCREAMING_SNAKE_CASE__    (       self		,					a		,					a		,					a)      ->       List[Any]:
						if IGNORE_RESULT & optionflags:
									return True
						return OutputChecker.check_output(self		,					a		,					a		,					a)



a_		:						int             =    CustomOutputChecker
a_		:						List[str]             =    HfDoctestModule







a_		:						Optional[int]             =    HfDocTestParser




