


'''simple docstring'''







import unittest

import numpy as np

from transformers.testing_utils import require_torch, require_vision
from transformers.utils import is_torch_available, is_vision_available

from ...test_image_processing_common import ImageProcessingSavingTestMixin, prepare_image_inputs


if is_torch_available():
  import torch

if is_vision_available():
  from PIL import Image

  from transformers import GLPNImageProcessor
class 					lowercase_     (    unittest.TestCase   ):


    def __init__(     self  ,					a  ,					a=7  ,					a=3  ,					a=18  ,					a=30  ,					a=4_00  ,					a=True  ,					a=32  ,					a=True  ,					):
          UpperCamelCase__										=				parent
          UpperCamelCase__										=				batch_size
          UpperCamelCase__										=				num_channels
          UpperCamelCase__										=				image_size
          UpperCamelCase__										=				min_resolution
          UpperCamelCase__										=				max_resolution
          UpperCamelCase__										=				do_resize
          UpperCamelCase__										=				size_divisor
          UpperCamelCase__										=				do_rescale


    def    __a							(     self    ):
          return {
              "do_resize": self.do_resize,
              "size_divisor": self.size_divisor,
              "do_rescale": self.do_rescale,
          }

@require_torch
@require_vision
class 					lowercase_     (    _snake_case  ,						unittest.TestCase   ):
    __UpperCAmelCase   			=	GLPNImageProcessor if is_vision_available() else None


    def    __a							(     self    ):
          UpperCamelCase__										=				GLPNImageProcessingTester(self    )


    @property
    def    __a							(     self    ):
          return self.image_processor_tester.prepare_image_processor_dict()


    def    __a							(     self    ):
          UpperCamelCase__										=				self.image_processing_class(**self.image_processor_dict    )
          self.assertTrue(hasattr(__snake_case  ,					"do_resize"    )    )
          self.assertTrue(hasattr(__snake_case  ,					"size_divisor"    )    )
          self.assertTrue(hasattr(__snake_case  ,					"resample"    )    )
          self.assertTrue(hasattr(__snake_case  ,					"do_rescale"    )    )


    def    __a							(     self    ):
          pass


    def    __a							(     self    ):
          # Initialize image_processing
          UpperCamelCase__										=				self.image_processing_class(**self.image_processor_dict    )
          # create random PIL images
          UpperCamelCase__										=				prepare_image_inputs(self.image_processor_tester  ,					equal_resolution=__snake_case    )
          for image in image_inputs:
                self.assertIsInstance(__snake_case  ,					Image.Image    )

          # Test not batched input (GLPNImageProcessor doesn't support batching)
          UpperCamelCase__										=				image_processing(image_inputs[0]  ,					return_tensors="pt"    ).pixel_values
          self.assertTrue(encoded_images.shape[-1] % self.image_processor_tester.size_divisor == 0    )
          self.assertTrue(encoded_images.shape[-2] % self.image_processor_tester.size_divisor == 0    )


    def    __a							(     self    ):
          # Initialize image_processing
          UpperCamelCase__										=				self.image_processing_class(**self.image_processor_dict    )
          # create random numpy tensors
          UpperCamelCase__										=				prepare_image_inputs(self.image_processor_tester  ,					equal_resolution=__snake_case  ,					numpify=__snake_case    )
          for image in image_inputs:
                self.assertIsInstance(__snake_case  ,					np.ndarray    )

          # Test not batched input (GLPNImageProcessor doesn't support batching)
          UpperCamelCase__										=				image_processing(image_inputs[0]  ,					return_tensors="pt"    ).pixel_values
          self.assertTrue(encoded_images.shape[-1] % self.image_processor_tester.size_divisor == 0    )
          self.assertTrue(encoded_images.shape[-2] % self.image_processor_tester.size_divisor == 0    )


    def    __a							(     self    ):
          # Initialize image_processing
          UpperCamelCase__										=				self.image_processing_class(**self.image_processor_dict    )
          # create random PyTorch tensors
          UpperCamelCase__										=				prepare_image_inputs(self.image_processor_tester  ,					equal_resolution=__snake_case  ,					torchify=__snake_case    )
          for image in image_inputs:
                self.assertIsInstance(__snake_case  ,					torch.Tensor    )

          # Test not batched input (GLPNImageProcessor doesn't support batching)
          UpperCamelCase__										=				image_processing(image_inputs[0]  ,					return_tensors="pt"    ).pixel_values
          self.assertTrue(encoded_images.shape[-1] % self.image_processor_tester.size_divisor == 0    )
          self.assertTrue(encoded_images.shape[-2] % self.image_processor_tester.size_divisor == 0    )









'''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 			snake_case_   (  SCREAMING_SNAKE_CASE__     ):







				"""simple docstring"""





				_SCREAMING_SNAKE_CASE :       Tuple     		=      []
				_SCREAMING_SNAKE_CASE :       Dict     		=      []
				_SCREAMING_SNAKE_CASE :       str     		=      []

				for rt in rc.restypes:
								_SCREAMING_SNAKE_CASE :       Optional[int]     		=      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 :       Optional[Any]     		=      {name: i for i, name in enumerate(SCREAMING_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     )

				_SCREAMING_SNAKE_CASE :       Dict     		=      torch.tensor(
				    SCREAMING_SNAKE_CASE__							,      dtype=torch.intaa							,      device=protein["""aatype"""].device							,      )
				_SCREAMING_SNAKE_CASE :       Optional[Any]     		=      torch.tensor(
				    SCREAMING_SNAKE_CASE__							,      dtype=torch.intaa							,      device=protein["""aatype"""].device							,      )
				_SCREAMING_SNAKE_CASE :       str     		=      torch.tensor(
				    SCREAMING_SNAKE_CASE__							,      dtype=torch.floataa							,      device=protein["""aatype"""].device							,      )
				_SCREAMING_SNAKE_CASE :       int     		=      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 :       List[str]     		=      restype_atomaa_to_atomaa[protein_aatype]
				_SCREAMING_SNAKE_CASE :       str     		=      restype_atomaa_mask[protein_aatype]

				_SCREAMING_SNAKE_CASE :       List[Any]     		=      residx_atomaa_mask
				_SCREAMING_SNAKE_CASE :       List[str]     		=      residx_atomaa_to_atomaa.long()

				# create the gather indices for mapping back
				_SCREAMING_SNAKE_CASE :       int     		=      restype_atomaa_to_atomaa[protein_aatype]
				_SCREAMING_SNAKE_CASE :       Dict     		=      residx_atomaa_to_atomaa.long()

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

				_SCREAMING_SNAKE_CASE :       int     		=      restype_atomaa_mask[protein_aatype]
				_SCREAMING_SNAKE_CASE :       int     		=      residx_atomaa_mask

				return protein







def 			snake_case_   (  SCREAMING_SNAKE_CASE__     ):







				"""simple docstring"""





				_SCREAMING_SNAKE_CASE :       Optional[Any]     		=      tree_map(lambda SCREAMING_SNAKE_CASE__     : torch.tensor(SCREAMING_SNAKE_CASE__							,      device=batch["""aatype"""].device     )							,      SCREAMING_SNAKE_CASE__							,      np.ndarray     )
				_SCREAMING_SNAKE_CASE :       Optional[Any]     		=      tensor_tree_map(lambda SCREAMING_SNAKE_CASE__     : np.array(SCREAMING_SNAKE_CASE__     )							,      make_atomaa_masks(SCREAMING_SNAKE_CASE__     )     )
				return out




