




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


if is_torch_available():
      import torch

if is_vision_available():
      from PIL import Image

      from transformers import BlipImageProcessor






class      A     (						unittest.TestCase						):
     """simple docstring"""

     def __init__(      self					:				Tuple		,					A__					:				Optional[int]		,					A__					:				Any=7		,					A__					:				Optional[Any]=3		,					A__					:				List[Any]=1_8		,					A__					:				Union[str, Any]=3_0		,					A__					:				int=4_0_0		,					A__					:				str=True		,					A__					:				Any=None		,					A__					:				Dict=True		,					A__					:				Union[str, Any]=False		,					A__					:				Optional[Any]=[0.48145466, 0.4578275, 0.40821073]		,					A__					:				Tuple=[0.26862954, 0.26130258, 0.27577711]		,					A__					:				Dict=True		,					)			->    Optional[int]:
           lowerCamelCase__ 					=			size if size is not None else {'height': 2_0, 'width': 2_0}
           lowerCamelCase__ 					=			parent
           lowerCamelCase__ 					=			batch_size
           lowerCamelCase__ 					=			num_channels
           lowerCamelCase__ 					=			image_size
           lowerCamelCase__ 					=			min_resolution
           lowerCamelCase__ 					=			max_resolution
           lowerCamelCase__ 					=			do_resize
           lowerCamelCase__ 					=			size
           lowerCamelCase__ 					=			do_normalize
           lowerCamelCase__ 					=			image_mean
           lowerCamelCase__ 					=			image_std
           lowerCamelCase__ 					=			do_pad
           lowerCamelCase__ 					=			do_convert_rgb




     def 	__snake_case				(      self					:				Dict     )			->    Optional[Any]:
           return {
               "do_resize": self.do_resize,
               "size": self.size,
               "do_normalize": self.do_normalize,
               "image_mean": self.image_mean,
               "image_std": self.image_std,
               "do_convert_rgb": self.do_convert_rgb,
               "do_pad": self.do_pad,
           }




     def 	__snake_case				(      self					:				int		,					A__					:				Optional[int]=False		,					A__					:				str=False		,					A__					:				Any=False     )			->    List[str]:
           assert not (numpify and torchify), "You cannot specify both numpy and PyTorch tensors at the same time"

           if equal_resolution:
                 lowerCamelCase__ 					=			[]
                 for i in range(self.batch_size     ):
                       image_inputs.append(
                           np.random.randint(
                               2_5_5		,					size=(self.num_channels, self.max_resolution, self.max_resolution)		,					dtype=np.uinta     )     )
           else:
                 lowerCamelCase__ 					=			[]
                 for i in range(self.batch_size     ):
                       lowerCamelCase__					,						lowerCamelCase__ 					=			np.random.choice(np.arange(self.min_resolution		,					self.max_resolution     )		,					2     )
                       image_inputs.append(np.random.randint(2_5_5		,					size=(self.num_channels, width, height)		,					dtype=np.uinta     )     )

           if not numpify and not torchify:
                 # PIL expects the channel dimension as last dimension
                 lowerCamelCase__ 					=			[Image.fromarray(np.moveaxis(A__		,					0		,					-1     )     ) for x in image_inputs]

           if torchify:
                 lowerCamelCase__ 					=			[torch.from_numpy(A__     ) for x in image_inputs]

           return image_inputs






@require_torch
@require_vision
class      A     (						_lowerCAmelCase     ,  unittest.TestCase						):
     """simple docstring"""

     _snake_case:		Tuple       =BlipImageProcessor if is_vision_available() else None




     def 	__snake_case				(      self					:				str     )			->    Tuple:
           lowerCamelCase__ 					=			BlipImageProcessingTester(self     )




     @property
     def 	__snake_case				(      self					:				Optional[int]     )			->    Tuple:
           return self.image_processor_tester.prepare_image_processor_dict()




     def 	__snake_case				(      self					:				List[Any]     )			->    Union[str, Any]:
           lowerCamelCase__ 					=			self.image_processing_class(**self.image_processor_dict     )
           self.assertTrue(hasattr(A__		,					'do_resize'     )     )
           self.assertTrue(hasattr(A__		,					'size'     )     )
           self.assertTrue(hasattr(A__		,					'do_normalize'     )     )
           self.assertTrue(hasattr(A__		,					'image_mean'     )     )
           self.assertTrue(hasattr(A__		,					'image_std'     )     )
           self.assertTrue(hasattr(A__		,					'do_convert_rgb'     )     )




     def 	__snake_case				(      self					:				List[str]     )			->    Optional[int]:
           pass




     def 	__snake_case				(      self					:				str     )			->    Union[str, Any]:
           lowerCamelCase__ 					=			self.image_processing_class(**self.image_processor_dict     )
           # create random PIL images
           lowerCamelCase__ 					=			self.image_processor_tester.prepare_inputs(equal_resolution=A__     )
           for image in image_inputs:
                 self.assertIsInstance(A__		,					Image.Image     )

           # Test not batched input
           lowerCamelCase__ 					=			image_processor(image_inputs[0]		,					return_tensors='pt'     ).pixel_values
           self.assertEqual(
               encoded_images.shape		,					(
                   1,
                   self.image_processor_tester.num_channels,
                   self.image_processor_tester.size['height'],
                   self.image_processor_tester.size['width'],
               )		,					)

           # Test batched
           lowerCamelCase__ 					=			image_processor(A__		,					return_tensors='pt'     ).pixel_values
           self.assertEqual(
               encoded_images.shape		,					(
                   self.image_processor_tester.batch_size,
                   self.image_processor_tester.num_channels,
                   self.image_processor_tester.size['height'],
                   self.image_processor_tester.size['width'],
               )		,					)




     def 	__snake_case				(      self					:				Optional[Any]     )			->    str:
           lowerCamelCase__ 					=			self.image_processing_class(**self.image_processor_dict     )
           # create random numpy tensors
           lowerCamelCase__ 					=			self.image_processor_tester.prepare_inputs(equal_resolution=A__		,					numpify=A__     )
           for image in image_inputs:
                 self.assertIsInstance(A__		,					np.ndarray     )

           # Test not batched input
           lowerCamelCase__ 					=			image_processor(image_inputs[0]		,					return_tensors='pt'     ).pixel_values
           self.assertEqual(
               encoded_images.shape		,					(
                   1,
                   self.image_processor_tester.num_channels,
                   self.image_processor_tester.size['height'],
                   self.image_processor_tester.size['width'],
               )		,					)

           # Test batched
           lowerCamelCase__ 					=			image_processor(A__		,					return_tensors='pt'     ).pixel_values
           self.assertEqual(
               encoded_images.shape		,					(
                   self.image_processor_tester.batch_size,
                   self.image_processor_tester.num_channels,
                   self.image_processor_tester.size['height'],
                   self.image_processor_tester.size['width'],
               )		,					)




     def 	__snake_case				(      self					:				Optional[int]     )			->    List[Any]:
           lowerCamelCase__ 					=			self.image_processing_class(**self.image_processor_dict     )
           # create random PyTorch tensors
           lowerCamelCase__ 					=			self.image_processor_tester.prepare_inputs(equal_resolution=A__		,					torchify=A__     )
           for image in image_inputs:
                 self.assertIsInstance(A__		,					torch.Tensor     )

           # Test not batched input
           lowerCamelCase__ 					=			image_processor(image_inputs[0]		,					return_tensors='pt'     ).pixel_values
           self.assertEqual(
               encoded_images.shape		,					(
                   1,
                   self.image_processor_tester.num_channels,
                   self.image_processor_tester.size['height'],
                   self.image_processor_tester.size['width'],
               )		,					)

           # Test batched
           lowerCamelCase__ 					=			image_processor(A__		,					return_tensors='pt'     ).pixel_values
           self.assertEqual(
               encoded_images.shape		,					(
                   self.image_processor_tester.batch_size,
                   self.image_processor_tester.num_channels,
                   self.image_processor_tester.size['height'],
                   self.image_processor_tester.size['width'],
               )		,					)






@require_torch
@require_vision
class      A     (						_lowerCAmelCase     ,  unittest.TestCase						):
     """simple docstring"""

     _snake_case:		int       =BlipImageProcessor if is_vision_available() else None




     def 	__snake_case				(      self					:				List[Any]     )			->    Tuple:
           lowerCamelCase__ 					=			BlipImageProcessingTester(self		,					num_channels=4     )
           lowerCamelCase__ 					=			3




     @property
     def 	__snake_case				(      self					:				Dict     )			->    Dict:
           return self.image_processor_tester.prepare_image_processor_dict()




     def 	__snake_case				(      self					:				Union[str, Any]     )			->    Optional[Any]:
           lowerCamelCase__ 					=			self.image_processing_class(**self.image_processor_dict     )
           self.assertTrue(hasattr(A__		,					'do_resize'     )     )
           self.assertTrue(hasattr(A__		,					'size'     )     )
           self.assertTrue(hasattr(A__		,					'do_normalize'     )     )
           self.assertTrue(hasattr(A__		,					'image_mean'     )     )
           self.assertTrue(hasattr(A__		,					'image_std'     )     )
           self.assertTrue(hasattr(A__		,					'do_convert_rgb'     )     )




     def 	__snake_case				(      self					:				Any     )			->    int:
           pass




     def 	__snake_case				(      self					:				List[Any]     )			->    Tuple:
           lowerCamelCase__ 					=			self.image_processing_class(**self.image_processor_dict     )
           # create random PIL images
           lowerCamelCase__ 					=			self.image_processor_tester.prepare_inputs(equal_resolution=A__     )
           for image in image_inputs:
                 self.assertIsInstance(A__		,					Image.Image     )

           # Test not batched input
           lowerCamelCase__ 					=			image_processor(image_inputs[0]		,					return_tensors='pt'     ).pixel_values
           self.assertEqual(
               encoded_images.shape		,					(
                   1,
                   self.expected_encoded_image_num_channels,
                   self.image_processor_tester.size['height'],
                   self.image_processor_tester.size['width'],
               )		,					)

           # Test batched
           lowerCamelCase__ 					=			image_processor(A__		,					return_tensors='pt'     ).pixel_values
           self.assertEqual(
               encoded_images.shape		,					(
                   self.image_processor_tester.batch_size,
                   self.expected_encoded_image_num_channels,
                   self.image_processor_tester.size['height'],
                   self.image_processor_tester.size['width'],
               )		,					)








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      lowerCAmelCase_     (					lowerCamelCase:    torch.Tensor       ,			lowerCamelCase:    torch.Tensor       ,			lowerCamelCase:    None  )   ->     torch.Tensor:


      '''simple docstring'''




      ...

@overload
def      lowerCAmelCase_     (					lowerCamelCase:    torch.Tensor       ,			lowerCamelCase:    torch.Tensor       ,			lowerCamelCase:    torch.Tensor  )   ->     Tuple[torch.Tensor, torch.Tensor]:


      '''simple docstring'''




      ...

def      lowerCAmelCase_     (					lowerCamelCase:    Any       ,			lowerCamelCase:    Union[str, Any]       ,			lowerCamelCase:    Tuple  )   ->     int:


      '''simple docstring'''




      lowerCamelCase__ 					=			aatype == rc.restype_order['G']
      lowerCamelCase__ 					=			rc.atom_order['CA']
      lowerCamelCase__ 					=			rc.atom_order['CB']
      lowerCamelCase__ 					=			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:
            lowerCamelCase__ 					=			torch.where(
                lowerCamelCase       ,			all_atom_masks[..., ca_idx]       ,			all_atom_masks[..., cb_idx]       ,			)
            return pseudo_beta, pseudo_beta_mask
      else:
            return pseudo_beta

def      lowerCAmelCase_     (					lowerCamelCase:    torch.Tensor       ,			lowerCamelCase:    Dict[str, torch.Tensor]  )   ->     torch.Tensor:


      '''simple docstring'''




      lowerCamelCase__ 					=			batched_gather(
          lowerCamelCase       ,			batch['residx_atom37_to_atom14']       ,			dim=-2       ,			no_batch_dims=len(atomaa.shape[:-2]  )       ,			)

      lowerCamelCase__ 					=			atomaa_data * batch['atom37_atom_exists'][..., None]

      return atomaa_data

def      lowerCAmelCase_     (					lowerCamelCase:    Dict[str, torch.Tensor]  )   ->     torch.Tensor:


      '''simple docstring'''




      lowerCamelCase__ 					=			template_feats['template_aatype']
      lowerCamelCase__ 					=			template_feats['template_torsion_angles_sin_cos']
      lowerCamelCase__ 					=			template_feats['template_alt_torsion_angles_sin_cos']
      lowerCamelCase__ 					=			template_feats['template_torsion_angles_mask']
      lowerCamelCase__ 					=			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      lowerCAmelCase_     (					lowerCamelCase:    Dict[str, torch.Tensor]       ,			lowerCamelCase:    torch.types.Number       ,			lowerCamelCase:    torch.types.Number       ,			lowerCamelCase:    int       ,			lowerCamelCase:    bool = False       ,			lowerCamelCase:    float = 1e-20       ,			lowerCamelCase:    float = 1e8       ,			)   ->     torch.Tensor:


      '''simple docstring'''




      lowerCamelCase__ 					=			batch['template_pseudo_beta_mask']
      lowerCamelCase__ 					=			template_mask[..., None] * template_mask[..., None, :]

      # Compute distogram (this seems to differ slightly from Alg. 5)
      lowerCamelCase__ 					=			batch['template_pseudo_beta']
      lowerCamelCase__ 					=			torch.sum((tpb[..., None, :] - tpb[..., None, :, :]) ** 2       ,			dim=-1       ,			keepdim=lowerCamelCase  )
      lowerCamelCase__ 					=			torch.linspace(lowerCamelCase       ,			lowerCamelCase       ,			lowerCamelCase       ,			device=tpb.device  ) ** 2
      lowerCamelCase__ 					=			torch.cat([lower[1:], lower.new_tensor([inf]  )]       ,			dim=-1  )
      lowerCamelCase__ 					=			((dgram > lower) * (dgram < upper)).type(dgram.dtype  )

      lowerCamelCase__ 					=			[dgram, template_mask_ad[..., None]]

      lowerCamelCase__ 					=			nn.functional.one_hot(
          batch['template_aatype']       ,			rc.restype_num + 2       ,			)

      lowerCamelCase__ 					=			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  )  )

      lowerCamelCase__					,						lowerCamelCase__					,						lowerCamelCase__ 					=			[rc.atom_order[a] for a in ['N', 'CA', 'C']]
      lowerCamelCase__ 					=			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       ,			)
      lowerCamelCase__ 					=			rigids.get_trans()[..., None, :, :]
      lowerCamelCase__ 					=			rigids[..., None].invert_apply(lowerCamelCase  )

      lowerCamelCase__ 					=			torch.rsqrt(eps + torch.sum(rigid_vec**2       ,			dim=-1  )  )

      lowerCamelCase__ 					=			batch['template_all_atom_mask']
      lowerCamelCase__ 					=			t_aa_masks[..., n] * t_aa_masks[..., ca] * t_aa_masks[..., c]
      lowerCamelCase__ 					=			template_mask[..., None] * template_mask[..., None, :]

      lowerCamelCase__ 					=			inv_distance_scalar * template_mask_ad
      lowerCamelCase__ 					=			rigid_vec * inv_distance_scalar[..., None]

      if not use_unit_vector:
            lowerCamelCase__ 					=			unit_vector * 0.0

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

      lowerCamelCase__ 					=			torch.cat(lowerCamelCase       ,			dim=-1  )
      lowerCamelCase__ 					=			act * template_mask_ad[..., None]

      return act

def      lowerCAmelCase_     (					lowerCamelCase:    Dict[str, torch.Tensor]  )   ->     torch.Tensor:


      '''simple docstring'''




      lowerCamelCase__ 					=			nn.functional.one_hot(batch['extra_msa']       ,			23  )
      lowerCamelCase__ 					=			[
          msa_ahot,
          batch['extra_has_deletion'].unsqueeze(-1  ),
          batch['extra_deletion_value'].unsqueeze(-1  ),
      ]
      return torch.cat(lowerCamelCase       ,			dim=-1  )

def      lowerCAmelCase_     (					lowerCamelCase:    Rigid       ,			lowerCamelCase:    torch.Tensor       ,			lowerCamelCase:    torch.Tensor       ,			lowerCamelCase:    torch.Tensor       ,			)   ->     Rigid:


      '''simple docstring'''




      lowerCamelCase__ 					=			rrgdf[aatype, ...]

      # [*, N, 8] transformations, i.e.
      #   One [*, N, 8, 3, 3] rotation matrix and
      #   One [*, N, 8, 3]    translation matrix
      lowerCamelCase__ 					=			r.from_tensor_axa(lowerCamelCase  )

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

      # [*, N, 8, 2]
      lowerCamelCase__ 					=			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.

      lowerCamelCase__ 					=			alpha.new_zeros(default_r.get_rots().get_rot_mats().shape  )
      lowerCamelCase__ 					=			1
      lowerCamelCase__ 					=			alpha[..., 1]
      lowerCamelCase__ 					=			-alpha[..., 0]
      lowerCamelCase__ 					=			alpha

      lowerCamelCase__ 					=			default_r.compose(Rigid(Rotation(rot_mats=lowerCamelCase  )       ,			lowerCamelCase  )  )

      lowerCamelCase__ 					=			all_frames[..., 5]
      lowerCamelCase__ 					=			all_frames[..., 6]
      lowerCamelCase__ 					=			all_frames[..., 7]

      lowerCamelCase__ 					=			all_frames[..., 4]
      lowerCamelCase__ 					=			chia_frame_to_bb.compose(lowerCamelCase  )
      lowerCamelCase__ 					=			chia_frame_to_bb.compose(lowerCamelCase  )
      lowerCamelCase__ 					=			chia_frame_to_bb.compose(lowerCamelCase  )

      lowerCamelCase__ 					=			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       ,			)

      lowerCamelCase__ 					=			r[..., None].compose(lowerCamelCase  )

      return all_frames_to_global


def      lowerCAmelCase_     (					lowerCamelCase:    Rigid       ,			lowerCamelCase:    torch.Tensor       ,			lowerCamelCase:    torch.Tensor       ,			lowerCamelCase:    torch.Tensor       ,			lowerCamelCase:    torch.Tensor       ,			lowerCamelCase:    torch.Tensor       ,			)   ->     torch.Tensor:


      '''simple docstring'''




      lowerCamelCase__ 					=			group_idx[aatype, ...]

      # [*, N, 14, 8]
      lowerCamelCase__ 					=			nn.functional.one_hot(
          lowerCamelCase       ,			num_classes=default_frames.shape[-3]       ,			)

      # [*, N, 14, 8]
      lowerCamelCase__ 					=			r[..., None, :] * group_mask_one_hot

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

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

      # [*, N, 14, 3]
      lowerCamelCase__ 					=			lit_positions[aatype, ...]
      lowerCamelCase__ 					=			t_atoms_to_global.apply(lowerCamelCase  )
      lowerCamelCase__ 					=			pred_positions * atom_mask

      return pred_positions