





import gc
import unittest

import torch
from parameterized import parameterized

from diffusers import AutoencoderKL
from diffusers.utils import floats_tensor, load_hf_numpy, require_torch_gpu, slow, torch_all_close, torch_device
from diffusers.utils.import_utils import is_xformers_available
from diffusers.utils.testing_utils import enable_full_determinism

from .test_modeling_common import ModelTesterMixin, UNetTesterMixin


enable_full_determinism()



class    _a     (				lowercase__					,							lowercase__					,							unittest.TestCase							):






							"""simple docstring"""

							snake_case_							 =						AutoencoderKL
							snake_case_							 =						"sample"
							snake_case_							 =						1e-2

							@property
							def      A_  (      self				:     Union[str, Any]    )	->Any:
													SCREAMING_SNAKE_CASE__     :				Optional[int]   =					4
													SCREAMING_SNAKE_CASE__     :				List[str]   =					3
													SCREAMING_SNAKE_CASE__     :				str   =					(32, 32)

													SCREAMING_SNAKE_CASE__     :				List[Any]   =					floats_tensor((batch_size, num_channels) + sizes    ).to(a    )

													return {"sample": image}

							@property
							def      A_  (      self				:     Any    )	->Optional[Any]:
													return (3, 32, 32)

							@property
							def      A_  (      self				:     Any    )	->List[str]:
													return (3, 32, 32)

							def      A_  (      self				:     str    )	->Optional[Any]:
													SCREAMING_SNAKE_CASE__     :				int   =					{
													    "block_out_channels": [32, 64],
													    "in_channels": 3,
													    "out_channels": 3,
													    "down_block_types": ["DownEncoderBlock2D", "DownEncoderBlock2D"],
													    "up_block_types": ["UpDecoderBlock2D", "UpDecoderBlock2D"],
													    "latent_channels": 4,
													}
													SCREAMING_SNAKE_CASE__     :				List[str]   =					self.dummy_input
													return init_dict, inputs_dict

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

							def      A_  (      self				:     List[Any]    )	->List[str]:
													pass

							@unittest.skipIf(torch_device == "mps"							,	"Gradient checkpointing skipped on MPS"    )
							def      A_  (      self				:     Dict    )	->int:
													# enable deterministic behavior for gradient checkpointing
													SCREAMING_SNAKE_CASE__,							SCREAMING_SNAKE_CASE__     :				int   =					self.prepare_init_args_and_inputs_for_common()
													SCREAMING_SNAKE_CASE__     :				List[Any]   =					self.model_class(**a    )
													model.to(a    )

													assert not model.is_gradient_checkpointing and model.training

													SCREAMING_SNAKE_CASE__     :				List[str]   =					model(**a    ).sample
													# run the backwards pass on the model. For backwards pass, for simplicity purpose,
													# we won't calculate the loss and rather backprop on out.sum()
													model.zero_grad()

													SCREAMING_SNAKE_CASE__     :				Dict   =					torch.randn_like(a    )
													SCREAMING_SNAKE_CASE__     :				Optional[int]   =					(out - labels).mean()
													loss.backward()

													# re-instantiate the model now enabling gradient checkpointing
													SCREAMING_SNAKE_CASE__     :				Optional[int]   =					self.model_class(**a    )
													# clone model
													model_a.load_state_dict(model.state_dict()    )
													model_a.to(a    )
													model_a.enable_gradient_checkpointing()

													assert model_a.is_gradient_checkpointing and model_a.training

													SCREAMING_SNAKE_CASE__     :				Tuple   =					model_a(**a    ).sample
													# run the backwards pass on the model. For backwards pass, for simplicity purpose,
													# we won't calculate the loss and rather backprop on out.sum()
													model_a.zero_grad()
													SCREAMING_SNAKE_CASE__     :				int   =					(out_a - labels).mean()
													loss_a.backward()

													# compare the output and parameters gradients
													self.assertTrue((loss - loss_a).abs() < 1E-5    )
													SCREAMING_SNAKE_CASE__     :				Dict   =					dict(model.named_parameters()    )
													SCREAMING_SNAKE_CASE__     :				Union[str, Any]   =					dict(model_a.named_parameters()    )
													for name, param in named_params.items():
																			self.assertTrue(torch_all_close(param.grad.data							,	named_params_a[name].grad.data							,	atol=5E-5    )    )

							def      A_  (      self				:     Dict    )	->List[Any]:
													SCREAMING_SNAKE_CASE__,							SCREAMING_SNAKE_CASE__     :				Dict   =					AutoencoderKL.from_pretrained("fusing/autoencoder-kl-dummy"							,	output_loading_info=a    )
													self.assertIsNotNone(a    )
													self.assertEqual(len(loading_info["missing_keys"]    )							,	0    )

													model.to(a    )
													SCREAMING_SNAKE_CASE__     :				Union[str, Any]   =					model(**self.dummy_input    )

													assert image is not None, "Make sure output is not None"






							def      A_  (      self				:     List[str]    )	->Optional[Any]:
													SCREAMING_SNAKE_CASE__     :				Optional[int]   =					AutoencoderKL.from_pretrained("fusing/autoencoder-kl-dummy"    )
													SCREAMING_SNAKE_CASE__     :				int   =					model.to(a    )
													model.eval()

													if torch_device == "mps":
																			SCREAMING_SNAKE_CASE__     :				List[Any]   =					torch.manual_seed(0    )
													else:
																			SCREAMING_SNAKE_CASE__     :				Optional[Any]   =					torch.Generator(device=a    ).manual_seed(0    )

													SCREAMING_SNAKE_CASE__     :				Dict   =					torch.randn(
													    1							,	model.config.in_channels							,	model.config.sample_size							,	model.config.sample_size							,	generator=torch.manual_seed(0    )							,	)
													SCREAMING_SNAKE_CASE__     :				List[str]   =					image.to(a    )
													with torch.no_grad():
																			SCREAMING_SNAKE_CASE__     :				Optional[Any]   =					model(a							,	sample_posterior=a							,	generator=a    ).sample

													SCREAMING_SNAKE_CASE__     :				Optional[int]   =					output[0, -1, -3:, -3:].flatten().cpu()

													# Since the VAE Gaussian prior's generator is seeded on the appropriate device,
													# the expected output slices are not the same for CPU and GPU.
													if torch_device == "mps":
																			SCREAMING_SNAKE_CASE__     :				List[Any]   =					torch.tensor(
																			    [
																			        -4.0078E-01,
																			        -3.8323E-04,
																			        -1.2681E-01,
																			        -1.1462E-01,
																			        2.0095E-01,
																			        1.0893E-01,
																			        -8.8247E-02,
																			        -3.0361E-01,
																			        -9.8644E-03,
																			    ]    )
													elif torch_device == "cpu":
																			SCREAMING_SNAKE_CASE__     :				Optional[Any]   =					torch.tensor(
																			    [-0.1352, 0.0878, 0.0419, -0.0818, -0.1069, 0.0688, -0.1458, -0.4446, -0.0026]    )
													else:
																			SCREAMING_SNAKE_CASE__     :				Any   =					torch.tensor(
																			    [-0.2421, 0.4642, 0.2507, -0.0438, 0.0682, 0.3160, -0.2018, -0.0727, 0.2485]    )

													self.assertTrue(torch_all_close(a							,	a							,	rtol=1E-2    )    )







@slow
class    _a     (				unittest.TestCase							):






							"""simple docstring"""

							def      A_  (      self				:     Tuple							,	a				:     Union[str, Any]							,	a				:     Optional[int]    )	->int:
													return f"""gaussian_noise_s={seed}_shape={'_'.join([str(a    ) for s in shape]    )}.npy"""

							def      A_  (      self				:     Union[str, Any]    )	->int:
													# clean up the VRAM after each test
													super().tearDown()
													gc.collect()
													torch.cuda.empty_cache()

							def      A_  (      self				:     Dict							,	a				:     Any=0							,	a				:     int=(4, 3, 5_12, 5_12)							,	a				:     Tuple=False    )	->Dict:
													SCREAMING_SNAKE_CASE__     :				str   =					torch.floataa if fpaa else torch.floataa
													SCREAMING_SNAKE_CASE__     :				Any   =					torch.from_numpy(load_hf_numpy(self.get_file_format(a							,	a    )    )    ).to(a    ).to(a    )
													return image

							def      A_  (      self				:     Optional[int]							,	a				:     Optional[Any]="CompVis/stable-diffusion-v1-4"							,	a				:     str=False    )	->Any:
													SCREAMING_SNAKE_CASE__     :				Optional[Any]   =					"fp16" if fpaa else None
													SCREAMING_SNAKE_CASE__     :				str   =					torch.floataa if fpaa else torch.floataa

													SCREAMING_SNAKE_CASE__     :				Union[str, Any]   =					AutoencoderKL.from_pretrained(
													    a							,	subfolder="vae"							,	torch_dtype=a							,	revision=a							,	)
													model.to(a    ).eval()

													return model

							def      A_  (      self				:     Optional[int]							,	a				:     Optional[int]=0    )	->List[Any]:
													if torch_device == "mps":
																			return torch.manual_seed(a    )
													return torch.Generator(device=a    ).manual_seed(a    )

							@parameterized.expand(
							    [
							        # fmt: off
							        [33, [-0.1603, 0.9878, -0.0495, -0.0790, -0.2709, 0.8375, -0.2060, -0.0824], [-0.2395, 0.0098, 0.0102, -0.0709, -0.2840, -0.0274, -0.0718, -0.1824]],
							        [47, [-0.2376, 0.1168, 0.1332, -0.4840, -0.2508, -0.0791, -0.0493, -0.4089], [0.0350, 0.0847, 0.0467, 0.0344, -0.0842, -0.0547, -0.0633, -0.1131]],
							        # fmt: on
							    ]    )
							def      A_  (      self				:     Optional[int]							,	a				:     str							,	a				:     Optional[Any]							,	a				:     Optional[int]    )	->Optional[int]:
													SCREAMING_SNAKE_CASE__     :				Dict   =					self.get_sd_vae_model()
													SCREAMING_SNAKE_CASE__     :				List[str]   =					self.get_sd_image(a    )
													SCREAMING_SNAKE_CASE__     :				List[Any]   =					self.get_generator(a    )

													with torch.no_grad():
																			SCREAMING_SNAKE_CASE__     :				List[str]   =					model(a							,	generator=a							,	sample_posterior=a    ).sample

													assert sample.shape == image.shape

													SCREAMING_SNAKE_CASE__     :				Dict   =					sample[-1, -2:, -2:, :2].flatten().float().cpu()
													SCREAMING_SNAKE_CASE__     :				Optional[int]   =					torch.tensor(expected_slice_mps if torch_device == "mps" else expected_slice    )

													assert torch_all_close(a							,	a							,	atol=3E-3    )

							@parameterized.expand(
							    [
							        # fmt: off
							        [33, [-0.0513, 0.0289, 1.3799, 0.2166, -0.2573, -0.0871, 0.5103, -0.0999]],
							        [47, [-0.4128, -0.1320, -0.3704, 0.1965, -0.4116, -0.2332, -0.3340, 0.2247]],
							        # fmt: on
							    ]    )
							@require_torch_gpu
							def      A_  (      self				:     List[str]							,	a				:     List[str]							,	a				:     Any    )	->Any:
													SCREAMING_SNAKE_CASE__     :				int   =					self.get_sd_vae_model(fpaa=a    )
													SCREAMING_SNAKE_CASE__     :				Optional[int]   =					self.get_sd_image(a							,	fpaa=a    )
													SCREAMING_SNAKE_CASE__     :				Optional[Any]   =					self.get_generator(a    )

													with torch.no_grad():
																			SCREAMING_SNAKE_CASE__     :				Optional[Any]   =					model(a							,	generator=a							,	sample_posterior=a    ).sample

													assert sample.shape == image.shape

													SCREAMING_SNAKE_CASE__     :				Union[str, Any]   =					sample[-1, -2:, :2, -2:].flatten().float().cpu()
													SCREAMING_SNAKE_CASE__     :				int   =					torch.tensor(a    )

													assert torch_all_close(a							,	a							,	atol=1E-2    )

							@parameterized.expand(
							    [
							        # fmt: off
							        [33, [-0.1609, 0.9866, -0.0487, -0.0777, -0.2716, 0.8368, -0.2055, -0.0814], [-0.2395, 0.0098, 0.0102, -0.0709, -0.2840, -0.0274, -0.0718, -0.1824]],
							        [47, [-0.2377, 0.1147, 0.1333, -0.4841, -0.2506, -0.0805, -0.0491, -0.4085], [0.0350, 0.0847, 0.0467, 0.0344, -0.0842, -0.0547, -0.0633, -0.1131]],
							        # fmt: on
							    ]    )
							def      A_  (      self				:     List[Any]							,	a				:     Tuple							,	a				:     Optional[int]							,	a				:     Union[str, Any]    )	->Union[str, Any]:
													SCREAMING_SNAKE_CASE__     :				Tuple   =					self.get_sd_vae_model()
													SCREAMING_SNAKE_CASE__     :				Dict   =					self.get_sd_image(a    )

													with torch.no_grad():
																			SCREAMING_SNAKE_CASE__     :				Optional[int]   =					model(a    ).sample

													assert sample.shape == image.shape

													SCREAMING_SNAKE_CASE__     :				Optional[Any]   =					sample[-1, -2:, -2:, :2].flatten().float().cpu()
													SCREAMING_SNAKE_CASE__     :				List[str]   =					torch.tensor(expected_slice_mps if torch_device == "mps" else expected_slice    )

													assert torch_all_close(a							,	a							,	atol=3E-3    )

							@parameterized.expand(
							    [
							        # fmt: off
							        [13, [-0.2051, -0.1803, -0.2311, -0.2114, -0.3292, -0.3574, -0.2953, -0.3323]],
							        [37, [-0.2632, -0.2625, -0.2199, -0.2741, -0.4539, -0.4990, -0.3720, -0.4925]],
							        # fmt: on
							    ]    )
							@require_torch_gpu
							def      A_  (      self				:     str							,	a				:     int							,	a				:     int    )	->str:
													SCREAMING_SNAKE_CASE__     :				Union[str, Any]   =					self.get_sd_vae_model()
													SCREAMING_SNAKE_CASE__     :				List[Any]   =					self.get_sd_image(a							,	shape=(3, 4, 64, 64)    )

													with torch.no_grad():
																			SCREAMING_SNAKE_CASE__     :				str   =					model.decode(a    ).sample

													assert list(sample.shape    ) == [3, 3, 5_12, 5_12]

													SCREAMING_SNAKE_CASE__     :				Tuple   =					sample[-1, -2:, :2, -2:].flatten().cpu()
													SCREAMING_SNAKE_CASE__     :				Tuple   =					torch.tensor(a    )

													assert torch_all_close(a							,	a							,	atol=1E-3    )

							@parameterized.expand(
							    [
							        # fmt: off
							        [27, [-0.0369, 0.0207, -0.0776, -0.0682, -0.1747, -0.1930, -0.1465, -0.2039]],
							        [16, [-0.1628, -0.2134, -0.2747, -0.2642, -0.3774, -0.4404, -0.3687, -0.4277]],
							        # fmt: on
							    ]    )
							@require_torch_gpu
							def      A_  (      self				:     Any							,	a				:     Tuple							,	a				:     Any    )	->str:
													SCREAMING_SNAKE_CASE__     :				Any   =					self.get_sd_vae_model(fpaa=a    )
													SCREAMING_SNAKE_CASE__     :				Optional[int]   =					self.get_sd_image(a							,	shape=(3, 4, 64, 64)							,	fpaa=a    )

													with torch.no_grad():
																			SCREAMING_SNAKE_CASE__     :				Union[str, Any]   =					model.decode(a    ).sample

													assert list(sample.shape    ) == [3, 3, 5_12, 5_12]

													SCREAMING_SNAKE_CASE__     :				Any   =					sample[-1, -2:, :2, -2:].flatten().float().cpu()
													SCREAMING_SNAKE_CASE__     :				Any   =					torch.tensor(a    )

													assert torch_all_close(a							,	a							,	atol=5E-3    )

							@parameterized.expand([(13,), (16,), (27,)]    )
							@require_torch_gpu
							@unittest.skipIf(not is_xformers_available()							,	reason="xformers is not required when using PyTorch 2.0."    )
							def      A_  (      self				:     Tuple							,	a				:     Optional[int]    )	->Optional[int]:
													SCREAMING_SNAKE_CASE__     :				List[Any]   =					self.get_sd_vae_model(fpaa=a    )
													SCREAMING_SNAKE_CASE__     :				Union[str, Any]   =					self.get_sd_image(a							,	shape=(3, 4, 64, 64)							,	fpaa=a    )

													with torch.no_grad():
																			SCREAMING_SNAKE_CASE__     :				List[str]   =					model.decode(a    ).sample

													model.enable_xformers_memory_efficient_attention()
													with torch.no_grad():
																			SCREAMING_SNAKE_CASE__     :				Tuple   =					model.decode(a    ).sample

													assert list(sample.shape    ) == [3, 3, 5_12, 5_12]

													assert torch_all_close(a							,	a							,	atol=1E-1    )

							@parameterized.expand([(13,), (16,), (37,)]    )
							@require_torch_gpu
							@unittest.skipIf(not is_xformers_available()							,	reason="xformers is not required when using PyTorch 2.0."    )
							def      A_  (      self				:     str							,	a				:     List[str]    )	->Union[str, Any]:
													SCREAMING_SNAKE_CASE__     :				Union[str, Any]   =					self.get_sd_vae_model()
													SCREAMING_SNAKE_CASE__     :				int   =					self.get_sd_image(a							,	shape=(3, 4, 64, 64)    )

													with torch.no_grad():
																			SCREAMING_SNAKE_CASE__     :				int   =					model.decode(a    ).sample

													model.enable_xformers_memory_efficient_attention()
													with torch.no_grad():
																			SCREAMING_SNAKE_CASE__     :				Tuple   =					model.decode(a    ).sample

													assert list(sample.shape    ) == [3, 3, 5_12, 5_12]

													assert torch_all_close(a							,	a							,	atol=1E-2    )






							@parameterized.expand(
							    [
							        # fmt: off
							        [33, [-0.3001, 0.0918, -2.6984, -3.9720, -3.2099, -5.0353, 1.7338, -0.2065, 3.4267]],
							        [47, [-1.5030, -4.3871, -6.0355, -9.1157, -1.6661, -2.7853, 2.1607, -5.0823, 2.5633]],
							        # fmt: on
							    ]    )
							def      A_  (      self				:     Any							,	a				:     int							,	a				:     List[Any]    )	->List[Any]:
													SCREAMING_SNAKE_CASE__     :				Optional[int]   =					self.get_sd_vae_model()
													SCREAMING_SNAKE_CASE__     :				List[str]   =					self.get_sd_image(a    )
													SCREAMING_SNAKE_CASE__     :				List[str]   =					self.get_generator(a    )

													with torch.no_grad():
																			SCREAMING_SNAKE_CASE__     :				Optional[int]   =					model.encode(a    ).latent_dist
																			SCREAMING_SNAKE_CASE__     :				Tuple   =					dist.sample(generator=a    )

													assert list(sample.shape    ) == [image.shape[0], 4] + [i // 8 for i in image.shape[2:]]

													SCREAMING_SNAKE_CASE__     :				List[Any]   =					sample[0, -1, -3:, -3:].flatten().cpu()
													SCREAMING_SNAKE_CASE__     :				Union[str, Any]   =					torch.tensor(a    )

													SCREAMING_SNAKE_CASE__     :				Optional[Any]   =					3E-3 if torch_device != "mps" else 1E-2
													assert torch_all_close(a							,	a							,	atol=a    )






import unittest
from typing import Dict, List, Optional, Union

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 BridgeTowerImageProcessor



class    _a     (				unittest.TestCase							):






							"""simple docstring"""

							def __init__(      self				:     Optional[int]							,	a				:     Any							,	a				:     bool = True							,	a				:     Dict[str, int] = None							,	a				:     int = 32							,	a				:     bool = True							,	a				:     Union[int, float] = 1 / 2_55							,	a				:     bool = True							,	a				:     bool = True							,	a				:     Optional[Union[float, List[float]]] = [0.4814_5466, 0.457_8275, 0.4082_1073]							,	a				:     Optional[Union[float, List[float]]] = [0.2686_2954, 0.2613_0258, 0.2757_7711]							,	a				:     bool = True							,	a				:     Any=7							,	a				:     str=30							,	a				:     Dict=4_00							,	a				:     Optional[int]=3							,	)	->int:
													SCREAMING_SNAKE_CASE__     :				int   =					parent
													SCREAMING_SNAKE_CASE__     :				Dict   =					do_resize
													SCREAMING_SNAKE_CASE__     :				List[str]   =					size if size is not None else {"shortest_edge": 2_88}
													SCREAMING_SNAKE_CASE__     :				List[Any]   =					size_divisor
													SCREAMING_SNAKE_CASE__     :				List[Any]   =					do_rescale
													SCREAMING_SNAKE_CASE__     :				Tuple   =					rescale_factor
													SCREAMING_SNAKE_CASE__     :				Optional[int]   =					do_normalize
													SCREAMING_SNAKE_CASE__     :				Union[str, Any]   =					do_center_crop
													SCREAMING_SNAKE_CASE__     :				Optional[int]   =					image_mean
													SCREAMING_SNAKE_CASE__     :				Dict   =					image_std
													SCREAMING_SNAKE_CASE__     :				List[str]   =					do_pad
													SCREAMING_SNAKE_CASE__     :				Union[str, Any]   =					batch_size
													SCREAMING_SNAKE_CASE__     :				int   =					num_channels
													SCREAMING_SNAKE_CASE__     :				Optional[int]   =					min_resolution
													SCREAMING_SNAKE_CASE__     :				Union[str, Any]   =					max_resolution

							def      A_  (      self				:     List[str]    )	->Tuple:
													return {
													    "image_mean": self.image_mean,
													    "image_std": self.image_std,
													    "do_normalize": self.do_normalize,
													    "do_resize": self.do_resize,
													    "size": self.size,
													    "size_divisor": self.size_divisor,
													}






							def      A_  (      self				:     int							,	a				:     Optional[int]							,	a				:     Union[str, Any]=False    )	->Optional[Any]:
													if not batched:
																			SCREAMING_SNAKE_CASE__     :				Union[str, Any]   =					self.size["shortest_edge"]
																			SCREAMING_SNAKE_CASE__     :				Dict   =					image_inputs[0]
																			if isinstance(a							,	Image.Image    ):
																									SCREAMING_SNAKE_CASE__,							SCREAMING_SNAKE_CASE__     :				Dict   =					image.size
																			else:
																									SCREAMING_SNAKE_CASE__,							SCREAMING_SNAKE_CASE__     :				List[str]   =					image.shape[1], image.shape[2]
																			SCREAMING_SNAKE_CASE__     :				Any   =					size / min(a							,	a    )
																			if h < w:
																									SCREAMING_SNAKE_CASE__,							SCREAMING_SNAKE_CASE__     :				Optional[int]   =					size, scale * w
																			else:
																									SCREAMING_SNAKE_CASE__,							SCREAMING_SNAKE_CASE__     :				List[str]   =					scale * h, size

																			SCREAMING_SNAKE_CASE__     :				List[Any]   =					int((13_33 / 8_00) * size    )
																			if max(a							,	a    ) > max_size:
																									SCREAMING_SNAKE_CASE__     :				List[Any]   =					max_size / max(a							,	a    )
																									SCREAMING_SNAKE_CASE__     :				int   =					newh * scale
																									SCREAMING_SNAKE_CASE__     :				Optional[int]   =					neww * scale

																			SCREAMING_SNAKE_CASE__,							SCREAMING_SNAKE_CASE__     :				Any   =					int(newh + 0.5    ), int(neww + 0.5    )
																			SCREAMING_SNAKE_CASE__,							SCREAMING_SNAKE_CASE__     :				Any   =					(
																			    newh // self.size_divisor * self.size_divisor,
																			    neww // self.size_divisor * self.size_divisor,
																			)

													else:
																			SCREAMING_SNAKE_CASE__     :				List[Any]   =					[]
																			for image in image_inputs:
																									SCREAMING_SNAKE_CASE__,							SCREAMING_SNAKE_CASE__     :				List[Any]   =					self.get_expected_values([image]    )
																									expected_values.append((expected_height, expected_width)    )
																			SCREAMING_SNAKE_CASE__     :				Tuple   =					max(a							,	key=lambda a    : item[0]    )[0]
																			SCREAMING_SNAKE_CASE__     :				Tuple   =					max(a							,	key=lambda a    : item[1]    )[1]

													return expected_height, expected_width







@require_torch
@require_vision
class    _a     (				lowercase__					,							unittest.TestCase							):






							"""simple docstring"""

							snake_case_							 =						BridgeTowerImageProcessor if is_vision_available() else None

							def      A_  (      self				:     List[Any]    )	->Union[str, Any]:
													SCREAMING_SNAKE_CASE__     :				Any   =					BridgeTowerImageProcessingTester(self    )

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

							def      A_  (      self				:     Tuple    )	->str:
													SCREAMING_SNAKE_CASE__     :				int   =					self.image_processing_class(**self.image_processor_dict    )
													self.assertTrue(hasattr(a							,	"image_mean"    )    )
													self.assertTrue(hasattr(a							,	"image_std"    )    )
													self.assertTrue(hasattr(a							,	"do_normalize"    )    )
													self.assertTrue(hasattr(a							,	"do_resize"    )    )
													self.assertTrue(hasattr(a							,	"size"    )    )
													self.assertTrue(hasattr(a							,	"size_divisor"    )    )

							def      A_  (      self				:     List[Any]    )	->List[Any]:
													pass

							def      A_  (      self				:     Tuple    )	->Optional[Any]:
													# Initialize image processor
													SCREAMING_SNAKE_CASE__     :				Dict   =					self.image_processing_class(**self.image_processor_dict    )
													# create random PIL images
													SCREAMING_SNAKE_CASE__     :				Union[str, Any]   =					prepare_image_inputs(self.image_processor_tester							,	equal_resolution=a    )
													for image in image_inputs:
																			self.assertIsInstance(a							,	Image.Image    )

													# Test not batched input
													SCREAMING_SNAKE_CASE__     :				List[Any]   =					image_processing(image_inputs[0]							,	return_tensors="pt"    ).pixel_values

													SCREAMING_SNAKE_CASE__,							SCREAMING_SNAKE_CASE__     :				Optional[Any]   =					self.image_processor_tester.get_expected_values(a    )
													self.assertEqual(
													    encoded_images.shape							,	(1, self.image_processor_tester.num_channels, expected_height, expected_width)							,	)

													# Test batched
													SCREAMING_SNAKE_CASE__     :				int   =					image_processing(a							,	return_tensors="pt"    ).pixel_values

													SCREAMING_SNAKE_CASE__,							SCREAMING_SNAKE_CASE__     :				Any   =					self.image_processor_tester.get_expected_values(a							,	batched=a    )
													self.assertEqual(
													    encoded_images.shape							,	(
													        self.image_processor_tester.batch_size,
													        self.image_processor_tester.num_channels,
													        expected_height,
													        expected_width,
													    )							,	)

							def      A_  (      self				:     Optional[int]    )	->Any:
													# Initialize image processor
													SCREAMING_SNAKE_CASE__     :				str   =					self.image_processing_class(**self.image_processor_dict    )
													# create random numpy tensors
													SCREAMING_SNAKE_CASE__     :				str   =					prepare_image_inputs(self.image_processor_tester							,	equal_resolution=a							,	numpify=a    )
													for image in image_inputs:
																			self.assertIsInstance(a							,	np.ndarray    )

													# Test not batched input
													SCREAMING_SNAKE_CASE__     :				Optional[Any]   =					image_processing(image_inputs[0]							,	return_tensors="pt"    ).pixel_values

													SCREAMING_SNAKE_CASE__,							SCREAMING_SNAKE_CASE__     :				List[Any]   =					self.image_processor_tester.get_expected_values(a    )
													self.assertEqual(
													    encoded_images.shape							,	(1, self.image_processor_tester.num_channels, expected_height, expected_width)							,	)

													# Test batched
													SCREAMING_SNAKE_CASE__     :				Tuple   =					image_processing(a							,	return_tensors="pt"    ).pixel_values

													SCREAMING_SNAKE_CASE__,							SCREAMING_SNAKE_CASE__     :				Union[str, Any]   =					self.image_processor_tester.get_expected_values(a							,	batched=a    )
													self.assertEqual(
													    encoded_images.shape							,	(
													        self.image_processor_tester.batch_size,
													        self.image_processor_tester.num_channels,
													        expected_height,
													        expected_width,
													    )							,	)






							def      A_  (      self				:     str    )	->Optional[int]:
													# Initialize image processor
													SCREAMING_SNAKE_CASE__     :				Dict   =					self.image_processing_class(**self.image_processor_dict    )
													# create random PyTorch tensors
													SCREAMING_SNAKE_CASE__     :				Union[str, Any]   =					prepare_image_inputs(self.image_processor_tester							,	equal_resolution=a							,	torchify=a    )
													for image in image_inputs:
																			self.assertIsInstance(a							,	torch.Tensor    )

													# Test not batched input
													SCREAMING_SNAKE_CASE__     :				Tuple   =					image_processing(image_inputs[0]							,	return_tensors="pt"    ).pixel_values

													SCREAMING_SNAKE_CASE__,							SCREAMING_SNAKE_CASE__     :				Tuple   =					self.image_processor_tester.get_expected_values(a    )
													self.assertEqual(
													    encoded_images.shape							,	(1, self.image_processor_tester.num_channels, expected_height, expected_width)							,	)

													# Test batched
													SCREAMING_SNAKE_CASE__     :				Any   =					image_processing(a							,	return_tensors="pt"    ).pixel_values

													SCREAMING_SNAKE_CASE__,							SCREAMING_SNAKE_CASE__     :				Optional[Any]   =					self.image_processor_tester.get_expected_values(a							,	batched=a    )
													self.assertEqual(
													    encoded_images.shape							,	(
													        self.image_processor_tester.batch_size,
													        self.image_processor_tester.num_channels,
													        expected_height,
													        expected_width,
													    )							,	)