




"""simple docstring"""

from typing import Dict, List, Optional, Union

import numpy as np

from ...image_processing_utils import BaseImageProcessor, BatchFeature, get_size_dict
from ...image_transforms import center_crop, normalize, rescale, resize, to_channel_dimension_format
from ...image_utils import (
    IMAGENET_STANDARD_MEAN,
    IMAGENET_STANDARD_STD,
    ChannelDimension,
    ImageInput,
    PILImageResampling,
    make_list_of_images,
    to_numpy_array,
    valid_images,
)
from ...utils import TensorType, is_vision_available, logging


if is_vision_available():
		import PIL


_lowerCamelCase					:     List[str]				       =    logging.get_logger(__name__)

class     lowercase (      __UpperCAmelCase):
				__lowerCAmelCase      :      str					    =				["""pixel_values"""]







				def __init__(							self				:   Any ,       _lowerCamelCase				:   bool = True ,       _lowerCamelCase				:   Dict[str, int] = None ,       _lowerCamelCase				:   PILImageResampling = PIL.Image.NEAREST ,       _lowerCamelCase				:   bool = False ,       _lowerCamelCase				:   Dict[str, int] = None ,       _lowerCamelCase				:   Union[int, float] = 1 / 2_55 ,       _lowerCamelCase				:   bool = False ,       _lowerCamelCase				:   bool = True ,       _lowerCamelCase				:   bool = True ,       _lowerCamelCase				:   Optional[Union[float, List[float]]] = None ,       _lowerCamelCase				:   Optional[Union[float, List[float]]] = None ,       _lowerCamelCase				:   bool = True ,       **_lowerCamelCase				:   str ,       ):



					"""simple docstring"""

					super().__init__(**_lowerCamelCase    )
					A_					:			Dict						=						size if size is not None else {'''height''': 3_46, '''width''': 3_46}
					A_					:			List[Any]						=						get_size_dict(_lowerCamelCase    )
					A_					:			List[Any]						=						crop_size if crop_size is not None else {'''height''': 2_89, '''width''': 2_89}
					A_					:			str						=						get_size_dict(_lowerCamelCase ,       param_name='''crop_size'''    )

					A_					:			Union[str, Any]						=						do_resize
					A_					:			List[str]						=						size
					A_					:			Tuple						=						resample
					A_					:			List[Any]						=						do_center_crop
					A_					:			Optional[int]						=						crop_size
					A_					:			Any						=						do_rescale
					A_					:			List[Any]						=						rescale_factor
					A_					:			str						=						rescale_offset
					A_					:			List[Any]						=						do_normalize
					A_					:			Dict						=						image_mean if image_mean is not None else IMAGENET_STANDARD_MEAN
					A_					:			Tuple						=						image_std if image_std is not None else IMAGENET_STANDARD_STD
					A_					:			List[str]						=						include_top







				def    a_					(							self				:   Union[str, Any] ,       _lowerCamelCase				:   np.ndarray ,       _lowerCamelCase				:   Dict[str, int] ,       _lowerCamelCase				:   PILImageResampling = PIL.Image.NEAREST ,       _lowerCamelCase				:   Optional[Union[str, ChannelDimension]] = None ,       **_lowerCamelCase				:   List[Any] ,       ):



					"""simple docstring"""

					A_					:			Dict						=						get_size_dict(_lowerCamelCase    )
					if "height" not in size or "width" not in size:
						raise ValueError(F"""The size dictionary must have keys 'height' and 'width'. Got {size.keys()}"""    )
					return resize(
					    _lowerCamelCase ,       size=(size['''height'''], size['''width''']) ,       resample=_lowerCamelCase ,       data_format=_lowerCamelCase ,       **_lowerCamelCase    )







				def    a_					(							self				:   Optional[int] ,       _lowerCamelCase				:   np.ndarray ,       _lowerCamelCase				:   Dict[str, int] ,       _lowerCamelCase				:   Optional[Union[str, ChannelDimension]] = None ,       **_lowerCamelCase				:   Union[str, Any] ,       ):



					"""simple docstring"""

					A_					:			Optional[int]						=						get_size_dict(_lowerCamelCase    )
					if "height" not in size or "width" not in size:
						raise ValueError(F"""The size dictionary must have keys 'height' and 'width'. Got {size.keys()}"""    )
					return center_crop(_lowerCamelCase ,       size=(size['''height'''], size['''width''']) ,       data_format=_lowerCamelCase ,       **_lowerCamelCase    )







				def    a_					(							self				:   Dict ,       _lowerCamelCase				:   np.ndarray ,       _lowerCamelCase				:   Union[int, float] ,       _lowerCamelCase				:   bool = True ,       _lowerCamelCase				:   Optional[Union[str, ChannelDimension]] = None ,       **_lowerCamelCase				:   Union[str, Any] ,       ):



					"""simple docstring"""

					if offset:
						A_					:			int						=						(image - 127.5) * scale
						if data_format is not None:
							A_					:			List[str]						=						to_channel_dimension_format(_lowerCamelCase ,       _lowerCamelCase    )
						A_					:			Dict						=						rescaled_image.astype(np.floataa    )
					else:
						A_					:			Tuple						=						rescale(_lowerCamelCase ,       scale=_lowerCamelCase ,       data_format=_lowerCamelCase ,       **_lowerCamelCase    )
					return rescaled_image







				def    a_					(							self				:   str ,       _lowerCamelCase				:   np.ndarray ,       _lowerCamelCase				:   Union[float, List[float]] ,       _lowerCamelCase				:   Union[float, List[float]] ,       _lowerCamelCase				:   Optional[Union[str, ChannelDimension]] = None ,       **_lowerCamelCase				:   int ,       ):



					"""simple docstring"""

					return normalize(_lowerCamelCase ,       mean=_lowerCamelCase ,       std=_lowerCamelCase ,       data_format=_lowerCamelCase ,       **_lowerCamelCase    )







				def    a_					(							self				:   Union[str, Any] ,       _lowerCamelCase				:   ImageInput ,       _lowerCamelCase				:   bool = None ,       _lowerCamelCase				:   Dict[str, int] = None ,       _lowerCamelCase				:   List[Any]=None ,       _lowerCamelCase				:   bool = None ,       _lowerCamelCase				:   Dict[str, int] = None ,       _lowerCamelCase				:   bool = None ,       _lowerCamelCase				:   float = None ,       _lowerCamelCase				:   bool = None ,       _lowerCamelCase				:   bool = None ,       _lowerCamelCase				:   Optional[Union[float, List[float]]] = None ,       _lowerCamelCase				:   Optional[Union[float, List[float]]] = None ,       _lowerCamelCase				:   bool = None ,       _lowerCamelCase				:   Optional[Union[str, TensorType]] = None ,       _lowerCamelCase				:   ChannelDimension = ChannelDimension.FIRST ,       **_lowerCamelCase				:   Optional[int] ,       ):



					"""simple docstring"""

					A_					:			Optional[Any]						=						do_resize if do_resize is not None else self.do_resize
					A_					:			Any						=						resample if resample is not None else self.resample
					A_					:			Union[str, Any]						=						do_center_crop if do_center_crop is not None else self.do_center_crop
					A_					:			List[str]						=						do_rescale if do_rescale is not None else self.do_rescale
					A_					:			Tuple						=						rescale_factor if rescale_factor is not None else self.rescale_factor
					A_					:			Optional[int]						=						rescale_offset if rescale_offset is not None else self.rescale_offset
					A_					:			int						=						do_normalize if do_normalize is not None else self.do_normalize
					A_					:			Union[str, Any]						=						image_mean if image_mean is not None else self.image_mean
					A_					:			Dict						=						image_std if image_std is not None else self.image_std
					A_					:			int						=						include_top if include_top is not None else self.include_top

					A_					:			Union[str, Any]						=						size if size is not None else self.size
					A_					:			Optional[Any]						=						get_size_dict(_lowerCamelCase    )
					A_					:			List[str]						=						crop_size if crop_size is not None else self.crop_size
					A_					:			List[str]						=						get_size_dict(_lowerCamelCase ,       param_name='''crop_size'''    )

					A_					:			List[Any]						=						make_list_of_images(_lowerCamelCase    )

					if not valid_images(_lowerCamelCase    ):
						raise ValueError(
						    '''Invalid image type. Must be of type PIL.Image.Image, numpy.ndarray, '''
						    '''torch.Tensor, tf.Tensor or jax.ndarray.'''    )

					if do_resize and size is None or resample is None:
						raise ValueError('''Size and resample must be specified if do_resize is True.'''    )

					if do_center_crop and crop_size is None:
						raise ValueError('''Crop size must be specified if do_center_crop is True.'''    )

					if do_rescale and rescale_factor is None:
						raise ValueError('''Rescale factor must be specified if do_rescale is True.'''    )

					if do_normalize and (image_mean is None or image_std is None):
						raise ValueError('''Image mean and std must be specified if do_normalize is True.'''    )

					# All transformations expect numpy arrays.
					A_					:			List[Any]						=						[to_numpy_array(_lowerCamelCase    ) for image in images]

					if do_resize:
						A_					:			Any						=						[self.resize(image=_lowerCamelCase ,       size=_lowerCamelCase ,       resample=_lowerCamelCase    ) for image in images]

					if do_center_crop:
						A_					:			List[Any]						=						[self.center_crop(image=_lowerCamelCase ,       size=_lowerCamelCase    ) for image in images]

					if do_rescale:
						A_					:			Optional[int]						=						[self.rescale(image=_lowerCamelCase ,       scale=_lowerCamelCase ,       offset=_lowerCamelCase    ) for image in images]

					if do_normalize:
						A_					:			Tuple						=						[self.normalize(image=_lowerCamelCase ,       mean=_lowerCamelCase ,       std=_lowerCamelCase    ) for image in images]

					if include_top:
						A_					:			List[Any]						=						[self.normalize(image=_lowerCamelCase ,       mean=[0, 0, 0] ,       std=_lowerCamelCase    ) for image in images]

					A_					:			Optional[Any]						=						[to_channel_dimension_format(_lowerCamelCase ,       _lowerCamelCase    ) for image in images]

					A_					:			str						=						{'''pixel_values''': images}
					return BatchFeature(data=_lowerCamelCase ,       tensor_type=_lowerCamelCase    )











"""simple docstring"""

from .chunk_utils import chunk_layer
from .data_transforms import make_atomaa_masks
from .feats import atomaa_to_atomaa, frames_and_literature_positions_to_atomaa_pos, torsion_angles_to_frames
from .loss import compute_predicted_aligned_error, compute_tm
from .protein import Protein as OFProtein
from .protein import to_pdb
from .rigid_utils import Rigid, Rotation
from .tensor_utils import dict_multimap, flatten_final_dims, permute_final_dims





